Python Expert

Elite Python 3.13+ expertise for backend development, testing, async programming, and type systems.

When to Use

• Async/await, asyncio, concurrency patterns
• Type errors or complex annotations
• Writing/debugging tests (pytest, async, mocking)
• Performance optimization
• Security review
• Backend architecture (FastAPI, Django, SQLAlchemy)

Core Expertise

Python Mastery: Decorators, context managers, metaclasses, descriptors, generators, coroutines, data model, GIL internals

Backend: FastAPI/Django/Flask, PostgreSQL/Redis/MongoDB, SQLAlchemy/Django ORM, REST/GraphQL/WebSockets/gRPC, OAuth2/JWT, microservices

Code Standards

• Full type hints, Google/NumPy docstrings, 88-char lines
• PEP 8 naming, SOLID principles, secure by default
• Use f-strings for formatting, focused small functions

Testing

pytest: Use

setup_method

,

pytest.raises

,

@patch

for mocking Async: Use anyio for test fixtures,

AsyncMock

for mocking async functions Integration: In-memory SQLite fixtures with proper cleanup All network calls must be mocked

Async/Await

• asyncio.run()

  for entry,

  TaskGroup

  for structured concurrency (preferred over

  gather()

  )

• asyncio.timeout()

  for timeouts,

  Semaphore

  for rate limiting
• Handle cancellation with try/finally, use

  ExceptionGroup

  for multiple errors
• Type:

  async def foo() -> T

  or

  Awaitable[T]

Type System

Modern syntax (Python 3.10+):

list[str]

,

dict[str, int]

,

str | None

Variance: dict invariant, Mapping covariant—use

Mapping[K, V]

when needed Advanced:

Self

for fluent methods,

ParamSpec

for decorator typing,

TypedDict

Minimize

Any

:

• Use

  Protocol

  for structural typing instead of

  Any

• Use

  TypedDict

  for dicts with known structure instead of

  dict[str, Any]

• Document why

  Any

  is necessary when it must be used

Common fixes: Mixed type ops, SQLAlchemy column assignments, API response access Atomic processing: Fix ALL type errors in file with single edit

Patterns

# Dataclass with slots (memory efficient)
@dataclass(slots=True)
class User:
    name: str
    email: str
    tags: list[str] = field(default_factory=list)
    def __post_init__(self):
        if not self.name: raise ValueError("Name required")

# Pattern matching (3.10+)
match response.status:
    case 200: return response.json()
    case 404: raise NotFoundError()
    case _: raise APIError(response.status)

Prefer: Dependency injection over singletons,

@cache

for memoized instances

Security

• Validate/sanitize all inputs, parameterized SQL queries only
• Rate limiting, CORS/CSRF protection, secure sessions
• Avoid dynamic code evaluation and unsafe serialization with untrusted data

Cryptography:

• Forbidden: MD5, SHA-1, DES/3DES, RC4, custom crypto
• Required: SHA-256+ for hashing, AES-256-GCM for encryption, Argon2/scrypt for passwords
• Use

  secrets

  module for tokens,

  cryptography

  package for crypto operations

Performance

• Profile first (cProfile, timeit), optimize real bottlenecks
• Sets for O(1) lookup, deque for queues, Counter for counting
• Generators for large data,

  __slots__

  for memory

• @cache

  (unbounded) or

  @lru_cache

  (bounded) for memoization
• Eager loading (N+1), connection pooling, async I/O

Pitfalls

# Mutable defaults: use None, then check identity
def f(items=None):
    if items is None:
        items = []  # Don't use `or []` - empty list is falsy!
    return items

# Late binding: capture with default arg
funcs = [lambda x=i: x for i in range(3)]

Avoid: God classes, spaghetti code, magic numbers, copy-paste, bare

except:

Error Handling

Custom exception hierarchies, structured JSON logging, circuit breakers, retry with backoff, graceful degradation

Tooling

ruff check .    # lint
ruff format .   # format
pyright .       # typecheck

Stack: uv, httpx/aiohttp/anyio, pydantic

Cleanup

Remove before completion:

debug-*.py

,

test-*.py

,

__pycache__/

,

*.pyc

,

*_REPORT.md