python-pro

What this skill does

# Python Pro

Advanced Python patterns for production code.

## Type Hints (3.12+)

```python
from typing import TypeVar, Protocol, overload
from collections.abc import Callable, Sequence

# Generic function
T = TypeVar('T')
def first(items: Sequence[T]) -> T | None:
    return items[0] if items else None

# Protocol (structural typing)
class Serializable(Protocol):
    def to_dict(self) -> dict: ...

def save(obj: Serializable) -> None:
    data = obj.to_dict()

# Overload for different return types
@overload
def parse(value: str, as_list: Literal[True]) -> list[str]: ...
@overload
def parse(value: str, as_list: Literal[False]) -> str: ...
def parse(value: str, as_list: bool = False):
    return value.split(',') if as_list else value.strip()

# TypedDict
from typing import TypedDict
class UserDict(TypedDict):
    name: str
    email: str
    age: int | None
```

## Async/Await

```python
import asyncio
import aiohttp

async def fetch_all(urls: list[str]) -> list[dict]:
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        return await asyncio.gather(*tasks)

async def fetch(session: aiohttp.ClientSession, url: str) -> dict:
    async with session.get(url) as response:
        return await response.json()

# Semaphore for rate limiting
sem = asyncio.Semaphore(10)
async def rate_limited_fetch(session, url):
    async with sem:
        return await fetch(session, url)

# Run
asyncio.run(fetch_all(["https://api.example.com/1", "https://api.example.com/2"]))
```

## Dataclasses & Pydantic

```python
from dataclasses import dataclass, field
from pydantic import BaseModel, validator

# Dataclass (simple data containers)
@dataclass(frozen=True)  # immutable
class Point:
    x: float
    y: float

# Pydantic (validation + serialization)
class User(BaseModel):
    name: str
    email: str
    age: int

    @validator('email')
    def validate_email(cls, v):
        if '@' not in v:
            raise ValueError('Invalid email')
        return v

user = User(name="Test", email="[email protected]", age=25)
user.model_dump()  # → dict
User.model_validate({"name": "Test", "email": "[email protected]", "age": 25})
```

## Context Managers

```python
from contextlib import contextmanager, asynccontextmanager

@contextmanager
def timer(label: str):
    import time
    start = time.perf_counter()
    yield
    elapsed = time.perf_counter() - start
    print(f"{label}: {elapsed:.3f}s")

with timer("database query"):
    result = db.execute(query)

# Async context manager
@asynccontextmanager
async def db_transaction():
    conn = await db.acquire()
    try:
        yield conn
        await conn.commit()
    except:
        await conn.rollback()
        raise
    finally:
        await conn.release()
```

## Decorators

```python
import functools
import time

def retry(max_attempts=3, delay=1):
    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(delay * (attempt + 1))
        return wrapper
    return decorator

@retry(max_attempts=3, delay=2)
def call_api(url):
    return requests.get(url).json()
```

## Testing

```bash
# pytest with fixtures and parametrize
pytest -xvs tests/

# Coverage
pytest --cov=src --cov-report=term-missing

# Parallel
pytest -n auto

# Specific test
pytest tests/test_user.py::test_create_user -v
```

```python
# Fixture pattern
import pytest

@pytest.fixture
def db():
    conn = create_test_db()
    yield conn
    conn.close()

@pytest.mark.parametrize("input,expected", [
    ("hello", "HELLO"),
    ("world", "WORLD"),
    ("", ""),
])
def test_uppercase(input, expected):
    assert input.upper() == expected
```

## Performance

```bash
# Profile
python3 -m cProfile -s cumulative app.py | head -20

# Line profiler
pip install line_profiler
kernprof -l -v script.py

# Memory profiler
pip install memory_profiler
python3 -m memory_profiler script.py
```

## Notes

- Use `ruff` for linting and formatting — it's 10-100x faster than flake8+black.
- `uv` is the fastest package manager. Use it over pip when possible.
- Type hints are documentation that the compiler checks. Use them everywhere.
- `match` statements (3.10+) are cleaner than if/elif chains for structural matching.
- Prefer `pathlib.Path` over `os.path` for file operations.