t = ([1, 2],)
t[0].append(3)  # Works! t is now ([1, 2, 3],)
t[0] = [4, 5]   # TypeError: 'tuple' object does not support item assignment

# DANGEROUS: mutable default argument
def add_item(item, items=[]):
    items.append(item)
    return items

add_item(1)  # [1]
add_item(2)  # [1, 2] -- NOT [2]! The default list is shared across calls.

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

a = [1, 2, 3]
b = a          # b points to the SAME object as a
c = [1, 2, 3]  # c is a NEW object with the same values

print(a is b)      # True  -- same object (id(a) == id(b))
print(a is c)      # False -- different objects, even though values match
print(a == c)      # True  -- values are equal
print(a is not c)  # True  -- confirms they're different objects

# CORRECT: Always use 'is' for None checks
if value is None:
    handle_missing()

# WRONG: Don't use == for None
if value == None:  # This calls value.__eq__(None), which could be overridden!
    handle_missing()

a = 256
b = 256
print(a is b)  # True -- CPython caches integers -5 to 256

a = 257
b = 257
print(a is b)  # False in the REPL! (True in a .py file due to peephole optimization)

x = [1, 2]
y = [1, 2]
z = x

print(x == y)  # True  -- same values
print(x is y)  # False -- different objects in memory
print(x is z)  # True  -- z was assigned to the same object as x

class Sneaky:
    def __eq__(self, other):
        return True  # Claims to be equal to everything!

s = Sneaky()
print(s == None)   # True (!)  -- __eq__ was overridden
print(s == 42)     # True (!)
print(s is None)   # False     -- identity can't be faked

# String containment (substring search)
'app' in 'apple'          # True -- O(n*m) substring search

# List/Tuple (linear scan)
5 in [1, 2, 3, 4, 5]      # True -- O(n), must check each element

# Set (hash lookup)
5 in {1, 2, 3, 4, 5}      # True -- O(1) average case

# Dict (checks keys, not values!)
'key' in {'key': 'val'}   # True -- O(1) hash lookup on keys
'val' in {'key': 'val'}   # False! Checks keys only.

# To check dict values:
'val' in {'key': 'val'}.values()  # True -- but O(n)!

# Slow: O(n) per check, O(n*m) total
blocklist = ['spam@x.com', 'junk@y.com', ...]  # 100K items
for email in incoming_emails:  # 50K emails
    if email in blocklist:     # O(100K) each time
        block(email)

# Fast: O(1) per check after O(n) set construction
blocklist_set = set(blocklist)  # One-time O(n) cost
for email in incoming_emails:
    if email in blocklist_set:  # O(1) each time
        block(email)

class NumberRange:
    def __init__(self, start, end):
        self.start, self.end = start, end
    def __contains__(self, item):
        return self.start <= item <= self.end

print(5 in NumberRange(1, 10))  # True

from collections import deque
d = deque([1, 2, 3])
d.appendleft(0)  # O(1) -- not O(n) like list.insert(0, x)

# Basic
squares = [x**2 for x in range(10)]

# With filter
evens = [x for x in range(20) if x % 2 == 0]

# Nested (flattening a matrix)
matrix = [[1,2], [3,4], [5,6]]
flat = [num for row in matrix for num in row]  # [1,2,3,4,5,6]

# With conditional expression (ternary)
labels = ['even' if x % 2 == 0 else 'odd' for x in range(5)]

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

# Set comprehension
unique_lengths = {len(word) for word in ['hi', 'hey', 'hello']}

# List comprehension: builds entire list in memory
total = sum([x**2 for x in range(10_000_000)])  # ~80MB list

# Generator expression: produces values lazily, constant memory
total = sum(x**2 for x in range(10_000_000))    # ~zero extra memory

d = {'name': 'Alice', 'age': 30}

# get() vs direct access
d['missing']            # Raises KeyError!
d.get('missing')        # Returns None (safe)
d.get('missing', 0)     # Returns 0 (custom default)

# setdefault() -- atomic get-or-set (thread-safe with GIL)
d.setdefault('role', 'engineer')  # Sets AND returns

# update() -- merge another dict (last value wins on conflicts)
d.update({'age': 31, 'city': 'NYC'})

# Merge operators (Python 3.9+)
merged = d | {'new_key': 'val'}   # Creates new dict
d |= {'new_key': 'val'}          # Updates in-place

# Dictionary unpacking
combined = {**defaults, **overrides}  # overrides win on conflicts

# items(), keys(), values() return VIEW objects (not lists!)
for key, value in d.items():  # View reflects live changes to dict
    print(key, value)

from collections import defaultdict

# Instead of checking if key exists before appending:
groups = defaultdict(list)
for item in data:
    groups[item.category].append(item)  # No KeyError, auto-creates []

# Counting pattern:
counts = defaultdict(int)
for word in words:
    counts[word] += 1  # No KeyError, auto-creates 0

from collections import Counter
c = Counter(['a', 'b', 'a', 'c', 'a'])
c.most_common(2)  # [('a', 3), ('b', 1)]

# You need a set of sets (e.g., tracking unique combinations)
# This fails:
set_of_sets = {  {1,2}, {3,4}  }  # TypeError: unhashable type 'set'

# This works:
set_of_frozensets = { frozenset({1,2}), frozenset({3,4}) }

# Dict key example: caching results for a combination of features
cache = {}
features = frozenset(['age', 'income', 'location'])
cache[features] = model.predict(features)

# Deduplicate while preserving order (Python 3.7+)
seen = set()
unique = []
for item in items:
    if item not in seen:
        seen.add(item)
        unique.append(item)

# Or use dict.fromkeys() trick:
unique = list(dict.fromkeys(items))

user_permissions = {'read', 'write', 'delete'}
required_permissions = {'read', 'write'}

# Check if user has all required permissions
if required_permissions.issubset(user_permissions):
    allow_action()

# What extra permissions does user have?
extra = user_permissions - required_permissions  # {'delete'}

yesterday_ids = set(fetch_ids('2024-01-01'))
today_ids = set(fetch_ids('2024-01-02'))

new_records = today_ids - yesterday_ids        # Added
deleted_records = yesterday_ids - today_ids    # Removed
unchanged = yesterday_ids & today_ids          # Still present
all_affected = yesterday_ids ^ today_ids       # Changed in either direction

text = 'Hello, World!'

# Basic indexing
text[0]       # 'H' -- zero-indexed
text[-1]      # '!' -- negative indexes count from the end

# Slicing: [start:stop) -- stop is EXCLUSIVE
text[0:5]     # 'Hello'
text[7:]      # 'World!' -- from index 7 to the end
text[:5]      # 'Hello' -- from start to index 5 (exclusive)

# Step
text[::2]     # 'Hlo ol!' -- every 2nd character
text[::-1]    # '!dlroW ,olleH' -- reverse

# Slice assignment (lists only, not strings/tuples)
nums = [0, 1, 2, 3, 4]
nums[1:3] = [10, 20, 30]  # [0, 10, 20, 30, 3, 4] -- replacement can differ in length!

# Instead of magic numbers:
NAME = slice(0, 20)
AGE = slice(20, 24)
record = 'John Smith          0030'
print(record[NAME].strip())  # 'John Smith'
print(record[AGE])            # '0030'

students = [
    {'name': 'John', 'age': 25, 'gpa': 3.5},
    {'name': 'Jane', 'age': 22, 'gpa': 3.9},
    {'name': 'Bob', 'age': 22, 'gpa': 3.7},
]

# Sort by single key
by_age = sorted(students, key=lambda x: x['age'])

# Sort by multiple keys (age ascending, then gpa descending)
by_age_gpa = sorted(students, key=lambda x: (x['age'], -x['gpa']))

# Using operator.itemgetter (faster than lambda for large lists)
from operator import itemgetter
by_age = sorted(students, key=itemgetter('age'))
by_age_name = sorted(students, key=itemgetter('age', 'name'))

# Reverse sort
by_age_desc = sorted(students, key=itemgetter('age'), reverse=True)

# Sort by GPA, then by age (stable sort trick)
result = sorted(students, key=itemgetter('gpa'))  # First: GPA
result = sorted(result, key=itemgetter('age'))     # Then: age (preserves GPA order within same age)

import copy

original = [[1, 2], [3, 4], {'key': 'value'}]

shallow = copy.copy(original)
deep = copy.deepcopy(original)

# Modify a nested object
original[0].append(999)

print(shallow[0])  # [1, 2, 999] -- AFFECTED! Shares the nested list
print(deep[0])     # [1, 2]      -- NOT affected, independent copy

# All of these are SHALLOW copies:
b = a[:]              # Slice copy
b = list(a)           # Constructor copy
b = a.copy()          # Method copy
b = copy.copy(a)      # Explicit shallow copy

# For dicts:
d2 = d.copy()
d2 = {**d}            # Unpacking (shallow)
d2 = dict(d)          # Constructor

# A config object shared across request handlers
default_config = {'retries': 3, 'headers': {'auth': 'token123'}}

# BUG: shallow copy means 'headers' dict is shared
handler_config = default_config.copy()
handler_config['headers']['custom'] = 'value'
# default_config['headers'] now also has 'custom'!

# FIX: deep copy
handler_config = copy.deepcopy(default_config)

class Person:
    species = 'Homo sapiens'  # Class attribute (shared by all instances)

    def __init__(self, name, age):
        self.name = name  # Instance attribute (unique per instance)
        self.age = age
        self._id = id(self)  # Convention: "private" attribute

    def greet(self):
        return f"Hi, I'm {self.name}, age {self.age}"

    def __repr__(self):  # For debugging
        return f"Person(name='{self.name}', age={self.age})"

    def __str__(self):  # For user-facing output
        return self.greet()

p1 = Person("Adam", 30)
p2 = Person("Eve", 28)

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int
    species: str = 'Homo sapiens'  # Default value

    def greet(self):
        return f"Hi, I'm {self.name}"

# Auto-generates __init__, __repr__, __eq__, and more
p = Person("Adam", 30)
print(p)  # Person(name='Adam', age=30, species='Homo sapiens')

class Pizza:
    base_price = 10  # Class attribute

    def __init__(self, toppings):
        self.toppings = toppings  # Instance attribute

    # Instance method: needs self to access toppings
    def price(self):
        return self.base_price + len(self.toppings) * 2

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

    # Static method: utility, no access to instance or class
    @staticmethod
    def is_valid_topping(topping):
        return topping.lower() in ['mozzarella', 'pepperoni', 'mushroom', 'basil', 'tomato']

# Usage
p = Pizza.margherita()      # Class method as factory
print(p.price())            # Instance method
Pizza.is_valid_topping('x') # Static method (no instance needed)

class FancyPizza(Pizza):
    base_price = 15

# Because margherita uses cls (not Pizza), it creates a FancyPizza!
fp = FancyPizza.margherita()  # Returns FancyPizza, not Pizza
print(type(fp))  # <class 'FancyPizza'>

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

    def speak(self):
        return "..."

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # Calls Animal.__init__
        self.breed = breed

    def speak(self):
        return "Woof!"

class ServiceDog(Dog):
    def __init__(self, name, breed, task):
        super().__init__(name, breed)  # Calls Dog.__init__
        self.task = task

class A:
    def method(self): return 'A'

class B(A):
    def method(self): return 'B'

class C(A):
    def method(self): return 'C'

class D(B, C):
    pass

d = D()
print(d.method())  # 'B' -- follows MRO
print(D.__mro__)   # (D, B, C, A, object) -- C3 linearization

class Base:
    def __init__(self):
        print('Base')

class Left(Base):
    def __init__(self):
        print('Left')
        super().__init__()  # Calls Right.__init__, NOT Base.__init__!

class Right(Base):
    def __init__(self):
        print('Right')
        super().__init__()

class Child(Left, Right):
    def __init__(self):
        super().__init__()

Child()  # Prints: Left, Right, Base (each called exactly once!)

# Instead of deep inheritance:
class Engine:
    def start(self): ...

class Car:
    def __init__(self):
        self.engine = Engine()  # Composition: Car HAS-A Engine

    def start(self):
        self.engine.start()

class Money:
    def __init__(self, amount, currency='USD'):
        self.amount = amount
        self.currency = currency

    def __repr__(self):
        return f"Money({self.amount}, '{self.currency}')"

    def __str__(self):
        return f"${self.amount:.2f} {self.currency}"

    def __add__(self, other):
        if self.currency != other.currency:
            raise ValueError("Cannot add different currencies")
        return Money(self.amount + other.amount, self.currency)

    def __eq__(self, other):
        return self.amount == other.amount and self.currency == other.currency

    def __hash__(self):
        return hash((self.amount, self.currency))

m = Money(10.50)
print(repr(m))  # Money(10.5, 'USD')
print(str(m))   # $10.50 USD

class User:
    def __init__(self, first_name, last_name, birth_year):
        self._first_name = first_name
        self._last_name = last_name
        self._birth_year = birth_year

    @property
    def full_name(self):
        """Computed property -- no stored state."""
        return f"{self._first_name} {self._last_name}"

    @property
    def age(self):
        """Computed from birth_year -- always current."""
        from datetime import date
        return date.today().year - self._birth_year

    @property
    def first_name(self):
        return self._first_name

    @first_name.setter
    def first_name(self, value):
        if not value or not value.strip():
            raise ValueError("Name cannot be empty")
        self._first_name = value.strip()

    @first_name.deleter
    def first_name(self):
        raise AttributeError("Cannot delete name")

u = User("John", "Doe", 1990)
print(u.full_name)    # "John Doe" -- accessed like attribute, computed like method
print(u.age)          # 36 (in 2026)
u.first_name = "Jane" # Calls setter with validation

from functools import cached_property

class DataSet:
    @cached_property
    def processed_data(self):
        """Expensive computation, run only once."""
        return heavy_processing(self.raw_data)

def flexible(required, *args, **kwargs):
    print(f"Required: {required}")
    print(f"Extra positional (tuple): {args}")
    print(f"Extra keyword (dict): {kwargs}")

flexible('hello', 1, 2, 3, debug=True, mode='fast')
# Required: hello
# Extra positional (tuple): (1, 2, 3)
# Extra keyword (dict): `{'debug': True, 'mode': 'fast'}`

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

args = [1, 2, 3]
add(*args)  # Unpacks list into positional args: add(1, 2, 3)

kwargs = {'a': 1, 'b': 2, 'c': 3}
add(**kwargs)  # Unpacks dict into keyword args: add(a=1, b=2, c=3)

def example(pos, *args, keyword_only, **kwargs):
    pass  # keyword_only MUST be passed by name

def connect(host, port, *, timeout=30, retries=3):
    # timeout and retries MUST be keyword arguments
    pass

connect('localhost', 8080, timeout=60)   # OK
connect('localhost', 8080, 60)           # TypeError!

def logging_decorator(func):
    def wrapper(*args, **kwargs):  # Accept anything
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)  # Forward everything
    return wrapper

# Lambda syntax: lambda parameters: expression
square = lambda x: x * x
add = lambda x, y: x + y

# Most common use: as key functions
sorted(names, key=lambda name: name.lower())
sorted(students, key=lambda s: (s['grade'], -s['age']))

# With filter and map (though comprehensions are preferred)
evens = list(filter(lambda x: x % 2 == 0, range(20)))
squared = list(map(lambda x: x**2, range(10)))

# BUG: All lambdas capture the same variable 'i'
funcs = [lambda: i for i in range(5)]
print([f() for f in funcs])  # [4, 4, 4, 4, 4] -- NOT [0, 1, 2, 3, 4]!

# FIX: Use default argument to capture current value
funcs = [lambda i=i: i for i in range(5)]
print([f() for f in funcs])  # [0, 1, 2, 3, 4]

import functools
import time

def timing_decorator(func):
    @functools.wraps(func)  # CRITICAL: preserves __name__, __doc__, etc.
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

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

def retry(max_attempts=3, backoff=1.0):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts - 1:
                        raise
                    time.sleep(backoff * (2 ** attempt))
        return wrapper
    return decorator

@retry(max_attempts=5, backoff=0.5)
def call_api():
    ...

class CountCalls:
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        return self.func(*args, **kwargs)

@CountCalls
def my_func():
    pass

my_func()
print(my_func.count)  # 1

@decorator_a
@decorator_b
def func(): ...
# Equivalent to: func = decorator_a(decorator_b(func))
# decorator_b is applied FIRST (bottom-up)

def make_multiplier(factor):
    def multiply(x):
        return x * factor  # 'factor' is captured from the enclosing scope
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))   # 10
print(triple(5))   # 15
print(double.__closure__[0].cell_contents)  # 2 (the captured value)

def make_counter():
    count = 0
    def increment():
        nonlocal count  # Without this, 'count += 1' would create a LOCAL variable
        count += 1
        return count
    return increment

counter = make_counter()
print(counter())  # 1
print(counter())  # 2
print(counter())  # 3

# Closure approach (lighter, simpler)
def make_account(balance):
    def deposit(amount):
        nonlocal balance
        balance += amount
        return balance
    return deposit

# Class approach (heavier, more features)
class Account:
    def __init__(self, balance):
        self.balance = balance
    def deposit(self, amount):
        self.balance += amount
        return self.balance

def fibonacci():
    a, b = 0, 1
    while True:  # Infinite sequence -- no problem with generators!
        yield a
        a, b = b, a + b

# Only computes values as requested
fib = fibonacci()
print(next(fib))  # 0
print(next(fib))  # 1
print(next(fib))  # 1
print(next(fib))  # 2

# List: ALL 10 million items in memory at once (~80MB for ints)
data = [x**2 for x in range(10_000_000)]

# Generator: ONE item in memory at a time (~0 extra memory)
data = (x**2 for x in range(10_000_000))

def read_large_file(path):
    with open(path) as f:
        for line in f:  # File objects are already iterators!
            yield line.strip()

# Process 50GB file with constant memory usage
for line in read_large_file('huge.log'):
    if 'ERROR' in line:
        handle_error(line)

def flatten(nested):
    for item in nested:
        if isinstance(item, list):
            yield from flatten(item)  # Delegate to recursive call
        else:
            yield item

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

def accumulator():
    total = 0
    while True:
        value = yield total  # Receive value from send()
        total += value

acc = accumulator()
next(acc)        # Prime the generator (advance to first yield)
acc.send(10)     # Returns 10
acc.send(20)     # Returns 30
acc.send(5)      # Returns 35

# Reading -- choose the right method:
with open('file.txt', 'r', encoding='utf-8') as f:
    content = f.read()       # Read entire file into one string (careful with large files!)
    lines = f.readlines()    # Read all lines into a list (also loads everything into memory)

# Line-by-line reading (memory efficient for large files):
with open('large.log', 'r', encoding='utf-8') as f:
    for line in f:           # File object is an iterator -- constant memory
        process(line)

# Writing ('w' truncates, 'a' appends, 'x' exclusive create):
with open('output.txt', 'w', encoding='utf-8') as f:
    f.write("Hello\n")
    f.writelines(['line1\n', 'line2\n'])  # Does NOT add newlines automatically!

from pathlib import Path

path = Path('data') / 'output.txt'  # OS-independent path joining
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text("Hello", encoding='utf-8')
content = path.read_text(encoding='utf-8')

with open('log.txt', 'a') as f:
    f.write("event happened\n")
    f.flush()  # Force write to disk NOW (important for logging)

import json

# Python dict to JSON string
data = {"id": 1, "name": "Alice", "active": True, "score": None}
json_string = json.dumps(data, indent=2)  # Pretty-printed

# JSON string to Python dict
parsed = json.loads(json_string)

# File I/O (use dump/load, not dumps/loads)
with open('data.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, indent=2, ensure_ascii=False)  # ensure_ascii=False for Unicode

with open('data.json', 'r', encoding='utf-8') as f:
    loaded = json.load(f)

from datetime import datetime
from decimal import Decimal

class CustomEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        if isinstance(obj, Decimal):
            return str(obj)  # Preserve precision
        if isinstance(obj, set):
            return list(obj)
        return super().default(obj)

json.dumps({"ts": datetime.now(), "price": Decimal("19.99")}, cls=CustomEncoder)

# Basic try-except
try:
    result = 10 / 0
except ZeroDivisionError:
    result = 0
    print("Cannot divide by zero")

# Catching multiple exceptions
try:
    data = json.loads(user_input)
except (json.JSONDecodeError, TypeError) as e:
    print(f"Invalid input: {e}")

# Catching the exception object for logging
try:
    connect_to_db()
except ConnectionError as e:
    logger.error(f"DB connection failed: {e}", exc_info=True)
    raise  # Re-raise after logging! Don't silently swallow.

# TERRIBLE: catches Ctrl+C, SystemExit, MemoryError
try:
    do_something()
except:  # Never do this!
    pass

# BAD BUT LESS BAD: catches too broadly
except Exception:
    pass

# GOOD: catch specific exceptions
except (ValueError, TypeError) as e:
    handle_specific_error(e)

except SomeError as e:
    logger.error(f"Failed: {e}")
    raise  # Preserves the original traceback

try:
    data = parse_config(raw)
except ValueError as e:
    raise ConfigError("Bad config format") from e  # Chains the original cause

try:
    result = dangerous_operation()   # May raise
except SpecificError as e:
    handle_error(e)                  # Runs ONLY if exception occurred
else:
    use_result(result)               # Runs ONLY if NO exception occurred
finally:
    cleanup()                        # ALWAYS runs, no matter what

# WITHOUT else -- imprecise error handling
try:
    data = fetch_from_api()       # We want to catch errors here
    processed = process(data)     # But NOT catch errors here!
except ConnectionError:
    handle_network_error()        # Would catch process() errors too!

# WITH else -- precise error handling
try:
    data = fetch_from_api()       # Only this is protected
except ConnectionError:
    handle_network_error()
else:
    processed = process(data)     # If this raises, it propagates normally

# GOTCHA: finally can override return values!
def tricky():
    try:
        return 1
    finally:
        return 2  # This wins! Returns 2, not 1.

print(tricky())  # 2 -- the finally return overrides the try return

connection = get_db_connection()
try:
    connection.begin()
    execute_queries(connection)
except DatabaseError:
    connection.rollback()  # Undo on failure
    raise
else:
    connection.commit()    # Commit only on success
finally:
    connection.close()     # Always close the connection

# When you write:
for item in [1, 2, 3]:
    print(item)

# Python actually does:
iterator = iter([1, 2, 3])  # Calls list.__iter__() -> returns list_iterator
while True:
    try:
        item = next(iterator)  # Calls iterator.__next__()
        print(item)
    except StopIteration:
        break

my_list = [1, 2, 3]  # Iterable
for x in my_list: pass  # Works
for x in my_list: pass  # Works again! Fresh iterator each time.

my_iter = iter(my_list)  # Iterator
list(my_iter)  # [1, 2, 3]
list(my_iter)  # [] -- exhausted!

class Countdown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self  # Iterator returns itself

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current + 1

for num in Countdown(5):
    print(num)  # 5, 4, 3, 2, 1

def countdown(start):
    while start > 0:
        yield start
        start -= 1

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

# I/O-bound: Thread pool (e.g., downloading 100 URLs)
with ThreadPoolExecutor(max_workers=20) as pool:
    results = pool.map(download_url, urls)

# CPU-bound: Process pool (e.g., resizing 1000 images)
with ProcessPoolExecutor(max_workers=8) as pool:
    results = pool.map(resize_image, images)

import asyncio
import aiohttp

async def fetch_all(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [session.get(url) for url in urls]
        return await asyncio.gather(*tasks)

# This is still a race condition despite the GIL:
counter = 0

def increment():
    global counter
    for _ in range(1_000_000):
        counter += 1  # NOT atomic! Read-modify-write can be interrupted between bytecodes

# Two threads doing this can produce counter < 2_000_000