import sys

# Simple integer
x = 42
print(f"Integer 42:")
print(f"  Size: {sys.getsizeof(x)} bytes")
print(f"  ID: {id(x):#x}")
print(f"  Type: {type(x)}")

# List of integers
lst = [1, 2, 3, 4, 5]
print(f"\nList [1,2,3,4,5]:")
print(f"  List object: {sys.getsizeof(lst)} bytes")
print(f"  Plus 5 integers: {5 * sys.getsizeof(1)} bytes")
print(f"  Total: ~{sys.getsizeof(lst) + 5*28} bytes")

# C equivalent would be 20 bytes (5 × 4)

Integer 42:
  Size: 28 bytes
  ID: 0x102c1e4c0
  Type: <class 'int'>

List [1,2,3,4,5]:
  List object: 104 bytes
  Plus 5 integers: 140 bytes
  Total: ~244 bytes

x = [1, 2, 3]  # x refers to a list object
y = x          # y refers to THE SAME object
y.append(4)    # Modifying through y
print(f"x = {x}")  # x sees the change!

# To create a copy:
z = x.copy()   # or x[:] or list(x)
z.append(5)
print(f"x = {x}, z = {z}")  # x unchanged

x = [1, 2, 3, 4]
x = [1, 2, 3, 4], z = [1, 2, 3, 4, 5]

import timeit
import operator

# Python function call overhead
def python_add(a, b):
    return a + b

# Direct operator
op_add = operator.add

a, b = 5, 10
n = 1000000

t1 = timeit.timeit(lambda: a + b, number=n)
t2 = timeit.timeit(lambda: op_add(a, b), number=n)
t3 = timeit.timeit(lambda: python_add(a, b), number=n)

print(f"Direct +: {t1:.3f}s")
print(f"operator.add: {t2:.3f}s ({t2/t1:.1f}x slower)")
print(f"Function: {t3:.3f}s ({t3/t1:.1f}x slower)")

Direct +: 0.013s
operator.add: 0.016s (1.2x slower)
Function: 0.022s (1.7x slower)

# Create a custom iterator
class Fibonacci:
    def __init__(self, max_n):
        self.max_n = max_n
        self.n = 0
        self.current = 0
        self.next_val = 1
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.n >= self.max_n:
            raise StopIteration
        
        result = self.current
        self.current, self.next_val = \
            self.next_val, self.current + self.next_val
        self.n += 1
        return result

# Use like any sequence
for f in Fibonacci(10):
    print(f, end=' ')
print()

# This is why range() is memory efficient
print(f"\nrange(1000000): {sys.getsizeof(range(1000000))} bytes")

0 1 1 2 3 5 8 13 21 34 

range(1000000): 48 bytes

def make_multiplier(n):
    """Factory function creating closures."""
    def multiplier(x):
        return x * n  # n is captured

    # Function is an object we can modify
    multiplier.factor = n
    multiplier.__name__ = f'times_{n}'
    return multiplier

times_2 = make_multiplier(2)
times_10 = make_multiplier(10)

print(f"{times_2.__name__}: {times_2(5)}")
print(f"{times_10.__name__}: {times_10(5)}")
print(f"Factors: {times_2.factor}, {times_10.factor}")

# Inspect closure
import inspect
closure_vars = inspect.getclosurevars(times_2)
print(f"Captured: {closure_vars.nonlocals}")

times_2: 10
times_10: 50
Factors: 2, 10
Captured: {'n': 2}

x = "global"  # Global namespace

def outer():
    x = "enclosing"  # Enclosing namespace
    
    def inner():
        print(f"Reading x: {x}")  # LEGB search finds enclosing
        
    def inner_local():
        x = "local"  # Creates local binding
        print(f"Local x: {x}")
        
    inner()
    inner_local()
    print(f"Enclosing x: {x}")

outer()
print(f"Global x: {x}")

# Namespace modification
def show_namespace_dict():
    local_var = 42
    print(f"locals(): {locals()}")
    print(f"'local_var' in locals(): {'local_var' in locals()}")

show_namespace_dict()

Reading x: enclosing
Local x: local
Enclosing x: enclosing
Global x: global
locals(): {'local_var': 42}
'local_var' in locals(): True

# UnboundLocalError example
count = 0
def increment():
    # Python sees assignment, creates local slot
    # But referenced before assignment
    try:
        count += 1  # UnboundLocalError
    except UnboundLocalError as e:
        print(f"Error: {e}")

increment()

Error: cannot access local variable 'count' where it is not associated with a value

import numpy as np

# Memory comparison
py_list = [1, 2, 3, 4, 5]
np_array = np.array([1, 2, 3, 4, 5])

print(f"Python list overhead: {sys.getsizeof(py_list)} bytes")
print(f"NumPy array overhead: {sys.getsizeof(np_array)} bytes")
print(f"NumPy data buffer: {np_array.nbytes} bytes")

# Performance impact
import timeit
lst = list(range(1000))
arr = np.arange(1000)

t_list = timeit.timeit(lambda: sum(lst), number=10000)
t_numpy = timeit.timeit(lambda: arr.sum(), number=10000)

print(f"\nSum 1000 elements:")
print(f"Python list: {t_list:.4f}s")
print(f"NumPy array: {t_numpy:.4f}s ({t_list/t_numpy:.1f}x faster)")

Python list overhead: 104 bytes
NumPy array overhead: 152 bytes
NumPy data buffer: 40 bytes

Sum 1000 elements:
Python list: 0.0228s
NumPy array: 0.0061s (3.7x faster)

# Immutable: operations create new objects
s = "hello"
print(f"Original id: {id(s):#x}")
s = s + " world"  # Creates new object
print(f"After +=:    {id(s):#x}")

# Mutable: operations modify in place
lst = [1, 2, 3]
original_id = id(lst)
lst.append(4)  # Modifies in place
print(f"\nList id before: {original_id:#x}")
print(f"List id after:  {id(lst):#x}")
print(f"Same object: {id(lst) == original_id}")

# The danger of mutable defaults
def add_to_list(item, target=[]):  # Mutable default argument
    target.append(item)
    return target

list1 = add_to_list(1)
list2 = add_to_list(2)  # Shares same default list
print(f"\nlist1: {list1}")
print(f"list2: {list2}")
print(f"Same object: {list1 is list2}")

Original id: 0x105945440
After +=:    0x10b78ee70

List id before: 0x10b7cefc0
List id after:  0x10b7cefc0
Same object: True

list1: [1, 2]
list2: [1, 2]
Same object: True

import timeit

# EAFP vs LBYL performance
d = {str(i): i for i in range(100)}

def eafp_found():
    try:
        return d['50']
    except KeyError:
        return None

def lbyl_found():
    if '50' in d:
        return d['50']
    return None

def eafp_not_found():
    try:
        return d['200']
    except KeyError:
        return None

def lbyl_not_found():
    if '200' in d:
        return d['200']
    return None

n = 100000
print("Key exists:")
print(f"  EAFP: {timeit.timeit(eafp_found, number=n):.3f}s")
print(f"  LBYL: {timeit.timeit(lbyl_found, number=n):.3f}s")

print("Key missing:")
print(f"  EAFP: {timeit.timeit(eafp_not_found, number=n):.3f}s")
print(f"  LBYL: {timeit.timeit(lbyl_not_found, number=n):.3f}s")

Key exists:
  EAFP: 0.002s
  LBYL: 0.003s
Key missing:
  EAFP: 0.008s
  LBYL: 0.001s

import dis

def square(x):
    return x * x

# View the bytecode
print("Bytecode for square(x):")
dis.dis(square)

Bytecode for square(x):
  3           RESUME                   0

  4           LOAD_FAST_LOAD_FAST      0 (x, x)
              BINARY_OP                5 (*)
              RETURN_VALUE

x = 42
y = 3.14
name = "tensor"
flag = True

# Reassignment can change type
x = "now a string"

s = "deep learning"
print(s.upper())
print(s.split())
print(s.replace("deep", "machine"))

DEEP LEARNING
['deep', 'learning']
machine learning

accuracy = 0.9423
epochs = 10000

print(f"Accuracy: {accuracy:.2%}")
print(f"Epochs: {epochs:,}")
print(f"Result: {accuracy:.4f}")

Accuracy: 94.23%
Epochs: 10,000
Result: 0.9423

layers = [64, 128, 256]

# Modify in place
layers.append(512)        # Add to end
layers.insert(0, 32)      # Insert at index
layers.extend([1024])     # Add multiple
print(f"After additions: {layers}")

# Remove elements
layers.pop()              # Remove last
layers.remove(128)        # Remove by value
print(f"After removals: {layers}")

After additions: [32, 64, 128, 256, 512, 1024]
After removals: [32, 64, 256, 512]

# Creating tuples
point = (3, 4)
rgb = (255, 128, 0)
single = (42,)        # Note the comma!
empty = ()

# Unpacking
x, y = point
r, g, b = rgb
print(f"Point: x={x}, y={y}")

# Unpacking with * (rest)
first, *rest = [1, 2, 3, 4, 5]
print(f"First: {first}, Rest: {rest}")

# Swapping uses tuple packing/unpacking
a, b = 1, 2
a, b = b, a           # Swap!
print(f"Swapped: a={a}, b={b}")

Point: x=3, y=4
First: 1, Rest: [2, 3, 4, 5]
Swapped: a=2, b=1

def minmax(data):
    """Return (min, max) tuple."""
    return min(data), max(data)

lo, hi = minmax([3, 1, 4, 1, 5, 9])
print(f"Range: {lo} to {hi}")

# Named tuples for clarity
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(3, 4)
print(f"Point: {p.x}, {p.y}")
print(f"Distance: {(p.x**2 + p.y**2)**0.5:.2f}")

Range: 1 to 9
Point: 3, 4
Distance: 5.00

config = {
    "learning_rate": 0.001,
    "epochs": 100,
    "batch_size": 32,
}

# Access and modify
print(f"LR: {config['learning_rate']}")
config["dropout"] = 0.5

# Safe access with .get()
momentum = config.get("momentum", 0.9)
print(f"Momentum: {momentum}")

# Iteration
for key, value in config.items():
    print(f"  {key}: {value}")

LR: 0.001
Momentum: 0.9
  learning_rate: 0.001
  epochs: 100
  batch_size: 32
  dropout: 0.5

# Merging dicts (Python 3.9+)
defaults = {"lr": 0.01, "epochs": 10}
overrides = {"epochs": 100}
final = defaults | overrides
print(f"Merged: {final}")

Merged: {'lr': 0.01, 'epochs': 100}

# Creating sets
seen_labels = {0, 1, 2, 1, 0}  # Duplicates removed
print(f"Unique labels: {seen_labels}")

# From list (common pattern)
data = [1, 2, 2, 3, 3, 3]
unique = set(data)
print(f"Unique values: {unique}")
print(f"Count: {len(unique)}")

# Membership testing (fast!)
if 2 in seen_labels:
    print("Label 2 exists")

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

print(f"Union: {a | b}")
print(f"Intersection: {a & b}")
print(f"Difference: {a - b}")
print(f"Symmetric diff: {a ^ b}")

Unique labels: {0, 1, 2}
Unique values: {1, 2, 3}
Count: 3
Label 2 exists
Union: {1, 2, 3, 4, 5, 6}
Intersection: {3, 4}
Difference: {1, 2}
Symmetric diff: {1, 2, 5, 6}

# Finding duplicates
items = ["cat", "dog", "cat", "bird", "dog"]
seen = set()
duplicates = set()

for item in items:
    if item in seen:
        duplicates.add(item)
    seen.add(item)

print(f"Duplicates: {duplicates}")

Duplicates: {'dog', 'cat'}

import timeit

data_list = list(range(10000))
data_set = set(range(10000))

t_list = timeit.timeit(lambda: 9999 in data_list, number=1000)
t_set = timeit.timeit(lambda: 9999 in data_set, number=1000)

print(f"List lookup: {t_list*1000:.2f}ms")
print(f"Set lookup:  {t_set*1000:.2f}ms")
print(f"Set is {t_list/t_set:.0f}x faster")

List lookup: 26.75ms
Set lookup:  0.02ms
Set is 1540x faster

data = [10, 20, 30, 40, 50, 60, 70]

print(f"data[2:5]  = {data[2:5]}")   # [30, 40, 50]
print(f"data[:3]   = {data[:3]}")    # [10, 20, 30]
print(f"data[4:]   = {data[4:]}")    # [50, 60, 70]
print(f"data[::2]  = {data[::2]}")   # [10, 30, 50, 70]
print(f"data[::-1] = {data[::-1]}")  # Reversed
print(f"data[1:-1] = {data[1:-1]}")  # [20, 30, 40, 50, 60]

data[2:5]  = [30, 40, 50]
data[:3]   = [10, 20, 30]
data[4:]   = [50, 60, 70]
data[::2]  = [10, 30, 50, 70]
data[::-1] = [70, 60, 50, 40, 30, 20, 10]
data[1:-1] = [20, 30, 40, 50, 60]

original = [1, 2, 3, 4, 5]
copy = original[:]       # Shallow copy
copy[0] = 999
print(f"Original: {original}")
print(f"Copy: {copy}")

Original: [1, 2, 3, 4, 5]
Copy: [999, 2, 3, 4, 5]

data = [1, 2, 3, 4, 5]
data[1:4] = [20, 30]     # Replace slice
print(f"After: {data}")

data[2:2] = [100, 200]   # Insert at index 2
print(f"After insert: {data}")

After: [1, 20, 30, 5]
After insert: [1, 20, 100, 200, 30, 5]

score = 0.85

if score >= 0.9:
    grade = "A"
elif score >= 0.8:
    grade = "B"
elif score >= 0.7:
    grade = "C"
else:
    grade = "F"

print(grade)

B

training = True
rate = 0.5 if training else 0.0
print(rate)

0.5

# Second part not evaluated if first is False
x = None
if x is not None and x > 0:
    print("Positive")
else:
    print("None or non-positive")

None or non-positive

x = 50
print(0 <= x <= 100)  # Equivalent to: 0 <= x and x <= 100

True

# All falsy
values = [False, None, 0, 0.0, "", [], {}, set()]
print([bool(v) for v in values])

[False, False, False, False, False, False, False, False]

data = []

# Instead of: if len(data) > 0:
if data:
    print("Has items")
else:
    print("Empty")

# Default value pattern
name = ""
display_name = name or "Anonymous"
print(f"Hello, {display_name}")

# Guard clause
result = None
value = result or "default"
print(value)

Empty
Hello, Anonymous
default

print(0 or 42)      # Returns 42, not True
print("" or "hi")   # Returns "hi"

42
hi

# Iterate over elements directly
for x in [10, 20, 30]:
    print(x)

10
20
30

# range(stop), range(start, stop), range(start, stop, step)
print(list(range(5)))        # [0, 1, 2, 3, 4]
print(list(range(2, 6)))     # [2, 3, 4, 5]
print(list(range(0, 10, 2))) # [0, 2, 4, 6, 8]

[0, 1, 2, 3, 4]
[2, 3, 4, 5]
[0, 2, 4, 6, 8]

layers = ["conv1", "conv2", "fc"]
for i, name in enumerate(layers):
    print(f"Layer {i}: {name}")

Layer 0: conv1
Layer 1: conv2
Layer 2: fc

names = ["Alice", "Bob", "Carol"]
scores = [85, 92, 78]

for name, score in zip(names, scores):
    print(f"{name}: {score}")

Alice: 85
Bob: 92
Carol: 78

# else clause (rarely used but useful)
for n in [2, 3, 5, 7]:
    if n == 4:
        break
else:
    print("No 4 found")  # Runs because no break

No 4 found

# Convergence loop (common in optimization)
loss = 1.0
iteration = 0
tolerance = 0.1

while loss > tolerance:
    loss *= 0.5
    iteration += 1

print(f"Converged in {iteration} iterations")
print(f"Final loss: {loss:.4f}")

Converged in 4 iterations
Final loss: 0.0625

# Transform each element
squares = [x**2 for x in range(6)]
print(squares)

# Filter elements
evens = [x for x in range(10) if x % 2 == 0]
print(evens)

# Equivalent explicit loop:
# evens = []
# for x in range(10):
#     if x % 2 == 0:
#         evens.append(x)

[0, 1, 4, 9, 16, 25]
[0, 2, 4, 6, 8]

# Flatten a matrix
matrix = [[1, 2], [3, 4], [5, 6]]
flat = [x for row in matrix for x in row]
print(flat)

[1, 2, 3, 4, 5, 6]

# Dict: {key_expr: value_expr for ...}
words = ["cat", "dog", "elephant"]
lengths = {w: len(w) for w in words}
print(lengths)

# Set: {expr for ...}
remainders = {x % 3 for x in range(10)}
print(remainders)

{'cat': 3, 'dog': 3, 'elephant': 8}
{0, 1, 2}

# Parentheses instead of brackets
gen = (x**2 for x in range(1000000))
print(type(gen))
print(sum(gen))  # Computed on-demand

<class 'generator'>
333332833333500000

def compute_accuracy(correct, total):
    """Compute classification accuracy."""
    return correct / total

print(compute_accuracy(85, 100))

0.85

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}"

print(greet("Alice"))
print(greet("Bob", "Hi"))

Hello, Alice
Hi, Bob

def min_max(data):
    return min(data), max(data)

lo, hi = min_max([3, 1, 4, 1, 5])
print(f"Range: {lo} to {hi}")

Range: 1 to 5

def train(model, lr, epochs):
    print(f"model={model}, lr={lr}, epochs={epochs}")

train("resnet", 0.01, 100)           # Positional
train("resnet", epochs=50, lr=0.001) # Keyword (any order)
train("resnet", 0.01, epochs=200)    # Mixed

model=resnet, lr=0.01, epochs=100
model=resnet, lr=0.001, epochs=50
model=resnet, lr=0.01, epochs=200

def log_call(name, *args, **kwargs):
    print(f"Function: {name}")
    print(f"  args: {args}")
    print(f"  kwargs: {kwargs}")

log_call("train", 100, 0.01, lr=0.001, verbose=True)

Function: train
  args: (100, 0.01)
  kwargs: {'lr': 0.001, 'verbose': True}

def append_to(item, target=[]):
    target.append(item)
    return target

a = append_to(1)
b = append_to(2)
c = append_to(3)

print(f"a = {a}")
print(f"b = {b}")
print(f"c = {c}")
# Same list object for all calls

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

def append_to(item, target=None):
    if target is None:
        target = []  # New list each call
    target.append(item)
    return target

a = append_to(1)
b = append_to(2)
print(f"a = {a}, b = {b}")

a = [1], b = [2]

class Layer:
    def __init__(self, in_size, out_size):
        self.in_size = in_size
        self.out_size = out_size

    def num_params(self):
        return self.in_size * self.out_size + self.out_size

    def __repr__(self):
        return f"Layer({self.in_size}, {self.out_size})"

layer = Layer(784, 256)
print(layer)
print(f"Parameters: {layer.num_params():,}")

Layer(784, 256)
Parameters: 200,960

import math                    # Entire module
print(math.sqrt(2))

import numpy as np             # Alias

from collections import Counter  # Specific name
print(Counter("abracadabra"))

1.4142135623730951
Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})

import sys
print(sys.path[:3])  # First 3 entries

['/opt/homebrew/anaconda3/lib/python313.zip', '/opt/homebrew/anaconda3/lib/python3.13', '/opt/homebrew/anaconda3/lib/python3.13/lib-dynload']

def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return float('inf')

print(safe_divide(10, 2))
print(safe_divide(10, 0))

5.0
inf

def mean(values: list[float]) -> float:
    return sum(values) / len(values)

def find_max(values: list[float]) -> float | None:
    if not values:
        return None
    return max(values)

print(mean([1.0, 2.0, 3.0]))
print(find_max([]))

2.0
None

import sys

# Memory comparison
lst = [1, 2, 3, 4, 5]
tup = (1, 2, 3, 4, 5)
string = "12345"

print("Memory usage:")
print(f"  List:   {sys.getsizeof(lst)} bytes")
print(f"  Tuple:  {sys.getsizeof(tup)} bytes")
print(f"  String: {sys.getsizeof(string)} bytes")

# Hashability determines dict key eligibility
print("\nCan be dict key:")
for obj, name in [(lst, 'List'), (tup, 'Tuple'), (string, 'String')]:
    try:
        d = {obj: 'value'}
        print(f"  {name}: Yes")
    except TypeError:
        print(f"  {name}: No")

Memory usage:
  List:   104 bytes
  Tuple:  80 bytes
  String: 46 bytes

Can be dict key:
  List: No
  Tuple: Yes
  String: Yes

# Observe allocation behavior
import sys

lst = []
sizes_and_caps = []

for i in range(20):
    lst.append(i)
    # Size includes list object overhead
    total_size = sys.getsizeof(lst)
    # Approximate capacity from size
    capacity = (total_size - sys.getsizeof([])) // 8
    sizes_and_caps.append((len(lst), capacity))
    
# Show growth points
print("Size → Capacity:")
last_cap = 0
for size, cap in sizes_and_caps:
    if cap != last_cap:
        print(f"  {size:2d} → {cap:2d} (grew by {cap - last_cap})")
        last_cap = cap

Size → Capacity:
   1 →  4 (grew by 4)
   5 →  8 (grew by 4)
   9 → 16 (grew by 8)
  17 → 24 (grew by 8)

# Dictionary internals
d = {'a': 1, 'b': 2, 'c': 3}

# Show hash values
for key in d:
    print(f"hash('{key}') = {hash(key):20d}")

# Dictionary growth
import sys
sizes = []
for i in range(20):
    d = {str(j): j for j in range(i)}
    sizes.append((i, sys.getsizeof(d)))

print("\nDict size growth:")
last_size = 0
for n, size in sizes:
    if size != last_size:
        print(f"  {n:2d} items: {size:4d} bytes")
        last_size = size

hash('a') = -7315216989034702776
hash('b') =  2805302887546029812
hash('c') =  4965872525638186726

Dict size growth:
   0 items:   64 bytes
   1 items:  184 bytes
   6 items:  272 bytes
  11 items:  464 bytes

# Set performance demonstration
import random

# Create test data
numbers = list(range(10000))
random.shuffle(numbers)

test_list = numbers[:5000]
test_set = set(test_list)

# Membership testing
lookups = random.sample(range(10000), 100)

import time

# List lookup
start = time.perf_counter()
for x in lookups:
    _ = x in test_list
list_time = time.perf_counter() - start

# Set lookup
start = time.perf_counter()
for x in lookups:
    _ = x in test_set
set_time = time.perf_counter() - start

print(f"100 lookups in collection of 5000:")
print(f"  List: {list_time*1000:.3f} ms")
print(f"  Set:  {set_time*1000:.3f} ms")
print(f"  Speedup: {list_time/set_time:.1f}x")

# Set operations
a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}

print(f"\nSet operations:")
print(f"  a & b = {a & b}")  # Intersection
print(f"  a | b = {a | b}")  # Union
print(f"  a - b = {a - b}")  # Difference
print(f"  a ^ b = {a ^ b}")  # Symmetric difference

100 lookups in collection of 5000:
  List: 1.177 ms
  Set:  0.019 ms
  Speedup: 62.5x

Set operations:
  a & b = {4, 5}
  a | b = {1, 2, 3, 4, 5, 6, 7, 8}
  a - b = {1, 2, 3}
  a ^ b = {1, 2, 3, 6, 7, 8}

# Functions are objects
def square(x):
    return x * x

# Assign to variable
f = square
print(f(5))

# Pass as argument
def apply_twice(func, x):
    return func(func(x))

print(apply_twice(square, 2))  # square(square(2)) = 16

# Return from function
def make_power(n):
    def power(x):
        return x ** n
    return power

cube = make_power(3)
print(cube(4))  # 64

25
16
64

def make_counter(start=0):
    count = start  # Captured by inner function

    def increment():
        nonlocal count  # Modify captured variable
        count += 1
        return count

    return increment

# Each call creates a new closure with its own count
counter_a = make_counter()
counter_b = make_counter(100)

print(f"counter_a(): {counter_a()}")  # 1
print(f"counter_a(): {counter_a()}")  # 2
print(f"counter_b(): {counter_b()}")  # 101 (independent)

counter_a(): 1
counter_a(): 2
counter_b(): 101

import functools

def logged(func):
    """Decorator that logs function calls."""
    @functools.wraps(func)  # Preserve name/docstring
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Returned {result}")
        return result
    return wrapper

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

# @logged is equivalent to: add = logged(add)
result = add(2, 3)

Calling add
Returned 5

# Generator function uses yield
def countdown(n):
    while n > 0:
        yield n
        n -= 1

# Values produced on demand
for x in countdown(5):
    print(x, end=' ')
print()

# Generator expression (like list comprehension)
squares = (x**2 for x in range(5))
print(list(squares))

5 4 3 2 1 
[0, 1, 4, 9, 16]

# Inheritance approach
class Vector(list):
    """Vector inherits from list."""
    
    def __init__(self, components):
        super().__init__(components)
    
    def magnitude(self):
        return sum(x**2 for x in self) ** 0.5
    
    def dot(self, other):
        return sum(a*b for a, b in zip(self, other))

# Problems with inheritance
v = Vector([3, 4])
print(f"Vector: {v}")
print(f"Magnitude: {v.magnitude()}")

# But inherits unwanted methods
v.reverse()  # Modifies in place!
print(f"After reverse: {v}")
v.append(5)  # Now 3D?
print(f"After append: {v}")

Vector: [3, 4]
Magnitude: 5.0
After reverse: [4, 3]
After append: [4, 3, 5]

# Composition approach
class Signal:
    """Signal uses composition."""
    
    def __init__(self, data, sample_rate):
        self._data = np.array(data)
        self.fs = sample_rate
        self._filter = None
    
    def __len__(self):
        return len(self._data)
    
    def __getitem__(self, idx):
        return self._data[idx]
    
    @property
    def duration(self):
        return len(self._data) / self.fs
    
    def fft(self):
        """Delegate to NumPy."""
        return np.fft.fft(self._data)
    
    def resample(self, new_rate):
        """Return new Signal."""
        ratio = new_rate / self.fs
        new_length = int(len(self._data) * ratio)
        new_data = np.interp(
            np.linspace(0, len(self._data), new_length),
            np.arange(len(self._data)),
            self._data
        )
        return Signal(new_data, new_rate)

# Clean interface
sig = Signal([1, 2, 3, 4], sample_rate=100)
print(f"Duration: {sig.duration}s")
print(f"FFT shape: {sig.fft().shape}")