Python Mastery

01 The Basics

What is Python?

Python is an interpreted, dynamically typed, garbage-collected language.

• Interpreted — Executed line-by-line by CPython. No compile step like C/Java.
• Dynamically typed — Types live with the value, not the variable. x = 5 then x = "hi" — totally fine.
• Garbage-collected — Memory is freed automatically when no longer used.

# How Python runs your code behind the scenes:
# 1. Lexer tokenizes your source code
# 2. Parser builds an AST (Abstract Syntax Tree)
# 3. Compiler turns AST → bytecode (.pyc files)
# 4. Python Virtual Machine (PVM) executes bytecode

# You can actually SEE the bytecode:
import dis
dis.dis(lambda: print("hello"))
# LOAD_GLOBAL    0 (print)
# LOAD_CONST     1 ('hello')
# CALL_FUNCTION  1
# RETURN_VALUE

Variables & Data Types

A variable is a name that points to an object in memory. It's a label stuck on a box, not a box itself.

# ── Basic types ──
name = "Yatin"           # str
age = 25                  # int
height = 5.9              # float
is_dev = True             # bool
nothing = None            # NoneType

print(type(name))    # <class 'str'>
print(type(age))     # <class 'int'>

# ── Everything is an object ──
x = 42
print(id(x))      # memory address
print(type(x))    # <class 'int'>

# Two names can point to the SAME object
y = x
print(id(x) == id(y))  # True

# Python caches small integers (-5 to 256)
a = 256
b = 256
print(a is b)  # True — same cached object

Mutable vs Immutable

Immutable objects can't be changed after creation — modifying them creates a new object. Mutable objects can be changed in-place.

# Immutable — "changing" creates a NEW object
s = "hello"
print(id(s))      # 4377001200
s = s + " world"
print(id(s))      # 4377055600 — different object!

# Mutable — you modify the SAME object
lst = [1, 2, 3]
print(id(lst))    # 4377102400
lst.append(4)
print(id(lst))    # 4377102400 — same object!

Operators

Symbols that perform operations on values — arithmetic, comparison, logic, and assignment.

# ── Arithmetic ──
print(10 / 3)     # 3.333 (true division — ALWAYS float)
print(10 // 3)    # 3     (floor division)
print(10 % 3)     # 1     (modulo)
print(10 ** 3)    # 1000  (power)

# ── Identity: is vs == ──
a = [1, 2]
b = [1, 2]
print(a == b)     # True  — same VALUE
print(a is b)     # False — different OBJECTS

# ── Short-circuit ──
print("" or "default")       # "default" — common pattern!
print("hello" and "world")   # "world"

# ── Walrus operator := (3.8+) ──
data = [1, 2, 3, 4, 5]
if (n := len(data)) > 3:
    print(f"Too many: {n}")  # Too many: 5

# ── Truthy / Falsy ──
# Falsy: False, 0, 0.0, "", [], {}, set(), None
# Everything else is Truthy
print(bool([]))       # False
print(bool([0]))      # True — list has an element

Type Conversion

Convert between types using built-in functions like int(), str(), float(), and list().

x = "42"
print(int(x))       # 42
print(float(x))     # 42.0
print(str(42))      # "42"
print(bool(0))      # False
print(list("abc"))  # ['a', 'b', 'c']

02 Strings

Strings are immutable sequences of Unicode characters. Every operation creates a new string.

# ── Creation ──
s1 = 'single'
s2 = "double"                           # identical
s3 = """multi
line"""
s4 = r"raw: \n stays literal"           # no escape processing

# ── f-strings (THE way to format) ──
name = "Yatin"
print(f"Hello {name}")                  # Hello Yatin
print(f"{3.14159:.2f}")                  # 3.14
print(f"{1000000:,}")                    # 1,000,000
print(f"{'hello':*^20}")                 # *******hello********

# ── Indexing & Slicing ──
s = "Python"
print(s[0])        # P
print(s[-1])       # n
print(s[0:3])      # Pyt    (stop is EXCLUDED)
print(s[::-1])      # nohtyP (reverse)

# ── Common Methods ──
s = "  Hello, World!  "
s.strip()            # "Hello, World!"
s.lower()            # "  hello, world!  "
s.upper()            # "  HELLO, WORLD!  "
s.strip().split(",") # ['Hello', ' World!']
"-".join(["a","b"])  # "a-b"
"hello".replace("l", "L")   # "heLLo"
"hello".startswith("he")    # True
"hello".find("ll")          # 2 (index, -1 if not found)
"42".isdigit()               # True

03 Control Flow

# ── if / elif / else ──
score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "F"

# ── Ternary ──
status = "adult" if age >= 18 else "minor"

# ── match/case (3.10+) — Structural Pattern Matching ──
point = (3, 4)
match point:
    case (0, 0):
        print("Origin")
    case (x, 0):
        print(f"On x-axis at {x}")
    case (x, y):
        print(f"Point at {x}, {y}")  # Point at 3, 4

# ── Loops ──
for fruit in ["apple", "banana"]:
    print(fruit)

for i in range(5):          # 0, 1, 2, 3, 4
    print(i)

for i in range(2, 10, 3): # 2, 5, 8  (start, stop, step)
    print(i)

# ── enumerate & zip ──
fruits = ["apple", "banana"]
for i, f in enumerate(fruits):
    print(f"{i}: {f}")          # 0: apple, 1: banana

names = ["Alice", "Bob"]
scores = [90, 85]
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# ── while ──
count = 0
while count < 5:
    count += 1

# ── break, continue, for...else ──
for n in range(10):
    if n == 3: continue    # skip 3
    if n == 7: break       # stop at 7
    print(n)

# for...else — else runs if loop completed WITHOUT break
for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0: break
    else:
        print(f"{n} is prime")

04 Functions

# ── Defining ──
def greet(name):
    """Return a greeting. This is a docstring."""
    return f"Hello, {name}!"

print(greet("Yatin"))   # Hello, Yatin!

# ── Default parameters ──
def power(base, exp=2):
    return base ** exp

print(power(3))      # 9
print(power(3, 3))   # 27

# ── Multiple return values (actually a tuple) ──
def divide(a, b):
    return a // b, a % b

q, r = divide(17, 5)  # q=3, r=2

# ── Keyword arguments ──
def create_user(name, age, role="viewer"):
    return {"name": name, "age": age, "role": role}

user = create_user(age=25, name="Yatin", role="admin")

# ── THE BUG ──
def append_to(element, target=[]):   # DON'T DO THIS
    target.append(element)
    return target

print(append_to(1))  # [1]
print(append_to(2))  # [1, 2]  — WHAT?! Remembered the old list!

# ── THE FIX ──
def append_to(element, target=None):
    if target is None:
        target = []
    target.append(element)
    return target

Lambda — Anonymous Functions

Small one-line functions without a name — perfect for quick inline operations like sorting or filtering. Syntax: lambda arguments: expression

Basic Syntax

# lambda is just a shortcut for simple functions
square = lambda x: x ** 2
square(5)   # 25

# Equivalent to:
def square(x):
    return x ** 2

# Multiple arguments
add = lambda a, b: a + b
add(3, 4)    # 7

# No arguments
greet = lambda: "Hello!"
greet()      # "Hello!"

# With default values
power = lambda x, n=2: x ** n
power(3)       # 9  (default n=2)
power(3, 3)    # 27

Sorting with Lambda

# Sort by string length
names = ["Charlie", "Alice", "Bob"]
names.sort(key=lambda n: len(n))
# ['Bob', 'Alice', 'Charlie']

# Sort list of tuples by second element
students = [("Alice", 90), ("Bob", 75), ("Carol", 85)]
students.sort(key=lambda s: s[1])
# [('Bob', 75), ('Carol', 85), ('Alice', 90)]

# Sort dicts by a specific key
users = [
    {"name": "Yatin", "age": 25},
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 20}
]
users.sort(key=lambda u: u["age"])
# sorted by age: Bob(20), Yatin(25), Alice(30)

# Sort dict by value
scores = {"Alice": 90, "Bob": 85, "Carol": 95}
ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)
# [('Carol', 95), ('Alice', 90), ('Bob', 85)]

# Multi-key sort: first by age, then by name
people = [("Bob", 25), ("Alice", 25), ("Carol", 20)]
people.sort(key=lambda p: (p[1], p[0]))
# [('Carol', 20), ('Alice', 25), ('Bob', 25)]

Lambda with map, filter, reduce

nums = [1, 2, 3, 4, 5]

# map — apply function to every element
squares = list(map(lambda x: x**2, nums))
# [1, 4, 9, 16, 25]

# filter — keep elements that return True
evens = list(filter(lambda x: x % 2 == 0, nums))
# [2, 4]

# reduce — combine all elements into one value
from functools import reduce
total = reduce(lambda a, b: a + b, nums)
# 15  (1+2+3+4+5)

product = reduce(lambda a, b: a * b, nums)
# 120  (1*2*3*4*5)

# But list comprehensions are usually cleaner!
squares = [x**2 for x in nums]        # prefer over map + lambda
evens = [x for x in nums if x % 2 == 0] # prefer over filter + lambda

Lambda with Other Built-ins

# min/max with key
words = ["python", "go", "javascript", "rust"]
shortest = min(words, key=lambda w: len(w))   # "go"
longest = max(words, key=lambda w: len(w))    # "javascript"

# Find user with highest score
users = [{"name": "Alice", "score": 90}, {"name": "Bob", "score": 95}]
best = max(users, key=lambda u: u["score"])
# {'name': 'Bob', 'score': 95}

Conditional Logic in Lambda

# Ternary expression inside lambda
check = lambda x: "even" if x % 2 == 0 else "odd"
check(4)    # "even"
check(7)    # "odd"

grade = lambda s: "A" if s >= 90 else "B" if s >= 80 else "C"
grade(95)   # "A"
grade(85)   # "B"
grade(70)   # "C"

Lambda vs def — When to Use Which

# ✓ USE lambda — simple, one-line, inline with sort/map/filter
names.sort(key=lambda n: n.lower())

# ✗ DON'T assign lambda to a variable (use def instead)
# Bad:
multiply = lambda x, y: x * y    # PEP 8 discourages this

# Good:
def multiply(x, y):
    return x * y

# ✗ DON'T use lambda for complex logic
# Lambda can only have ONE expression — no statements, loops, or assignments
# lambda x: for i in x: print(i)  — SyntaxError!

Functions are Objects

In Python, functions can be stored in variables, passed as arguments, and put in data structures — just like any other value.

def add(a, b): return a + b
def sub(a, b): return a - b

# Assign to variable, put in dict, pass as argument
ops = {"+": add, "-": sub}
print(ops["+"](10, 3))   # 13

# Higher-order function — takes a function as argument
def apply(func, x, y):
    return func(x, y)

print(apply(add, 5, 3))  # 8

# map, filter
nums = [1, 2, 3, 4]
list(map(lambda x: x**2, nums))          # [1, 4, 9, 16]
list(filter(lambda x: x % 2 == 0, nums)) # [2, 4]

05 Data Structures

Lists — Ordered, Mutable

The most common data structure — you can add, remove, and change elements freely. Keeps insertion order.

Creating Lists

# Different ways to create
empty = []
nums = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True, None]   # any type
nested = [[1, 2], [3, 4], [5, 6]]        # 2D list
from_range = list(range(5))               # [0, 1, 2, 3, 4]
repeated = [0] * 5                        # [0, 0, 0, 0, 0]
from_string = list("hello")               # ['h', 'e', 'l', 'l', 'o']

Access & Slicing

nums = [10, 20, 30, 40, 50]

# Indexing
nums[0]           # 10  — first
nums[-1]          # 50  — last
nums[-2]          # 40  — second to last

# Slicing — [start:stop:step]
nums[1:4]         # [20, 30, 40]  — index 1 to 3
nums[:3]          # [10, 20, 30]  — first 3
nums[2:]          # [30, 40, 50]  — from index 2 onwards
nums[::]          # [10, 20, 30, 40, 50]  — full copy
nums[::-1]        # [50, 40, 30, 20, 10]  — reversed
nums[::2]         # [10, 30, 50]  — every 2nd element

# Slice assignment (replace a range)
nums[1:3] = [200, 300]   # [10, 200, 300, 40, 50]
nums[1:3] = [99]          # [10, 99, 40, 50]  — can change size!

Adding Elements

fruits = ["apple", "banana"]

fruits.append("cherry")          # add ONE item to end
# ['apple', 'banana', 'cherry']

fruits.insert(1, "mango")        # insert at specific index
# ['apple', 'mango', 'banana', 'cherry']

fruits.extend(["grape", "kiwi"]) # add MULTIPLE items from iterable
# ['apple', 'mango', 'banana', 'cherry', 'grape', 'kiwi']

# + creates a NEW list (doesn't modify original)
new = fruits + ["melon"]         # fruits is unchanged!

# Common mistake: append vs extend
a = [1, 2]
a.append([3, 4])     # [1, 2, [3, 4]]  — adds list AS element!
b = [1, 2]
b.extend([3, 4])     # [1, 2, 3, 4]    — adds each item

Removing Elements

nums = [10, 20, 30, 20, 40]

nums.remove(20)       # removes FIRST occurrence only
# [10, 30, 20, 40]

popped = nums.pop()   # remove & return LAST
# popped = 40, nums = [10, 30, 20]

popped = nums.pop(1)  # remove & return at INDEX
# popped = 30, nums = [10, 20]

del nums[0]           # delete by index (no return)
# [20]

nums = [1, 2, 3, 4, 5]
del nums[1:3]         # delete a slice
# [1, 4, 5]

nums.clear()          # remove ALL elements
# []

Searching & Counting

letters = ["a", "b", "c", "b", "a"]

letters.index("b")       # 1 — first occurrence index
letters.index("b", 2)    # 3 — search starting from index 2
letters.count("a")       # 2 — how many times "a" appears

"c" in letters           # True  — membership check
"z" in letters           # False

len(letters)             # 5

Sorting & Reversing

nums = [3, 1, 4, 1, 5]

# In-place sort (modifies original, returns None!)
nums.sort()                      # [1, 1, 3, 4, 5]
nums.sort(reverse=True)         # [5, 4, 3, 1, 1]

# sorted() — returns NEW list, original unchanged
original = [3, 1, 4]
new_sorted = sorted(original)    # [1, 3, 4]
# original is still [3, 1, 4]

# Custom sort with key
words = ["banana", "apple", "cherry"]
words.sort(key=len)              # ['apple', 'banana', 'cherry']

users = [("Yatin", 25), ("Alice", 30), ("Bob", 20)]
users.sort(key=lambda u: u[1])   # sort by age

# Reverse (in-place)
nums = [1, 2, 3]
nums.reverse()                   # [3, 2, 1]
list(reversed(nums))             # returns NEW reversed list

Unpacking & Destructuring

# Basic unpacking
a, b, c = [1, 2, 3]       # a=1, b=2, c=3

# Star unpacking
first, *middle, last = [1, 2, 3, 4, 5]
# first=1, middle=[2, 3, 4], last=5

head, *tail = [1, 2, 3, 4]
# head=1, tail=[2, 3, 4]

*init, last = [1, 2, 3, 4]
# init=[1, 2, 3], last=4

# Swap without temp variable
x, y = 10, 20
x, y = y, x            # x=20, y=10

# Ignore values with _
_, b, _ = [1, 2, 3]     # only care about b

Copying — Shallow vs Deep

import copy

# Shallow copy — 3 ways (all equivalent)
original = [[1, 2], [3, 4]]
a = original.copy()
b = list(original)
c = original[::]

# Shallow = new outer list, but inner lists are SHARED
original[0][0] = 999
print(a[0][0])       # 999 — changed too!

# Deep copy — fully independent at all levels
original = [[1, 2], [3, 4]]
deep = copy.deepcopy(original)
original[0][0] = 999
print(deep[0][0])     # 1 — independent!

Common Patterns

# Enumerate — get index + value
for i, fruit in enumerate(["apple", "banana", "cherry"]):
    print(f"{i}: {fruit}")

# Zip — iterate multiple lists together
names = ["Alice", "Bob"]
ages = [25, 30]
for name, age in zip(names, ages):
    print(f"{name} is {age}")

# List as stack (LIFO)
stack = []
stack.append(1)     # push
stack.append(2)
stack.pop()          # 2 — last in, first out

# Flatten nested list — 3 ways
nested = [[1, 2], [3, 4], [5]]

flat = [x for sub in nested for x in sub]   # comprehension (most Pythonic)
flat = sum(nested, [])                         # shortest but slow for large lists (O(n²))

from itertools import chain
flat = list(chain.from_iterable(nested))        # fastest for big data (O(n))
# all give [1, 2, 3, 4, 5]

# Recursive flatten — handles ANY nesting depth
def flatten(lst):
    result = []
    for item in lst:
        if isinstance(item, (list, tuple)):
            result.extend(flatten(item))   # recurse into nested
        else:
            result.append(item)
    return result

flatten([1, [2, [3, 4]], (5, 6), 7])
# [1, 2, 3, 4, 5, 6, 7]

# Filter with list comprehension
nums = [1, 2, 3, 4, 5, 6]
evens = [n for n in nums if n % 2 == 0]   # [2, 4, 6]

# min, max, sum
min(nums)   # 1
max(nums)   # 6
sum(nums)   # 21

# Check if all/any match a condition
all(n > 0 for n in nums)   # True  — all positive
any(n > 5 for n in nums)   # True  — at least one > 5

List Gotchas

# 1. Mutable default argument — CLASSIC bug
def add_item(item, lst=[]):   # BAD! shared across calls
    lst.append(item)
    return lst

add_item(1)   # [1]
add_item(2)   # [1, 2] — not [2]!

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

# 2. Multiplying nested lists — shared references!
grid = [[0] * 3] * 3       # BAD!
grid[0][0] = 1
# [[1,0,0], [1,0,0], [1,0,0]] — all rows changed!

grid = [[0] * 3 for _ in range(3)]   # GOOD!
grid[0][0] = 1
# [[1,0,0], [0,0,0], [0,0,0]] — only first row

# 3. sort() returns None, not the list
result = [3, 1, 2].sort()   # None! not [1,2,3]
result = sorted([3, 1, 2]) # [1,2,3] ✓

Tuples — Ordered, Immutable

Like lists, but you can't change values once created. Faster than lists, use less memory, and can be dictionary keys.

Creating Tuples

# Different ways to create
empty = ()
single = (42,)              # MUST have trailing comma!
not_a_tuple = (42)          # just an int in parentheses
pair = (3, 4)
mixed = (1, "hello", 3.14)
from_list = tuple([1, 2, 3])

# Parentheses are optional (packing)
coords = 10, 20, 30        # same as (10, 20, 30)

Access & Slicing (Same as Lists)

t = (10, 20, 30, 40, 50)

t[0]         # 10
t[-1]        # 50
t[1:4]       # (20, 30, 40)  — slice returns a tuple
t[::-1]      # (50, 40, 30, 20, 10)

len(t)        # 5
min(t)        # 10
max(t)        # 50
sum(t)        # 150

Tuple Methods (Only 2!)

t = (1, 2, 3, 2, 1)

t.count(2)     # 2 — how many times 2 appears
t.index(3)     # 2 — index of first occurrence

# That's it! No append, remove, sort — tuples are immutable

Why Use Tuples Over Lists?

# 1. As dictionary keys (lists CAN'T do this)
locations = {}
locations[(40.7, -74.0)] = "New York"
locations[(51.5, -0.1)] = "London"

# 2. As set elements
points = {(0, 0), (1, 1), (2, 2)}

# 3. Function returning multiple values
def get_user():
    return "Yatin", 25     # returns a tuple

name, age = get_user()     # unpack

# 4. Protect data from accidental changes
DAYS = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")

# 5. Slightly faster & less memory than lists
import sys
sys.getsizeof([1, 2, 3])   # 120 bytes
sys.getsizeof((1, 2, 3))   # 64 bytes  — almost half!

Unpacking & Patterns

# Unpacking works same as lists
a, b, c = (1, 2, 3)
first, *rest = (1, 2, 3, 4)   # first=1, rest=[2,3,4]

# Swap values (this creates tuples under the hood)
x, y = 10, 20
x, y = y, x

# Tuple concatenation (creates NEW tuple)
a = (1, 2)
b = (3, 4)
c = a + b        # (1, 2, 3, 4)
d = a * 3        # (1, 2, 1, 2, 1, 2)

Named Tuples — Tuples with Names

from collections import namedtuple

# Create a "class-like" tuple
Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)

print(p.x, p.y)     # 3 4  — access by name
print(p[0], p[1])   # 3 4  — still works by index

# Practical example
User = namedtuple("User", ["name", "age", "email"])
user = User("Yatin", 25, "y@dev.com")
print(user.name)     # "Yatin"

# Convert to dict
user._asdict()       # {'name': 'Yatin', 'age': 25, 'email': 'y@dev.com'}

# Create modified copy (tuples are immutable, so _replace returns new)
older = user._replace(age=26)
# User(name='Yatin', age=26, email='y@dev.com')

Tuple Gotchas

# 1. Single element needs comma!
t = (42,)     # tuple
t = (42)      # just int 42
type((42,))   # <class 'tuple'>
type((42))    # <class 'int'>

# 2. Immutable BUT can contain mutable objects
t = ([1, 2], [3, 4])
t[0].append(99)    # works! inner list is mutable
# ([1, 2, 99], [3, 4])
# t[0] = [5, 6]     # TypeError! can't reassign tuple element

Dictionaries — Key-Value Mappings

Store data as key-value pairs for fast O(1) lookup. The most-used data structure after lists. Keys must be hashable (immutable).

Creating Dictionaries

# Different ways to create
empty = {}
user = {"name": "Yatin", "age": 25}
from_tuples = dict([("a", 1), ("b", 2)])
from_kwargs = dict(name="Yatin", age=25)
from_keys = dict.fromkeys(["a", "b", "c"], 0)  # {'a': 0, 'b': 0, 'c': 0}
from_zip = dict(zip(["name", "age"], ["Yatin", 25]))

# Dict comprehension
squares = {n: n**2 for n in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Access & Lookup

user = {"name": "Yatin", "age": 25, "skills": ["Python"]}

# Direct access — raises KeyError if missing!
user["name"]                   # "Yatin"
# user["email"]               # KeyError!

# Safe access with .get()
user.get("email")              # None — no error
user.get("email", "N/A")      # "N/A" — custom default

# Check if key exists
"name" in user                # True
"email" in user               # False

Adding & Updating

user = {"name": "Yatin"}

# Add / update single key
user["age"] = 25               # add new key
user["name"] = "Yatin Dora"   # update existing

# Update multiple at once
user.update({"email": "y@dev.com", "age": 26})

# setdefault — add ONLY if key doesn't exist
user.setdefault("name", "Unknown")   # "Yatin Dora" — already exists, no change
user.setdefault("city", "NYC")       # "NYC" — added because key was missing

# Merge with | operator (3.9+)
a = {"x": 1, "y": 2}
b = {"y": 3, "z": 4}

merged = a | b     # {'x': 1, 'y': 3, 'z': 4}
# creates NEW dict — "y" exists in both, b's value (3) wins
# a and b are unchanged

a |= b             # modifies a IN-PLACE (like += for dicts)
# a is now {'x': 1, 'y': 3, 'z': 4}  — same as a.update(b)

# Key rule: when keys overlap, RIGHT side always wins
{"a": 1} | {"a": 99}   # {'a': 99}

# Before 3.9 — old ways to merge
merged = {**a, **b}          # unpacking (3.5+)
a.update(b)                  # in-place (like |=)

Removing Elements

user = {"name": "Yatin", "age": 25, "city": "NYC"}

# del — raises KeyError if missing
del user["city"]

# pop — remove & return value (with optional default)
age = user.pop("age")              # 25
email = user.pop("email", None)   # None — no error

# popitem — remove & return last inserted pair
user["a"] = 1
user["b"] = 2
user.popitem()    # ('b', 2)

# clear — remove everything
user.clear()      # {}

Iteration

user = {"name": "Yatin", "age": 25, "city": "NYC"}

# Loop through keys (default)
for key in user:
    print(key)          # name, age, city

# Loop through values
for val in user.values():
    print(val)          # Yatin, 25, NYC

# Loop through key-value pairs
for k, v in user.items():
    print(f"{k}: {v}")  # name: Yatin, age: 25, city: NYC

# Get all keys/values as lists
keys = list(user.keys())      # ['name', 'age', 'city']
vals = list(user.values())    # ['Yatin', 25, 'NYC']

Nested Dictionaries

users = {
    "user1": {
        "name": "Yatin",
        "skills": ["Python", "JS"],
        "address": {"city": "NYC", "zip": "10001"}
    },
    "user2": {
        "name": "Alice",
        "skills": ["Go", "Rust"],
        "address": {"city": "LA", "zip": "90001"}
    }
}

# Access nested data
users["user1"]["name"]                # "Yatin"
users["user1"]["skills"][0]           # "Python"
users["user1"]["address"]["city"]    # "NYC"

# Safe nested access (avoid KeyError chains)
city = users.get("user3", {}).get("address", {}).get("city", "Unknown")
# "Unknown"

defaultdict & Counter

from collections import defaultdict, Counter

# defaultdict — auto-creates missing keys with a default value
word_count = defaultdict(int)      # default = 0
for w in "hello world hello python hello".split():
    word_count[w] += 1
# {'hello': 3, 'world': 1, 'python': 1}

# Group items
groups = defaultdict(list)
for name, dept in [("Alice", "eng"), ("Bob", "hr"), ("Carol", "eng")]:
    groups[dept].append(name)
# {'eng': ['Alice', 'Carol'], 'hr': ['Bob']}

# Counter — count anything iterable
counts = Counter("mississippi")
# Counter({'s': 4, 'i': 4, 'p': 2, 'm': 1})

counts.most_common(2)             # [('s', 4), ('i', 4)]
counts["s"]                       # 4
counts["z"]                       # 0 — no KeyError!

# Counter arithmetic
a = Counter("aab")    # {'a': 2, 'b': 1}
b = Counter("abc")    # {'a': 1, 'b': 1, 'c': 1}
a + b                  # Counter({'a': 3, 'b': 2, 'c': 1})
a - b                  # Counter({'a': 1})

Dict Gotchas

# 1. Keys must be hashable (immutable)
d = {[1, 2]: "val"}    # TypeError! lists can't be keys
d = {(1, 2): "val"}    # OK — tuples can be keys

# 2. Don't modify dict size while iterating
d = {"a": 1, "b": 2, "c": 3}
# BAD: for k in d: del d[k]  — RuntimeError!

# GOOD: iterate over a copy
for k in list(d.keys()):
    if d[k] < 3:
        del d[k]

# 3. {} is an empty dict, NOT an empty set
type({})       # <class 'dict'>
type(set())    # <class 'set'>

Sets — Unordered, Unique

No duplicates allowed and no guaranteed order. Lightning-fast membership testing with O(1) lookup.

Creating Sets

empty = set()             # NOT {} — that's a dict!
nums = {1, 2, 3, 3}     # {1, 2, 3} — duplicate removed
from_list = set([1, 2, 2, 3])   # {1, 2, 3}
from_string = set("hello")      # {'h', 'e', 'l', 'o'}

# Set comprehension
evens = {n for n in range(10) if n % 2 == 0}
# {0, 2, 4, 6, 8}

Adding & Removing

s = {1, 2, 3}

s.add(4)             # {1, 2, 3, 4}
s.add(3)             # {1, 2, 3, 4} — no effect, already exists

s.update([5, 6])     # add multiple: {1, 2, 3, 4, 5, 6}

s.remove(6)           # raises KeyError if not found
s.discard(99)         # no error if not found — safer!

popped = s.pop()      # remove & return arbitrary element
s.clear()             # empty the set

Set Operations (Math)

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# Union — everything from both
a | b               # {1, 2, 3, 4, 5, 6}
a.union(b)          # same thing

# Intersection — common elements
a & b               # {3, 4}
a.intersection(b)   # same thing

# Difference — in a but NOT in b
a - b               # {1, 2}
a.difference(b)     # same thing

# Symmetric difference — in either but NOT both
a ^ b               # {1, 2, 5, 6}

# Subset & superset checks
{1, 2} <= {1, 2, 3}      # True  — subset
{1, 2, 3} >= {1, 2}      # True  — superset
{1, 2}.isdisjoint({3, 4}) # True  — no common elements

Practical Uses

# Remove duplicates from a list
names = ["alice", "bob", "alice", "carol", "bob"]
unique = list(set(names))   # ['alice', 'bob', 'carol'] (order may vary)

# Remove duplicates preserving order (Python 3.7+)
unique_ordered = list(dict.fromkeys(names))
# ['alice', 'bob', 'carol'] — original order kept

# O(1) membership test — WAY faster than lists for large data
big_set = set(range(1_000_000))
999999 in big_set      # instant!
999999 in list(big_set)  # slow — has to check each element

# Find common elements between lists
list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]
common = list(set(list1) & set(list2))   # [3, 4]

Quick Comparison

# ┌──────────────┬─────────┬───────────┬─────────┬───────────┐
# │              │  List   │  Tuple    │  Dict   │   Set     │
# ├──────────────┼─────────┼───────────┼─────────┼───────────┤
# │ Syntax       │ [1,2,3] │ (1,2,3)   │ {k: v}  │ {1,2,3}   │
# │ Ordered      │ ✓       │ ✓         │ ✓ (3.7+)│ ✗         │
# │ Mutable      │ ✓       │ ✗         │ ✓       │ ✓         │
# │ Duplicates   │ ✓       │ ✓         │ keys ✗  │ ✗         │
# │ Index access │ ✓       │ ✓         │ by key  │ ✗         │
# │ Hashable     │ ✗       │ ✓         │ keys ✓  │ items ✓   │
# │ Use case     │ general │ fixed     │ lookup  │ unique    │
# │              │ storage │ data      │ mapping │ fast test │
# └──────────────┴─────────┴───────────┴─────────┴───────────┘

06 OOP & Classes

A class = blueprint. An object = instance created from that blueprint.

class Dog:
    # Class attribute — shared by ALL instances
    species = "Canis familiaris"

    def __init__(self, name, age):
        # Instance attributes — unique to each dog
        self.name = name
        self.age = age

    def bark(self):
        return f"{self.name} says Woof!"

    def human_years(self):
        return self.age * 7

rex = Dog("Rex", 5)
buddy = Dog("Buddy", 3)

print(rex.bark())          # Rex says Woof!
print(buddy.human_years()) # 21
print(rex.species)         # Canis familiaris (shared)

Class vs Instance vs Static Methods

Three ways to define methods — instance methods get self, class methods get cls, static methods get nothing. Each serves a different purpose.

Instance Method (Regular) — uses self

The default. Has access to the instance (self) and its data. Can also access class attributes through self.

class User:
    platform = "Web"              # class attribute

    def __init__(self, name):
        self.name = name           # instance attribute

    def greet(self):              # instance method
        return f"Hi, I'm {self.name} on {self.platform}"

u = User("Yatin")
u.greet()    # "Hi, I'm Yatin on Web"

# What actually happens when you call u.greet():
# Python converts it to → User.greet(u)
# That's why self is the first parameter!

Class Method — uses cls

Gets the class itself (not an instance). Can't access instance data (self). Mainly used as factory methods — alternative ways to create objects.

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def from_string(cls, data_str):
        # cls IS the User class — same as calling User(...)
        name, age = data_str.split("-")
        return cls(name, int(age))       # creates a new User

    @classmethod
    def from_dict(cls, data):
        return cls(data["name"], data["age"])

# Multiple ways to create a User
u1 = User("Yatin", 25)                          # normal
u2 = User.from_string("Alice-30")               # from string
u3 = User.from_dict({"name": "Bob", "age": 20}) # from dict

Real-World Examples

The core idea: your __init__ takes clean, final values. But real data comes in messy formats — JSON strings, CSV rows, env variables, database rows. Class methods handle the parsing and conversion, then call cls() to create the object. Same object, different input sources.

1. Python's own datetime uses classmethods! — You've already used these. They're all factory methods that create a datetime object from different inputs.

from datetime import datetime
now = datetime.now()                     # from system clock
today = datetime.today()                 # from today's date
d = datetime.fromtimestamp(1679500000)   # from unix timestamp
# All return a datetime object — just different ways to create one

2. Config loader — Your app needs config settings, but they come from different places depending on the environment. __init__ just stores the settings dict. Each classmethod knows how to read from one source.

class Config:
    def __init__(self, settings):
        self.settings = settings       # just stores clean data

    @classmethod
    def from_json(cls, filepath):      # reads a JSON file, parses it
        with open(filepath) as f:
            return cls(json.load(f))    # cls() calls __init__ with parsed dict

    @classmethod
    def from_env(cls):                 # reads from environment variables
        return cls({
            "debug": os.getenv("DEBUG", "false"),
            "db_url": os.getenv("DATABASE_URL"),
        })

    @classmethod
    def default(cls):                  # hardcoded defaults for dev
        return cls({"debug": "false", "db_url": "sqlite:///app.db"})

# Pick whichever fits the situation
config = Config.from_json("config.json")   # production — read from file
config = Config.from_env()                  # docker/cloud — read from env vars
config = Config.default()                   # development — use defaults

3. User from different data sources — APIs send JSON, files have CSV, databases return tuples. Each classmethod knows how to parse one format and extract name, email, age for __init__.

class User:
    def __init__(self, name, email, age):
        self.name = name               # __init__ only cares about
        self.email = email             # clean, final values
        self.age = age

    @classmethod
    def from_json(cls, json_str):      # API sends '{"name": "...", ...}'
        data = json.loads(json_str)    # parse JSON string → dict
        return cls(data["name"], data["email"], data["age"])

    @classmethod
    def from_csv_row(cls, row):        # CSV file has "Yatin,y@dev.com,25"
        name, email, age = row.split(",")
        return cls(name, email, int(age)) # convert age string → int

    @classmethod
    def from_db_row(cls, row):         # DB returns (id, name, email, age)
        return cls(row[1], row[2], row[3])  # skip id at index 0

# All create the same User object — parsing logic stays in the classmethod
# __init__ stays clean and simple

Why cls Instead of Just Writing the Class Name?

Because cls is dynamic — it becomes whatever class called the method. Hardcoding the class name breaks inheritance.

# ❌ Hardcoded class name — breaks for subclasses
class Animal:
    def __init__(self, name):
        self.name = name

    @classmethod
    def create(cls, name):
        return Animal(name)       # hardcoded!

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

d = Dog.create("Buddy")
type(d)       # <class 'Animal'> — NOT a Dog!
d.bark()      # AttributeError! Animal has no bark()

# ✓ Using cls — works for ALL subclasses
class Animal:
    def __init__(self, name):
        self.name = name

    @classmethod
    def create(cls, name):
        return cls(name)          # cls = whatever class calls it

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

d = Dog.create("Buddy")      # cls = Dog → Dog("Buddy")
type(d)       # <class 'Dog'> ✓
d.bark()      # "Woof!" ✓

a = Animal.create("Cat")    # cls = Animal → Animal("Cat")
type(a)       # <class 'Animal'> ✓

self vs cls — What's the Difference?

self is a specific object (instance). cls is the class itself (the blueprint). They operate at different levels.

class Car:
    total_cars = 0                # class-level data (shared by all)

    def __init__(self, brand):
        self.brand = brand        # instance-level data (unique to each)
        Car.total_cars += 1

    # Instance method — works with ONE specific car
    def describe(self):
        return f"I am a {self.brand}"
        # self = the specific car object
        # self.brand = THIS car's brand

    # Class method — works with the Car CLASS itself
    @classmethod
    def get_count(cls):
        return f"{cls.total_cars} {cls.__name__}s made"
        # cls = the Car class (not any specific car)
        # cls.total_cars = class-level data

    @classmethod
    def create_default(cls):
        return cls("Unknown")      # cls() creates a new instance
        # self CAN'T do this — self is already an instance

c1 = Car("BMW")
c2 = Car("Tesla")

c1.describe()        # "I am a BMW"    — self = c1
c2.describe()        # "I am a Tesla"  — self = c2
Car.get_count()      # "2 Cars made"   — cls = Car

# ┌──────────────┬─────────────────────┬────────────────────────┐
# │              │ self                │ cls                    │
# ├──────────────┼─────────────────────┼────────────────────────┤
# │ What is it?  │ ONE specific object │ The class (blueprint)  │
# │ Example      │ self = my BMW       │ cls = Car              │
# │ Access       │ self.brand (unique) │ cls.total_cars (shared)│
# │ Can create?  │ No (already exists) │ Yes — cls() makes new  │
# │ Used in      │ instance methods    │ @classmethod           │
# └──────────────┴─────────────────────┴────────────────────────┘

Static Method — no self, no cls

Gets nothing — can't access instance or class data. It's just a regular function that lives inside the class for organization.

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

    @staticmethod
    def is_even(n):
        return n % 2 == 0

# Call without creating an instance
MathUtils.add(3, 4)      # 7
MathUtils.is_even(5)      # False

# Also works on instances (but no point)
m = MathUtils()
m.add(3, 4)               # 7 — same thing

All Three Together

class Pizza:
    base_price = 10

    def __init__(self, toppings):
        self.toppings = toppings

    # Instance method — needs self (instance data)
    def price(self):
        return self.base_price + len(self.toppings) * 2

    # Class method — factory, alternative constructor
    @classmethod
    def margherita(cls):
        return cls(["mozzarella", "tomato"])

    # Static method — utility, no access to self or cls
    @staticmethod
    def is_valid_topping(topping):
        return topping in ["cheese", "tomato", "mushroom"]

p = Pizza.margherita()                     # classmethod — factory
print(p.price())                           # 14 — instance method
print(Pizza.is_valid_topping("cheese"))    # True — static method

Quick Comparison

# ┌────────────────┬───────────────┬────────────────┬───────────────┐
# │                │ Instance      │ @classmethod   │ @staticmethod │
# ├────────────────┼───────────────┼────────────────┼───────────────┤
# │ First param    │ self          │ cls            │ nothing       │
# │ Access instance│ ✓             │ ✗              │ ✗             │
# │ Access class   │ ✓ (via self)  │ ✓ (via cls)    │ ✗             │
# │ Called on      │ instance      │ class or inst  │ class or inst │
# │ Use case       │ work with     │ factory /      │ utility       │
# │                │ object data   │ alt constructor│ function      │
# └────────────────┴───────────────┴────────────────┴───────────────┘

07 __init__ & self — Complete Explanation

What is __init__?

__init__ is the initializer (NOT the constructor). It's called automatically after the object is created. Its job: set up initial state.

# WITHOUT __init__ — blank, fragile objects
class Dog:
    pass

d = Dog()
d.name = "Rex"     # manually set every time
d.age = 5          # easy to forget one → bugs

# WITH __init__ — guaranteed setup
class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

d = Dog("Rex", 5)  # one line, always has both attributes

What is self?

self is a reference to the specific instance calling the method. When you call rex.bark(), Python actually does Dog.bark(rex). So self IS rex.

class Demo:
    def __init__(self, name):
        # self.name = the OBJECT's attribute
        # name       = the PARAMETER passed in
        self.name = name
        print(f"I am object at {id(self)}")

d = Demo("test")
print(f"d is at {id(d)}")
# Both print the SAME address — self IS the object

The Full Lifecycle: __new__ vs __init__

__new__ creates the object (allocates memory), then __init__ sets it up. Most of the time you only need __init__.

class Dog:
    def __new__(cls, *args, **kwargs):
        print("1. __new__: CREATING object (allocating memory)")
        instance = super().__new__(cls)
        return instance

    def __init__(self, name):
        print("2. __init__: INITIALIZING object (setting up data)")
        self.name = name

d = Dog("Rex")
# 1. __new__: CREATING object (allocating memory)
# 2. __init__: INITIALIZING object (setting up data)

# So Dog("Rex") actually does:
# 1. obj = Dog.__new__(Dog, "Rex")     ← blank object
# 2. Dog.__init__(obj, "Rex")           ← set attributes
# 3. return obj

Real-World __init__

How __init__ is used in production — validating inputs, storing config, and setting up initial state.

class DatabaseConnection:
    def __init__(self, host, port, db, timeout=30):
        # Validate
        if not host:
            raise ValueError("Host required")

        # Store config
        self.host = host
        self.port = port
        self.db = db
        self.timeout = timeout

        # Set up initial state
        self.is_connected = False
        self._connection = None    # _ = private by convention
        self.query_count = 0

    def connect(self):
        print(f"Connecting to {self.host}:{self.port}/{self.db}")
        self.is_connected = True

08 Magic / Dunder Methods

Double-underscore methods let your objects work with Python's operators and built-in functions.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):         # for developers (debugging)
        return f"Vector({self.x}, {self.y})"

    def __str__(self):          # for users (print)
        return f"({self.x}, {self.y})"

    def __add__(self, other):   # + operator
        return Vector(self.x + other.x, self.y + other.y)

    def __eq__(self, other):    # == operator
        return self.x == other.x and self.y == other.y

    def __abs__(self):          # abs() function
        return (self.x**2 + self.y**2)**0.5

    def __len__(self):          # len() function
        return int(abs(self))

    def __getitem__(self, i):   # v[0], v[1]
        return (self.x, self.y)[i]

    def __iter__(self):         # for x in v, unpacking
        yield self.x
        yield self.y

    def __call__(self, scalar): # v(3) — make it callable
        return Vector(self.x * scalar, self.y * scalar)

v1 = Vector(3, 4)
v2 = Vector(1, 2)

print(v1)           # (3, 4)         __str__
print(repr(v1))     # Vector(3, 4)   __repr__
print(v1 + v2)      # (4, 6)         __add__
print(abs(v1))      # 5.0            __abs__
print(v1[0])        # 3              __getitem__
print(v1(3))        # (9, 12)        __call__
x, y = v1            # unpacking via __iter__

Reference Table

Quick lookup of all common dunder methods, grouped by what they do and what triggers them.

09 Inheritance & MRO

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError

    def describe(self):
        return f"I am {self.name}, an animal"

class Dog(Animal):
    def speak(self):
        return f"{self.name}: Woof!"

    def describe(self):
        return f"I am {self.name}, a dog"

class Cat(Animal):
    def speak(self):
        return f"{self.name}: Meow!"

# Polymorphism
for a in [Dog("Rex"), Cat("Whiskers")]:
    print(a.speak())

# ── super() ──
# Animal (grandparent) → Dog (parent) → GuideDog (child)
class GuideDog(Dog):
    def __init__(self, name, owner):
        super().__init__(name)   # call parent (Dog) __init__
        self.owner = owner

    def speak(self):
        # call parent (Dog) method
        parent_sound = super().speak()          # "Buddy: Woof!"
        # super().describe() → calls Dog.describe() (parent, one step up MRO)
        parent_desc = super().describe()           # "I am Buddy, a dog"
        # Animal.describe(self) → directly calls grandparent, skips MRO
        grandparent_desc = Animal.describe(self)    # "I am Buddy, an animal"
        return f"{parent_sound} | {parent_desc} | {grandparent_desc}"

    def info(self):
        # call grandparent (Animal) attribute — self.name set by Animal.__init__
        # works because: GuideDog.__init__ → super (Dog) → Dog inherits Animal.__init__ → sets self.name
        return f"Guide dog {self.name} belongs to {self.owner}"

g = GuideDog("Buddy", "Alice")
print(g.speak())  # "Buddy: Woof! | I am Buddy, a dog | I am Buddy, an animal"
print(g.info())   # "Guide dog Buddy belongs to Alice"

# To explicitly call grandparent skipping parent:
# Animal.speak(self)  — works but breaks MRO, avoid this
# super() always follows MRO chain: GuideDog → Dog → Animal → object

# ── MRO (Method Resolution Order) ──
# MRO is the order Python searches for a method when you call it.
# When you call obj.method(), Python checks classes in MRO order
# and uses the FIRST match it finds. super() follows this same order.
#
# Single inheritance: simple chain
#   GuideDog → Dog → Animal → object
#   g.speak() → checks GuideDog first ✓ found, stop
#   g.name   → GuideDog? ✗ → Dog? ✗ → Animal.__init__ set it ✓
#
# Multiple inheritance: diamond problem
# Python uses C3 linearization to decide the order.
# Rules: 1) child before parent  2) left parent before right parent

class A:
    def greet(self): return "A"
class B(A):
    def greet(self): return "B"
class C(A):
    def greet(self): return "C"
class D(B, C):   # Diamond!  D inherits B and C, both inherit A
    pass

#       A          MRO: D → B → C → A → object
#      / \         D.greet() → checks D? ✗ → B? ✓ "B" (stop)
#     B   C        super() in B.greet() would go to C (not A!)
#      \ /         because MRO says C comes next after B
#       D

print(D().greet())  # "B"  — first match in MRO
print(D.__mro__)    # D → B → C → A → object

# isinstance / issubclass
print(isinstance(Dog("Rex"), Animal))  # True
print(issubclass(Dog, Animal))         # True

Properties

Use @property to control attribute access — add validation, computed values, or read-only fields without changing the API.

Why do we need it? Without @property, anyone can set any value directly — even invalid ones like t.celsius = -500. You could write getter/setter methods like get_celsius() / set_celsius(), but then every user of your class has to change from t.celsius to t.get_celsius(). @property lets you add validation/logic behind the scenes while keeping the clean t.celsius syntax.

# ❌ Without @property — no control over what gets set
class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

t = Temperature(100)
t.celsius = -500      # no error! but -500°C is physically impossible
print(t.celsius)       # -500  — bad data, no validation

# ✅ With @property — setter runs validation automatically
class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius       # _celsius = private storage (convention)

    @property                       # GETTER: runs when you READ t.celsius
    def celsius(self):
        return self._celsius

    @celsius.setter                 # SETTER: runs when you WRITE t.celsius = value
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Below absolute zero!")
        self._celsius = value

    @property                       # read-only — no setter, so can't set t.fahrenheit = x
    def fahrenheit(self):
        return self._celsius * 9/5 + 32  # computed on the fly from _celsius

t = Temperature(100)
print(t.celsius)      # 100      — calls @property getter
print(t.fahrenheit)   # 212.0    — computed, read-only
t.celsius = 0         # calls @celsius.setter → validates → sets _celsius = 0
print(t.fahrenheit)   # 32.0     — auto-recomputed
t.celsius = -300      # ValueError: Below absolute zero!
t.fahrenheit = 50     # AttributeError: can't set — no setter defined

# The magic: caller uses simple t.celsius syntax
# but behind the scenes Python calls your getter/setter methods
# t.celsius      →  Temperature.celsius.fget(t)   (getter)
# t.celsius = 0  →  Temperature.celsius.fset(t, 0) (setter)

Private Variables

Python has no true private variables like Java/C++. Everything is accessible. But there are two conventions:

class BankAccount:
    def __init__(self, balance):
        self.name = "Savings"       # public — anyone can read/write
        self._balance = balance       # _ = "protected" — convention: don't touch from outside
        self.__pin = 1234            # __ = "private" — name mangling (Python renames it)

acc = BankAccount(1000)

# public — works fine
print(acc.name)          # "Savings"

# _ single underscore — works but "please don't"
print(acc._balance)      # 1000  — still accessible! just a convention

# __ double underscore — name mangling
print(acc.__pin)         # AttributeError: no attribute '__pin'
print(acc._BankAccount__pin)  # 1234  — Python renamed it to _ClassName__var
                               # so it's STILL accessible, just harder to find

# Summary:
#   name      → public        anyone can use
#   _name     → protected     "don't touch" convention, still accessible
#   __name    → name-mangled  Python renames to _ClassName__name, still accessible
#
# Bottom line: Python trusts developers — "we're all adults here"
# Use _ for internal attrs, __ only to avoid name clashes in subclasses

10 Error Handling

# ── try / except / else / finally ──
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")
except (TypeError, ValueError):
    print("Type or value error")
except Exception as e:       # catch-all (use sparingly)
    print(f"Unknown: {e}")
else:                          # runs ONLY if no exception
    print("Success!")
finally:                       # runs ALWAYS
    print("Cleanup")

# ── raise vs throw ──
# "raise" IS Python's "throw" — same concept, different keyword
# Python: raise    |   Java/C#/JS/C++: throw
#
# What raise does:
# 1. Creates an exception object
# 2. Immediately stops the current function
# 3. Walks UP the call stack looking for a matching except
# 4. If nothing catches it → program crashes with traceback

# ── Raising ──
def validate_age(age):
    if age < 0:
        raise ValueError(f"Age can't be negative: {age}")

# raise separates DETECTING an error from HANDLING it
def divide(a, b):
    if b == 0:
        raise ZeroDivisionError("can't divide by zero")  # stops HERE
    return a / b          # never reached if b == 0

# Caller decides what to do with the error
try:
    divide(10, 0)
except ZeroDivisionError as e:
    print(e)              # can't divide by zero

# Three forms of raise:
raise ValueError("msg")          # raise a new exception
raise                             # re-raise current exception (inside except)
raise TypeError("x") from err    # chain: new exception caused by original

# ── Custom exceptions ──
class InsufficientFunds(Exception):
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        super().__init__(f"Need {amount}, have {balance}")

class BankAccount:
    def __init__(self, balance):
        self.balance = balance

    def withdraw(self, amount):
        if amount > self.balance:
            raise InsufficientFunds(self.balance, amount)
        self.balance -= amount

# ── Using the custom exception ──
acct = BankAccount(100)
try:
    acct.withdraw(250)
except InsufficientFunds as e:
    print(e)                 # Need 250, have 100
    print(e.balance)          # 100  ← access custom attrs
    print(e.amount)           # 250

# ── Exception hierarchies for your app ──
class AppError(Exception):
    """Base for all app errors — catch this to handle any app error."""

class NotFoundError(AppError):
    pass

class PermissionError(AppError):
    pass

try:
    raise NotFoundError("User 42 missing")
except AppError as e:       # catches NotFoundError AND PermissionError
    print(e)

# ── Re-raising & chaining ──
try:
    int("abc")
except ValueError as e:
    raise                     # re-raise same exception

try:
    int("abc")
except ValueError as original:
    raise RuntimeError("parse failed") from original  # chain: keeps both tracebacks

# ── Practical pattern: retry with fallback ──
for attempt in range(3):
    try:
        result = risky_operation()
        break                 # success — exit loop
    except ConnectionError:
        if attempt == 2:
            raise             # last attempt — give up
        print(f"Retry {attempt + 1}...")

Exception Hierarchy

# BaseException
#  ├── SystemExit, KeyboardInterrupt
#  └── Exception              ← catch THIS, not BaseException
#       ├── ValueError
#       ├── TypeError
#       ├── KeyError
#       ├── IndexError
#       ├── FileNotFoundError
#       ├── ZeroDivisionError
#       ├── AttributeError
#       └── StopIteration

11 File Handling

# ALWAYS use `with` — auto-closes, even on exception
with open("data.txt", "w") as f:
    f.write("Hello\nWorld\n")

with open("data.txt") as f:
    content = f.read()           # entire file

with open("data.txt") as f:
    for line in f:              # line by line (memory efficient)
        print(line.strip())

# Modes: "r" read, "w" write (overwrite!), "a" append
#        "x" create (fail if exists), "b" binary, "+" read+write

# ── Production: use pathlib (modern, cross-platform) ──
from pathlib import Path

config_dir = Path("config")
config_dir.mkdir(parents=True, exist_ok=True)  # create dirs safely

file = config_dir / "app.txt"     # build paths with /  (not string concat!)
file.write_text("hello")            # write + auto-close
content = file.read_text()          # read  + auto-close

file.exists()                        # True
file.name                            # "app.txt"
file.suffix                          # ".txt"
file.stem                            # "app"
file.parent                          # Path("config")
file.resolve()                       # absolute path

# Iterate files in a directory
for p in Path(".").glob("*.py"):     # all .py in current dir
    print(p.name)
for p in Path(".").rglob("*.py"):    # recursive — all subdirs too
    print(p)

# ── Production: handle errors gracefully ──
from pathlib import Path

def read_config(path: str) -> dict:
    p = Path(path)
    if not p.exists():
        raise FileNotFoundError(f"Config missing: {p}")
    return json.loads(p.read_text())

# Or catch errors at call site
try:
    data = Path("settings.json").read_text()
except FileNotFoundError:
    data = "{}"                   # fallback to empty config
except PermissionError:
    print("No read access!")

# ── Production: safe writes (atomic — no half-written files) ──
import tempfile, os

def safe_write(path: str, content: str):
    """Write to temp file first, then rename — atomic on most OS."""
    p = Path(path)
    tmp = p.with_suffix(".tmp")
    tmp.write_text(content)
    tmp.rename(p)                    # atomic replace — no corruption

# ── Production: encoding matters ──
# ALWAYS specify encoding — default varies by OS!
with open("data.txt", "w", encoding="utf-8") as f:
    f.write("café ☕")

Path("data.txt").read_text(encoding="utf-8")

# ── JSON ──
import json
with open("data.json", "w") as f:
    json.dump({"name": "Yatin"}, f, indent=2)

with open("data.json") as f:
    data = json.load(f)

# Production: validate JSON & handle bad data
def load_json_safe(path: str, default=None) -> dict:
    try:
        return json.loads(Path(path).read_text(encoding="utf-8"))
    except (FileNotFoundError, json.JSONDecodeError):
        return default or {}

# json.dumps / json.loads — work with strings (no file)
text = json.dumps({"age": 25})     # dict → string
obj  = json.loads(text)              # string → dict

# ── CSV ──
import csv

# Reading
with open("data.csv", encoding="utf-8") as f:
    for row in csv.DictReader(f):   # each row is a dict
        print(row["name"])

# Writing
users = [{"name": "Yatin", "age": 25}, {"name": "Bob", "age": 30}]
with open("users.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["name", "age"])
    writer.writeheader()             # name,age
    writer.writerows(users)          # write all rows at once

# ── Large files: stream instead of loading all into memory ──
def count_errors(log_path: str) -> int:
    """Process a 10GB log file without using 10GB of RAM."""
    errors = 0
    with open(log_path, encoding="utf-8") as f:
        for line in f:            # yields one line at a time
            if "ERROR" in line:
                errors += 1
    return errors

12 Modules, Packages & Project Structure

Modules

A module is just a .py file. import executes it and gives you access to its contents.

# ── math_utils.py ──
PI = 3.14159
def circle_area(r): return PI * r ** 2

# ── main.py ──
import math_utils                         # whole module
from math_utils import circle_area        # specific function
from math_utils import circle_area as ca # with alias

__name__ == "__main__"

Guards code so it only runs when the file is executed directly, not when it's imported as a module.

# When Python runs a file directly: __name__ = "__main__"
# When it's imported:               __name__ = "module_name"

def circle_area(r):
    return 3.14 * r ** 2

if __name__ == "__main__":
    # Only runs when executed directly, NOT when imported
    print(circle_area(5))
    print("Tests passed!")

Packages & __init__.py

Directories become importable packages with __init__.py — controls what's publicly accessible.

# ── models/__init__.py ──
from .user import User
from .product import Product

# Now users can do:
from models import User, Product     # clean!
# Instead of:
from models.user import User         # verbose

# ── WHY __init__.py in every folder? ──

# Problem: Python sees folders as just folders, not packages.
# Without __init__.py, `import models` fails — Python doesn't
# know this folder contains importable code.

# __init__.py tells Python: "This folder is a package."
# Think of it like an index page for a chapter in a book.

# ── What happens when you import a package (full breakdown) ──
#
# Given this structure:
#   models/
#   ├── __init__.py      →  from .user import User
#   └── user.py          →  class User: ...
#
# When you write: `from models import User`
#
# Step 1: FIND the package
#   Python searches sys.path (list of directories) for "models"
#   sys.path includes: current dir, installed packages, stdlib
#   It finds models/ folder and checks for __init__.py → found!
#
# Step 2: EXECUTE __init__.py (this is the key!)
#   Python runs models/__init__.py top to bottom, like any script.
#   That file says: `from .user import User`
#     → Python now runs models/user.py
#     → class User is created and bound to the name "User"
#       inside the models package namespace
#
# Step 3: BIND the name
#   `from models import User` grabs "User" from the models
#   namespace and binds it in YOUR file's namespace.
#   Now you can use User directly.
#
# Step 4: CACHE it
#   Python stores the module in sys.modules["models"].
#   Next time ANYONE imports models, __init__.py does NOT
#   run again — Python reuses the cached version.
#   (This is why init code only runs ONCE.)

# You can see this yourself:
import sys

# Before import — "models" not in cache
print("models" in sys.modules)       # False

from models import User               # triggers Step 1-4

# After import — cached!
print("models" in sys.modules)       # True
print(sys.modules["models"])          # <module 'models' from 'models/__init__.py'>

# See where Python searches for packages:
for p in sys.path:
    print(p)
# /Users/you/project          ← your current directory (first!)
# /usr/lib/python3.12         ← stdlib
# /usr/lib/python3.12/site-packages  ← pip installed

# ── Different import styles — same mechanism ──
import models                  # runs __init__.py → models.User
from models import User        # runs __init__.py → User directly
from models.user import User   # runs __init__.py AND user.py → User
import models.user             # runs __init__.py AND user.py → models.user.User

# KEY INSIGHT: __init__.py ALWAYS runs, no matter which style!
# Even `from models.user import User` triggers __init__.py first.

# ── 4 things __init__.py does ──

# 1. MARKS the directory as a package (can be empty!)
#    utils/__init__.py  → even an empty file works

# 2. CONTROLS the public API — hide internals, expose clean imports

# ── models/user.py ──
class User:
    def __init__(self, name):
        self.name = name

# ── models/__init__.py ──
from .user import User
from .product import Product

# Without __init__.py re-exports:
from models.user import User              # ugly — exposes internal structure
from models.product import Product

# With __init__.py re-exports:
from models import User, Product           # clean! users don't know about user.py

# 3. RUNS INIT CODE — setup that should happen once on import
#
# __init__.py runs ONCE when the package is first imported.
# Perfect for one-time setup. Think of it as the "boot up" for your package.

Example A: Shared database connection

# Problem: Every file creates its own DB connection = wasteful
#
# routes/auth.py
db = Database("sqlite:///app.db")           # connection #1
# routes/api.py
db = Database("sqlite:///app.db")           # connection #2  ← duplicate!
# routes/admin.py
db = Database("sqlite:///app.db")           # connection #3  ← duplicate!

# Solution: create it ONCE in __init__.py
#
# ── db/__init__.py ──
from .connection import Database
default_db = Database("sqlite:///app.db")   # created ONCE on first import

# ── routes/auth.py ──
from db import default_db                   # reuses same connection

# ── routes/api.py ──
from db import default_db                   # same connection — not recreated!

# ── routes/admin.py ──
from db import default_db                   # same connection — shared across app

# WHY? Python caches modules after first import.
# __init__.py runs once → default_db created once → everyone shares it.

Example B: Configure logging for the whole package

# ── myapp/__init__.py ──
import logging

# Runs ONCE when anyone does `import myapp` or `from myapp import ...`
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger("myapp")
logger.info("App package loaded!")          # prints once on startup

# ── myapp/routes/auth.py ──
import logging
logger = logging.getLogger("myapp.auth")    # inherits config from above!
logger.info("Auth route hit")               # formatted the same way

Example C: Register plugins / load components on startup

# ── plugins/__init__.py ──
from .email_plugin import EmailPlugin
from .sms_plugin import SMSPlugin

# Auto-register all plugins into a registry
registry = {}
for plugin in [EmailPlugin, SMSPlugin]:
    registry[plugin.name] = plugin         # built once at import time

# ── anywhere else ──
from plugins import registry
registry["email"].send("hello")            # use directly — no setup needed

Example D: Package version & metadata

# ── mylib/__init__.py ──
__version__ = "2.1.0"
__author__ = "Yatin"

# Now users can check:
import mylib
print(mylib.__version__)                    # "2.1.0"

# This is how real packages do it:
import flask
print(flask.__version__)                    # "3.0.0"
import requests
print(requests.__version__)                 # "2.31.0"

Example E: Validate environment on import

# ── payments/__init__.py ──
import os

# Fail FAST — crash at import time, not at runtime 10 minutes later
API_KEY = os.environ.get("STRIPE_API_KEY")
if not API_KEY:
    raise RuntimeError(
        "STRIPE_API_KEY not set! Add it to .env"
    )

# If we get here, key exists — safe to use in any file
# ── payments/charge.py ──
from . import API_KEY                       # guaranteed to exist

# WHY in __init__.py?
# Without: app starts → runs for 10 min → user pays → CRASH (no API key)
# With:    app starts → CRASH immediately → you fix it before deploying

13 Comprehensions

# ── List ──
squares = [x**2 for x in range(10)]
evens = [x for x in range(20) if x % 2 == 0]
labels = ["even" if x%2==0 else "odd" for x in range(5)]

# Nested — flatten matrix
matrix = [[1,2], [3,4], [5,6]]
flat = [n for row in matrix for n in row]
# [1, 2, 3, 4, 5, 6]

# ── Dict ──
word_lens = {w: len(w) for w in ["hello", "world"]}
swapped = {v: k for k, v in {"a": 1}.items()}

# ── Set ──
unique_lens = {len(w) for w in ["hi", "hey", "hello"]}  # {2, 3, 5}

# ── Generator expression (lazy — no memory for full list) ──
total = sum(x**2 for x in range(1_000_000))  # memory efficient!

14 Iterators & Generators

The Iterator Protocol

How for loops actually work under the hood — using __iter__() and __next__() to walk through items one by one.

# How `for x in something` ACTUALLY works:
nums = [1, 2, 3]
iterator = iter(nums)        # calls __iter__()
print(next(iterator))        # 1  — calls __next__()
print(next(iterator))        # 2
print(next(iterator))        # 3
# next(iterator)              # StopIteration!

Generators — The Easy Way

yield pauses the function, returns a value, and resumes on next call.

def countdown(n):
    while n > 0:
        yield n     # pause here, return n
        n -= 1

for i in countdown(5):
    print(i)  # 5, 4, 3, 2, 1

# WHY? Memory efficiency.
# This yields billion values without storing them all:
def infinite():
    n = 0
    while True:
        yield n
        n += 1

# Real-world: process huge files with constant memory
def read_large_file(path):
    with open(path) as f:
        for line in f:
            yield line.strip()

# ── Generator pipeline (data processing pattern) ──
def parse(lines):
    for line in lines:
        yield line.split(",")

def filter_valid(rows):
    for row in rows:
        if len(row) == 3:
            yield row

# Chain them — nothing runs until you iterate!
pipeline = filter_valid(parse(read_large_file("data.csv")))
for row in pipeline:
    print(row)

# ── yield from ──
def chain(*iterables):
    for it in iterables:
        yield from it

list(chain([1,2], [3,4]))  # [1, 2, 3, 4]

15 Decorators

A decorator takes a function, wraps it, and returns the wrapped version. @ is just syntactic sugar.

import time
from functools import wraps

# ── Basic decorator ──
def timer(func):
    @wraps(func)   # preserves original name/docstring
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.perf_counter()-start:.4f}s")
        return result
    return wrapper

@timer
def slow():
    time.sleep(1)

slow()  # slow took 1.0012s

# @timer on slow is the same as: slow = timer(slow)

# ── Decorator WITH arguments ──
def retry(max_attempts=3):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    print(f"Attempt {attempt} failed: {e}")
                    if attempt == max_attempts: raise
        return wrapper
    return decorator

@retry(max_attempts=5)
def flaky_api():
    pass

# ── Built-in cache decorator ──
from functools import lru_cache

@lru_cache(maxsize=128)
def fib(n):
    if n < 2: return n
    return fib(n-1) + fib(n-2)

print(fib(100))  # instant!

16 Closures & Scope

LEGB Rule

The order Python searches for variable names — Local, Enclosing, Global, then Built-in.

# Python looks up variables in this order:
# L — Local (inside current function)
# E — Enclosing (in outer function, for nested)
# G — Global (module level)
# B — Built-in (print, len, etc.)

x = "global"
def outer():
    x = "enclosing"
    def inner():
        x = "local"
        print(x)    # "local"
    inner()

# global / nonlocal keywords
count = 0
def inc():
    global count      # access module-level count
    count += 1

def outer():
    x = 0
    def inner():
        nonlocal x    # access enclosing scope's x
        x += 1
    inner()
    print(x)         # 1

Closures

A function that remembers variables from the scope where it was created, even after that scope is gone.

# A function that "closes over" variables from its enclosing scope
def make_multiplier(factor):
    def multiply(x):
        return x * factor   # factor is remembered!
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)
print(double(5))   # 10
print(triple(5))   # 15

# Real-world: config factories
def make_logger(prefix):
    def log(msg):
        print(f"[{prefix}] {msg}")
    return log

error = make_logger("ERROR")
error("Something broke")  # [ERROR] Something broke

17 Context Managers

# ── Class-based ──
class Timer:
    def __enter__(self):
        self.start = time.perf_counter()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"Elapsed: {time.perf_counter()-self.start:.4f}s")
        return False   # don't suppress exceptions

with Timer():
    time.sleep(1)

# ── Generator-based (simpler) ──
from contextlib import contextmanager

@contextmanager
def timer(label):
    start = time.perf_counter()
    try:
        yield      # `with` block runs here
    finally:
        print(f"{label}: {time.perf_counter()-start:.4f}s")

with timer("query"):
    time.sleep(0.5)

18 *args & **kwargs

# *args  → extra POSITIONAL args as a tuple
# **kwargs → extra KEYWORD args as a dict

def add_all(*args):
    return sum(args)       # args is a tuple
print(add_all(1,2,3,4))  # 10

def profile(**kwargs):
    return kwargs          # kwargs is a dict
profile(name="Yatin", age=25)  # {'name':'Yatin','age':25}

# Combining — ORDER MATTERS
def full(required, default="hi", *args, **kwargs):
    print(required, default, args, kwargs)

# ── Unpacking ──
def add(a, b, c): return a + b + c
nums = [1, 2, 3]
print(add(*nums))                # 6 — unpack list
print(add(**{"a":1,"b":2,"c":3}))  # 6 — unpack dict

# ── Keyword-only (after *) ──
def connect(host, port, *, timeout=30, ssl=True):
    pass   # timeout & ssl MUST be keyword arguments

# ── Positional-only (before /) — 3.8+ ──
def greet(name, /, greeting="Hello"):
    pass   # name MUST be positional

19 Type Hints

Type hints don't affect runtime. They exist for docs, IDE support, and tools like mypy.

def greet(name: str, times: int = 1) -> str:
    return (name + "! ") * times

# Collections
def process(
    items: list[int],
    mapping: dict[str, float],
    coords: tuple[float, float],
) -> None: ...

# Optional / Union (3.10+)
def find(id: int) -> str | None: ...
def parse(data: int | str) -> str: ...

# Callable
from typing import Callable
def apply(f: Callable[[int, int], int], a: int, b: int) -> int:
    return f(a, b)

# TypeAlias
Vector = list[float]
Matrix = list[Vector]

20 Data Structures from Scratch

Building classic data structures in Python teaches you OOP, references, recursion, and how the language actually works under the hood.

Linked List

A chain of nodes where each one points to the next. Good for fast insertions/deletions, but slow random access.

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None       # pointer to next node

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if not self.head:           # empty list
            self.head = new_node
            return
        current = self.head
        while current.next:          # walk to the end
            current = current.next
        current.next = new_node      # link it

    def prepend(self, data):
        new_node = Node(data)
        new_node.next = self.head    # point to old head
        self.head = new_node         # become the new head

    def delete(self, data):
        if not self.head:
            return
        if self.head.data == data:
            self.head = self.head.next
            return
        current = self.head
        while current.next:
            if current.next.data == data:
                current.next = current.next.next  # skip over it
                return
            current = current.next

    def __iter__(self):             # make it iterable!
        current = self.head
        while current:
            yield current.data
            current = current.next

    def __repr__(self):
        return " → ".join(str(x) for x in self) + " → None"

# Usage
ll = LinkedList()
ll.append(1)
ll.append(2)
ll.append(3)
ll.prepend(0)
print(ll)           # 0 → 1 → 2 → 3 → None
ll.delete(2)
print(ll)           # 0 → 1 → 3 → None

# Iterate like any Python collection
for val in ll:
    print(val)       # 0, 1, 3

Stack (LIFO)

Last In, First Out — like a stack of plates. The last item you add is the first one you remove.

class Stack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        if self.is_empty():
            raise IndexError("Stack is empty")
        return self._items.pop()

    def peek(self):
        return self._items[-1]

    def is_empty(self):
        return len(self._items) == 0

    def __len__(self):
        return len(self._items)

    def __repr__(self):
        return f"Stack({self._items})"

s = Stack()
s.push(1); s.push(2); s.push(3)
print(s.pop())   # 3 (last in, first out)
print(s.peek())  # 2

Queue (FIFO)

First In, First Out — like a real queue. The first item added is the first one processed.

from collections import deque

class Queue:
    def __init__(self):
        self._items = deque()   # deque is O(1) for both ends

    def enqueue(self, item):
        self._items.append(item)

    def dequeue(self):
        return self._items.popleft()

    def __len__(self):
        return len(self._items)

    def __repr__(self):
        return f"Queue({list(self._items)})"

q = Queue()
q.enqueue("first"); q.enqueue("second")
print(q.dequeue())  # "first" (first in, first out)

Binary Tree

A hierarchical structure where each node has at most two children. A BST keeps values sorted for fast search.

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

class BinarySearchTree:
    def __init__(self):
        self.root = None

    def insert(self, val):
        if not self.root:
            self.root = TreeNode(val)
            return
        self._insert(self.root, val)

    def _insert(self, node, val):
        if val < node.val:
            if node.left:
                self._insert(node.left, val)
            else:
                node.left = TreeNode(val)
        else:
            if node.right:
                self._insert(node.right, val)
            else:
                node.right = TreeNode(val)

    def search(self, val):
        return self._search(self.root, val)

    def _search(self, node, val):
        if not node:
            return False
        if val == node.val:
            return True
        if val < node.val:
            return self._search(node.left, val)
        return self._search(node.right, val)

    def inorder(self, node="DEFAULT"):
        """In-order traversal: left → root → right (sorted order!)"""
        if node == "DEFAULT":
            node = self.root
        if not node:
            return []
        return self.inorder(node.left) + [node.val] + self.inorder(node.right)

# Usage
bst = BinarySearchTree()
for val in [5, 3, 7, 1, 4, 6, 8]:
    bst.insert(val)

print(bst.inorder())     # [1, 3, 4, 5, 6, 7, 8] — sorted!
print(bst.search(4))     # True
print(bst.search(99))    # False

# The tree looks like:
#        5
#       / \
#      3   7
#     / \ / \
#    1  4 6  8

Hash Map (Dictionary internals)

How Python's dict works under the hood — hashing keys to bucket indices for O(1) average lookup.

class HashMap:
    """Simplified version of how Python's dict works."""
    def __init__(self, size=16):
        self.size = size
        self.buckets = [[] for _ in range(size)]

    def _hash(self, key):
        return hash(key) % self.size   # map key to bucket index

    def __setitem__(self, key, value):   # hm[key] = value
        idx = self._hash(key)
        for i, (k, v) in enumerate(self.buckets[idx]):
            if k == key:
                self.buckets[idx][i] = (key, value)
                return
        self.buckets[idx].append((key, value))

    def __getitem__(self, key):          # hm[key]
        idx = self._hash(key)
        for k, v in self.buckets[idx]:
            if k == key:
                return v
        raise KeyError(key)

hm = HashMap()
hm["name"] = "Yatin"
print(hm["name"])    # Yatin

21 Concurrency & The GIL

# ── Threading — for I/O-bound ──
import threading, time

def download(url):
    time.sleep(2)  # simulate I/O

# Sequential: 6s  |  Threaded: ~2s
threads = [threading.Thread(target=download, args=(u,))
           for u in ["u1", "u2", "u3"]]
for t in threads: t.start()
for t in threads: t.join()

# ── Multiprocessing — for CPU-bound (bypasses GIL) ──
from multiprocessing import Pool

def compute(n):
    return sum(i**2 for i in range(n))

with Pool(4) as pool:
    results = pool.map(compute, [10**6]*4)

# ── asyncio — modern I/O-bound ──
import asyncio

async def fetch(url):
    await asyncio.sleep(2)
    return f"Data from {url}"

async def main():
    results = await asyncio.gather(
        fetch("api/users"), fetch("api/posts")
    )

asyncio.run(main())  # ~2s, not ~4s

22 Memory Model

import sys

# Everything is heap-allocated
print(sys.getsizeof(0))     # 28 bytes — even an int!
print(sys.getsizeof(""))    # 49 bytes — empty string!
print(sys.getsizeof([]))   # 56 bytes — empty list!

# Reference counting — primary GC
a = [1, 2]   # refcount = 1
b = a        # refcount = 2
del b        # refcount = 1
del a        # refcount = 0 → freed immediately

# Circular refs → generational GC handles them
import gc
gc.collect()

# ── __slots__ — save memory ──
class Point:
    __slots__ = ("x", "y")   # no __dict__ per instance
    def __init__(self, x, y):
        self.x = x
        self.y = y

# Regular class: ~152 bytes/instance
# With __slots__: ~56 bytes/instance
# 1M points = ~100MB saved!

23 Metaclasses & Descriptors

A metaclass is the "class of a class." type is the default metaclass.

print(type(42))      # <class 'int'>
print(type(int))     # <class 'type'> — int is an instance of type!
print(type(type))    # <class 'type'> — type is its own metaclass

# Singleton metaclass
class SingletonMeta(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Database(metaclass=SingletonMeta):
    pass

print(Database() is Database())  # True — always same object

Descriptors

The low-level mechanism behind @property, @classmethod, and @staticmethod — controls how attribute access works.

# The mechanism behind @property, @classmethod, @staticmethod
class Positive:
    def __set_name__(self, owner, name):
        self.name = name
        self.storage = f"_{name}"

    def __get__(self, obj, objtype=None):
        return getattr(obj, self.storage, None)

    def __set__(self, obj, value):
        if value <= 0:
            raise ValueError(f"{self.name} must be positive")
        setattr(obj, self.storage, value)

class Product:
    price = Positive()      # descriptor on the CLASS
    quantity = Positive()

    def __init__(self, name, price, qty):
        self.name = name
        self.price = price       # triggers Positive.__set__
        self.quantity = qty

24 Design Patterns

# ── Strategy (first-class functions) ──
def sort_by_name(items):
    return sorted(items, key=lambda x: x["name"])

def display(items, strategy):
    return strategy(items)

# ── Observer ──
class EventEmitter:
    def __init__(self):
        self._listeners = {}
    def on(self, event, cb):
        self._listeners.setdefault(event, []).append(cb)
    def emit(self, event, *args):
        for cb in self._listeners.get(event, []):
            cb(*args)

# ── Registry (common in ML frameworks) ──
REGISTRY = {}
def register(name):
    def dec(cls):
        REGISTRY[name] = cls
        return cls
    return dec

@register("linear")
class LinearModel: pass

model = REGISTRY["linear"]()  # create by name

25 Testing

import pytest

def add(a, b): return a + b

# Test functions start with test_
def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0

# Test exceptions
def test_divide_zero():
    with pytest.raises(ZeroDivisionError):
        1 / 0

# Fixtures — setup/teardown
@pytest.fixture
def sample_data():
    data = {"users": ["Alice", "Bob"]}
    yield data    # test runs at yield point
    # cleanup after

def test_users(sample_data):
    assert len(sample_data["users"]) == 2

# Parametrize — run same test with different inputs
@pytest.mark.parametrize("a,b,expected", [
    (1,2,3), (-1,1,0), (0,0,0),
])
def test_add_many(a, b, expected):
    assert add(a, b) == expected

# Run: pytest test_file.py -v

26 Dataclasses

from dataclasses import dataclass, field, asdict

# Auto-generates __init__, __repr__, __eq__
@dataclass
class Point:
    x: float
    y: float
    z: float = 0.0

p = Point(1, 2)
print(p)                      # Point(x=1, y=2, z=0.0)
print(p == Point(1, 2))       # True

# frozen=True → immutable (hashable, can be dict keys)
@dataclass(frozen=True)
class Color:
    r: int; g: int; b: int

# slots=True → memory efficient (3.10+)
@dataclass(slots=True)
class Particle:
    x: float; y: float; mass: float

# Mutable defaults need field(default_factory=...)
@dataclass
class Config:
    name: str
    tags: list[str] = field(default_factory=list)

    def __post_init__(self):
        # Runs AFTER auto-generated __init__ — for validation
        if not self.name:
            raise ValueError("Name required")

print(asdict(Config("app", ["ml"])))
# {'name': 'app', 'tags': ['ml']}

27 Functional Programming

from functools import reduce, partial
from itertools import chain, islice, groupby, product

# ── partial — lock in some arguments ──
def power(base, exp): return base ** exp

square = partial(power, exp=2)
print(square(5))   # 25

# ── itertools ──
list(chain([1,2], [3,4]))        # [1,2,3,4]  flatten
list(islice(infinite(), 5))     # [0,1,2,3,4] lazy slice
list(product([1,2], ["a","b"])) # all combinations

# reduce — accumulate
print(reduce(lambda a,b: a+b, [1,2,3,4]))  # 10

28 NumPy Foundation

NumPy is the foundation of ALL Python ML/data science. Every ML library uses NumPy arrays internally.

import numpy as np

# ── Creation ──
a = np.array([1, 2, 3])
b = np.zeros((3, 4))             # 3x4 zeros
c = np.ones((2, 3))              # 2x3 ones
d = np.arange(0, 10, 2)          # [0, 2, 4, 6, 8]
e = np.linspace(0, 1, 5)         # [0, 0.25, 0.5, 0.75, 1.0]
f = np.random.randn(3, 3)        # 3x3 random normal
g = np.eye(3)                     # identity matrix

# ── Shape ──
print(b.shape)   # (3, 4)
print(b.dtype)   # float64
print(b.ndim)    # 2
x = np.arange(12).reshape(3, 4)  # reshape

# ── Vectorized ops (100x faster than Python loops) ──
a = np.array([1, 2, 3])
b = np.array([10, 20, 30])
print(a + b)       # [11, 22, 33]
print(a * b)       # [10, 40, 90]
print(a ** 2)      # [1, 4, 9]

# ── Boolean indexing ──
data = np.array([10, 25, 3, 40])
print(data[data > 10])   # [25, 40]

# ── Broadcasting ──
matrix = np.ones((3, 3))
row = np.array([1, 2, 3])
print(matrix + row)  # row is broadcast across all rows

# ── Linear algebra ──
A = np.array([[1,2],[3,4]])
B = np.array([[5,6],[7,8]])
print(A @ B)                    # matrix multiply
print(np.linalg.inv(A))         # inverse
print(np.linalg.det(A))         # determinant

# ── Aggregations ──
m = np.array([[1,2,3],[4,5,6]])
print(m.sum(axis=0))   # [5,7,9]  per column
print(m.sum(axis=1))   # [6, 15]  per row
print(m.mean(), m.std())

29 Pandas Foundation

import pandas as pd

df = pd.DataFrame({
    "name": ["Alice", "Bob", "Charlie"],
    "age": [25, 30, 35],
    "salary": [50000, 60000, 70000],
    "dept": ["Eng", "Mkt", "Eng"]
})

# ── Explore ──
df.head()          # first 5 rows
df.info()          # types, non-null counts
df.describe()      # statistics

# ── Select ──
df["name"]                   # one column (Series)
df[["name", "age"]]          # multiple columns
df.loc[0]                     # row by label
df.iloc[0:2]                  # rows by position

# ── Filter (SQL WHERE) ──
df[df["age"] > 28]
df[(df["dept"] == "Eng") & (df["salary"] > 55000)]
# Use & not 'and', | not 'or'

# ── New columns ──
df["bonus"] = df["salary"] * 0.1

# ── GroupBy (SQL GROUP BY) ──
df.groupby("dept")["salary"].mean()

# ── Missing data ──
df.dropna()                # drop rows with NaN
df.fillna(0)               # replace NaN
df.isna().sum()            # count NaNs per column

# ── Merge (SQL JOIN) ──
orders = pd.DataFrame({"uid": [1,2], "product": ["A","B"]})
users = pd.DataFrame({"uid": [1,2], "name": ["Alice","Bob"]})
merged = pd.merge(orders, users, on="uid")

# ── Read/Write ──
# pd.read_csv("data.csv")
# df.to_csv("out.csv", index=False)

30 The ML Bridge — Everything Together

This example uses almost every Python concept from this guide to build Linear Regression from scratch.

import numpy as np
import pandas as pd
from dataclasses import dataclass
from abc import ABC, abstractmethod
from functools import wraps
import time

# Decorator
def log_time(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"[{func.__name__}] {time.perf_counter()-start:.2f}s")
        return result
    return wrapper

# Dataclass for config
@dataclass
class Config:
    lr: float = 0.01
    epochs: int = 100
    reg: float = 0.001

# ABC for model interface
class BaseModel(ABC):
    def __init__(self, config: Config):
        self.config = config
        self.weights = None

    @abstractmethod
    def fit(self, X, y): ...

    @abstractmethod
    def predict(self, X): ...

    def __repr__(self):
        return f"{self.__class__.__name__}(lr={self.config.lr})"

# Concrete model
class LinearRegression(BaseModel):
    @log_time
    def fit(self, X, y):
        X_b = np.c_[np.ones(X.shape[0]), X]
        self.weights = np.zeros(X_b.shape[1])

        for _ in range(self.config.epochs):
            preds = X_b @ self.weights
            errors = preds - y
            grad = (2 / len(y)) * X_b.T @ errors
            self.weights -= self.config.lr * grad
        return self

    def predict(self, X):
        X_b = np.c_[np.ones(X.shape[0]), X]
        return X_b @ self.weights

# Generator for mini-batches
def batch_gen(X, y, size=32):
    idx = np.random.permutation(len(X))
    for i in range(0, len(X), size):
        yield X[idx[i:i+size]], y[idx[i:i+size]]

# Run it
if __name__ == "__main__":
    np.random.seed(42)
    X = np.random.randn(100, 3)
    true_w = np.array([2.0, -1.0, 0.5])
    y = X @ true_w + np.random.randn(100) * 0.1

    model = LinearRegression(Config(lr=0.01, epochs=1000))
    model.fit(X, y)

    print(f"Learned: {model.weights[1:]}")
    print(f"True:    {true_w}")