# Immutable — cannot be changed after creation
# int, float, str, tuple, frozenset, bool

x = "hello"
x[0] = "H"  # TypeError! Strings are immutable
x = "Hello"  # This creates a NEW string, not modifying old one

# Mutable — can be changed in place
# list, dict, set, bytearray

my_list = [1, 2, 3]
my_list[0] = 10  # Works! Lists are mutable
print(my_list)   # [10, 2, 3]

# Why it matters:
# 1. Immutable objects are hashable (can be dict keys)
# 2. Mutable default arguments are a common bug:

def add_item(item, lst=[]):  # BAD! Shared default list
    lst.append(item)
    return lst

print(add_item(1))  # [1]
print(add_item(2))  # [1, 2] — NOT [2]!

# Fix:
def add_item(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

# List — ordered, mutable, allows duplicates
fruits = ["apple", "banana", "apple"]
fruits.append("cherry")

# Tuple — ordered, immutable, allows duplicates
coords = (10, 20, 30)
# coords[0] = 5  # TypeError!

# Set — unordered, mutable, NO duplicates
unique = {1, 2, 3, 2, 1}
print(unique)  # {1, 2, 3}

# Dictionary — key-value pairs, ordered (3.7+), mutable
student = {"name": "Rahul", "age": 22, "city": "Bangalore"}
student["grade"] = "A"  # add new key

# When to use which:
# List  → ordered collection, need index access
# Tuple → fixed data (coordinates, RGB), dict keys
# Set   → remove duplicates, membership testing (fast)
# Dict  → key-value mapping, lookups by key

# == checks VALUE equality
# is checks IDENTITY (same object in memory)

a = [1, 2, 3]
b = [1, 2, 3]
c = a

a == b  # True (same values)
a is b  # False (different objects)
a is c  # True (same object)

# Integer caching (Python caches -5 to 256):
x = 256
y = 256
x is y  # True (cached)

x = 257
y = 257
x is y  # False (not cached — new objects)

# Rule: always use == for comparison
# Use 'is' only for None checks: if x is None

# Reverse a string:
s = "hello"
reversed_s = s[::-1]  # "olleh" (slicing)

# Other methods:
reversed_s = "".join(reversed(s))

# Check palindrome:
def is_palindrome(s):
    s = s.lower().replace(" ", "")
    return s == s[::-1]

print(is_palindrome("madam"))    # True
print(is_palindrome("racecar"))  # True
print(is_palindrome("hello"))    # False

# String slicing is the most Pythonic approach.
# Interviewers expect you to know s[::-1]

# List comprehension = concise way to create lists

# Traditional loop:
squares = []
for i in range(10):
    squares.append(i ** 2)

# List comprehension (same result):
squares = [i ** 2 for i in range(10)]

# With condition:
evens = [i for i in range(20) if i % 2 == 0]

# Nested:
matrix = [[1,2,3], [4,5,6], [7,8,9]]
flat = [num for row in matrix for num in row]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Dict comprehension:
word_lengths = {word: len(word) for word in ["hello", "world"]}
# {"hello": 5, "world": 5}

# Set comprehension:
unique_lengths = {len(word) for word in ["hi", "hello", "hey"]}
# {2, 5, 3}

# When NOT to use:
# Complex logic — use a regular loop for readability
# Side effects — comprehensions are for creating data

lst = [1, 2, 3]

# append() — adds ONE element to the end
lst.append(4)        # [1, 2, 3, 4]
lst.append([5, 6])   # [1, 2, 3, 4, [5, 6]] — nested!

# extend() — adds EACH element from iterable
lst = [1, 2, 3]
lst.extend([4, 5])   # [1, 2, 3, 4, 5] — flat

# insert() — adds element at specific index
lst = [1, 2, 3]
lst.insert(1, "a")   # [1, "a", 2, 3]

# Common mistake:
# Using append when you mean extend
# append([4,5]) gives nested list
# extend([4,5]) gives flat list

# *args — variable number of positional arguments (tuple)
def add(*args):
    return sum(args)

add(1, 2, 3)      # 6
add(1, 2, 3, 4, 5) # 15

# **kwargs — variable number of keyword arguments (dict)
def greet(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

greet(name="Priya", age=22, city="Mumbai")
# name: Priya
# age: 22
# city: Mumbai

# Both together:
def func(a, b, *args, **kwargs):
    print(a, b)       # positional
    print(args)        # extra positional as tuple
    print(kwargs)      # extra keyword as dict

func(1, 2, 3, 4, x=5, y=6)
# 1 2
# (3, 4)
# {'x': 5, 'y': 6}

# Lambda = anonymous, single-expression function

# Regular function:
def square(x):
    return x ** 2

# Lambda equivalent:
square = lambda x: x ** 2

# Common use cases:
# 1. Sorting with custom key
students = [("Rahul", 85), ("Priya", 92), ("Amit", 78)]
students.sort(key=lambda x: x[1])  # sort by marks

# 2. With map/filter
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
evens = list(filter(lambda x: x%2 == 0, numbers))

# 3. With sorted
words = ["banana", "apple", "cherry"]
sorted_words = sorted(words, key=lambda w: len(w))

# When NOT to use lambda:
# Multi-line logic — use a regular function
# Complex conditions — readability matters
# Reusable logic — name it with def

# Decorator = function that modifies another function

def timer(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end-start:.2f}s")
        return result
    return wrapper

@timer
def slow_function():
    import time
    time.sleep(1)
    return "done"

slow_function()  # prints: slow_function took 1.00s

# Common built-in decorators:
# @staticmethod — no self parameter
# @classmethod — cls parameter instead of self
# @property — access method like an attribute

# Decorators are syntactic sugar for:
# slow_function = timer(slow_function)

# Encapsulation — bundling data + methods
class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # private (name mangling)
    
    def deposit(self, amount):
        self.__balance += amount
    
    def get_balance(self):
        return self.__balance

# Inheritance
class Animal:
    def speak(self):
        return "..."

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

# Polymorphism — same interface, different behavior
animals = [Dog(), Cat()]
for animal in animals:
    print(animal.speak())  # Woof! then Meow!

# Abstraction
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2

# Multiple inheritance (Python supports it):
class A:
    pass
class B:
    pass
class C(A, B):  # inherits from both A and B
    pass

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")
except (TypeError, ValueError) as e:
    print(f"Type/Value error: {e}")
except Exception as e:
    print(f"Unexpected: {e}")
else:
    print("No error occurred")  # runs if NO exception
finally:
    print("Always runs")  # cleanup code

# Custom exception:
class InsufficientFundsError(Exception):
    def __init__(self, balance, amount):
        self.message = f"Cannot withdraw {amount}. Balance: {balance}"
        super().__init__(self.message)

# Raise custom exception:
raise InsufficientFundsError(100, 500)

# Key difference from Java:
# Python uses try/except (not try/catch)
# Python has else block (runs if no exception)

# Without 'with' — must manually close file:
f = open("data.txt", "r")
content = f.read()
f.close()  # easy to forget!

# With 'with' — auto-closes file:
with open("data.txt", "r") as f:
    content = f.read()
# file is automatically closed here

# 'with' uses context managers (__enter__ and __exit__)
# It guarantees cleanup even if an exception occurs

# File modes:
# "r"  — read (default)
# "w"  — write (overwrites)
# "a"  — append
# "r+" — read + write
# "rb" — read binary (images, PDFs)