Python Pro

Python Pro is an AI skill that provides advanced guidance for modern Python development covering language features, performance optimization, type safety, and ecosystem best practices. It covers Python 3.12+ features, async programming, type hints, packaging, testing strategies, and performance profiling that produce robust, maintainable Python applications.

What Is This?

Overview

Python Pro delivers expert-level Python development practices for building production applications. It addresses modern Python features including pattern matching, exception groups, and the new type parameter syntax, async programming with asyncio for concurrent I/O operations, comprehensive type hinting using generics, protocols, and TypedDict, project packaging with pyproject.toml and modern build backends, testing strategies with pytest covering fixtures, parametrize, and mocking, and performance profiling and optimization for CPU and I/O-bound workloads.

Who Should Use This

This skill serves Python developers building production backend services, data engineers creating robust data pipelines, library authors packaging reusable Python modules, and teams establishing Python coding standards and best practices.

Why Use It?

Problems It Solves

Python's flexibility allows patterns that work but are fragile, untyped, and hard to maintain at scale. Without type hints, large codebases become difficult to refactor safely. Async code written incorrectly creates subtle bugs with event loop blocking. Packaging and dependency management remain confusing due to multiple competing tools and standards.

Core Highlights

The skill leverages Python's type system to catch errors before runtime. Async patterns properly manage concurrency without blocking the event loop. Modern packaging follows the latest PEP standards for reproducible builds. Performance guidance identifies and addresses actual bottlenecks rather than premature optimization.

How to Use It?

Basic Usage

from dataclasses import dataclass, field
from typing import Protocol
from datetime import datetime

class Repository[T](Protocol):
    async def find_by_id(self, id: int) -> T | None: ...
    async def save(self, entity: T) -> T: ...
    async def delete(self, id: int) -> bool: ...

@dataclass
class User:
    id: int
    email: str
    name: str
    created_at: datetime = field(default_factory=datetime.now)

class UserService:
    def __init__(self, repo: Repository[User]) -> None:
        self.repo = repo

    async def get_user(self, user_id: int) -> User:
        user = await self.repo.find_by_id(user_id)
        if user is None:
            raise ValueError(f"User {user_id} not found")
        return user

    async def update_email(self, user_id: int, new_email: str) -> User:
        user = await self.get_user(user_id)
        user.email = new_email
        return await self.repo.save(user)

Real-World Examples

import asyncio
from contextlib import asynccontextmanager
from collections.abc import AsyncIterator

@asynccontextmanager
async def managed_workers(
    tasks: list[asyncio.Task],
) -> AsyncIterator[list[asyncio.Task]]:
    try:
        yield tasks
    finally:
        for task in tasks:
            if not task.done():
                task.cancel()
        await asyncio.gather(*tasks, return_exceptions=True)

async def process_batch(items: list[dict], max_concurrent: int = 10) -> list:
    semaphore = asyncio.Semaphore(max_concurrent)
    results = []

    async def process_one(item: dict) -> dict:
        async with semaphore:
            result = await fetch_and_transform(item)
            return result

    tasks = [asyncio.create_task(process_one(item)) for item in items]
    async with managed_workers(tasks):
        results = await asyncio.gather(*tasks)
    return results

Advanced Tips

Use __slots__ on dataclasses that are instantiated frequently to reduce memory usage. Prefer asyncio.TaskGroup (Python 3.11+) over manual task management for structured concurrency with proper exception propagation. Run mypy in strict mode in CI to enforce type safety across the entire codebase.

When to Use It?

Use Cases

Use Python Pro when building async web services with FastAPI or similar frameworks, when designing type-safe libraries for team or public consumption, when optimizing Python application performance for production workloads, or when establishing coding standards and tooling for a Python development team.

Related Topics

FastAPI and Django frameworks, pytest for testing, mypy and pyright for type checking, uv and poetry for dependency management, and profiling tools like cProfile and py-spy all complement advanced Python development.

Important Notes

Requirements

Python 3.12 or later for the latest language features. A type checker like mypy or pyright configured for the project. A testing framework like pytest with appropriate plugins.

Usage Recommendations

Do: add type hints to all function signatures and use a type checker in CI. Prefer composition over inheritance for flexible, testable designs. Use context managers for resource management to ensure proper cleanup.

Don't: block the event loop with synchronous I/O calls in async code. Use mutable default arguments in function definitions, as they are shared across calls. Catch broad exceptions like except Exception without re-raising or logging, as this silences real errors.

Limitations

Python's GIL limits true parallelism for CPU-bound tasks within a single process. Type hints are not enforced at runtime without additional tools like beartype. Async Python requires all I/O operations in the call chain to be async, creating an all-or-nothing adoption challenge in existing synchronous codebases.