Python Expert

Python Expert

Write code that reads like the problem. Lean on the stdlib, type the boundaries, handle specific exceptions, and measure before optimizing. There's usually one obvious, Pythonic way — find it.

When to Use

• Writing, refactoring, or reviewing Python.
• Best practices: PEP 8, typing, packaging, project layout.
• Debugging exceptions/tracebacks or unexpected behavior.
• Performance/profiling, async, or data-stack (numpy/pandas) work.

When NOT to Use

• Another language → relevant language skill.
• Contest algorithms (language incidental) → competitive-programming-expert.
• System/architecture design → software-architect.
• DL modeling/training → deep-learning-expert.

Core Principles

1. Pythonic & typed

• PEP 8 via autoformatter (ruff format/black) + linter (ruff). Comprehensions, generators, enumerate/zip, pathlib, f-strings.
• Type public functions; run mypy/pyright strict for libraries. Use dataclasses/pydantic for structured data; enum/Literal for fixed sets.

2. Correct & robust

• Catch specific exceptions; never bare except:. Re-raise with context (raise X from e). EAFP (try/except) over LBYL where it reads cleaner.
• Manage resources with context managers (with); don't hand-close files/locks. Prefer pure functions and immutability where practical.

3. Use the stdlib first

• collections (Counter, defaultdict, deque), itertools, functools (lru_cache, cached_property), contextlib, pathlib, datetime/zoneinfo. Reach for a dependency only when the stdlib falls short.
• Tooling: uv (or Poetry) for envs/deps, pytest for tests, ruff for lint/format.

4. Concurrency & performance

• Measure first (timeit, cProfile, py-spy). Use set/dict for O(1) membership; pick the right container.
• Concurrency model matters because of the GIL: asyncio for high-concurrency I/O, threads for blocking I/O calls, multiprocessing (or vectorized numpy) for CPU-bound work. (Free-threaded 3.13+ is changing this — know your runtime.)

Common Mistakes

• Mutable default arguments (def f(x=[])) → shared across calls; use None + assign inside.
• Bare except: → swallows KeyboardInterrupt/bugs; catch specific types.
• == vs is → is only for None/singletons, not value equality.
• Late-binding closures in loops → capture with a default arg or functools.partial.
• String-concatenating in a loop / building lists you immediately sum → use join/generators.
• from module import * and deep relative imports → explicit imports.
• Threads for CPU-bound work → GIL-bound; use processes or numpy.

Examples

Idiomatic, typed, safe

from __future__ import annotations
from collections import Counter
from collections.abc import Iterable

def top_words(words: Iterable[str], n: int = 3) -> list[tuple[str, int]]:
    """Return the n most common non-empty words, case-insensitively."""
    return Counter(w.casefold() for w in words if w).most_common(n)

Async I/O with bounded concurrency

import asyncio, httpx

async def fetch_all(urls: list[str], limit: int = 10) -> list[str]:
    sem = asyncio.Semaphore(limit)
    async with httpx.AsyncClient(timeout=10) as client:
        async def one(u: str) -> str:
            async with sem:
                r = await client.get(u); r.raise_for_status()
                return r.text
        return await asyncio.gather(*(one(u) for u in urls))

See Also

• competitive-programming-expert — algorithmic Python + fast I/O.
• deep-learning-expert — PyTorch/NumPy on Python fundamentals.
• testing-expert — pytest, fixtures, fakes. performance-expert — profiling.
• rules/python-style-guide.md — enforceable style rules.