Python Advanced

Prescriptive Rules

Generator Expressions Over List Comprehensions

# BAD: Creates entire list in memory
total = sum([x * x for x in range(1000000)])

# GOOD: Generator expression, processes one at a time
total = sum(x * x for x in range(1000000))

# BAD: Multiple passes over data
data = [process(x) for x in items]
filtered = [x for x in data if condition(x)]

# GOOD: Single pass with generator pipeline
processed = (process(x) for x in items)
filtered = (x for x in processed if condition(x))

Context Managers for Resource Safety

from contextlib import contextmanager, ExitStack

# Simple context manager
@contextmanager
def managed_resource(name):
    print(f"Acquiring {name}")
    resource = acquire(name)
    try:
        yield resource
    finally:
        print(f"Releasing {name}")
        resource.release()

# Multiple resources with ExitStack
with ExitStack() as stack:
    files = [stack.enter_context(open(f)) for f in filenames]
    # All files automatically closed on exit

Coroutines for Async Patterns

# Modern async/await (built on coroutines)
import asyncio

async def fetch_data(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.json()

async def fetch_all(urls):
    tasks = [fetch_data(url) for url in urls]
    return await asyncio.gather(*tasks)

# Run async code
results = asyncio.run(fetch_all(urls))

Metaprogramming with Purpose

# Descriptors for managed attributes
class TypedProperty:
    def __init__(self, name, expected_type):
        self.name = name
        self.expected_type = expected_type

    def __get__(self, obj, cls):
        if obj is None:
            return self
        return obj.__dict__.get(self.name)

    def __set__(self, obj, value):
        if not isinstance(value, self.expected_type):
            raise TypeError(f"Expected {self.expected_type}")
        obj.__dict__[self.name] = value

# Class decorator for auto-generating
def auto_repr(cls):
    def __repr__(self):
        attrs = ', '.join(f'{k}={v!r}' for k, v in self.__dict__.items())
        return f'{cls.__name__}({attrs})'
    cls.__repr__ = __repr__
    return cls

Closures and Function Factories

# Closure captures state
def make_counter(start=0):
    count = start
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

# Function factory
def make_validator(min_val, max_val):
    def validate(value):
        if not (min_val <= value <= max_val):
            raise ValueError(f"Must be between {min_val} and {max_val}")
        return value
    return validate

age_validator = make_validator(0, 150)

Advanced Patterns

yield from for Delegation

# Flatten nested structures
def flatten(items):
    for item in items:
        if isinstance(item, (list, tuple)):
            yield from flatten(item)
        else:
            yield item

# Coroutine delegation
def grouper(results, key):
    while True:
        results[key] = yield from accumulator()

slots for Memory Efficiency

# Default: each instance has a dict
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
# Each instance: ~300+ bytes

# With slots: fixed attributes, no dict
class Point:
    __slots__ = ['x', 'y']
    def __init__(self, x, y):
        self.x = x
        self.y = y
# Each instance: ~50 bytes

weakref for Cache Management

import weakref

class ExpensiveObject:
    _cache = weakref.WeakValueDictionary()

    def __new__(cls, key):
        if key in cls._cache:
            return cls._cache[key]
        obj = super().__new__(cls)
        cls._cache[key] = obj
        return obj

Anti-Patterns

Review Checklist

• Are large collections lazily evaluated?
• Are resources managed with context managers?
• Is async code using modern async/await?
• Could repetitive patterns use metaprogramming?
• Are closures used instead of global state?
• Is memory-critical code using slots?

Key Insight

"Python's power comes from understanding its execution model. Generators aren't just syntax—they're the foundation of Python's approach to iteration, coroutines, and async programming."