python

name	python
description	Python programming patterns and best practices
domain	programming-languages
version	1.1.0
tags	["python","typing","async","dataclasses","decorators"]
triggers	{"keywords":{"primary":["python","py","pandas","numpy","pip","venv"],"secondary":["asyncio","typing","dataclass","decorator","pytest"]},"context_boost":["data","analysis","scripting","automation","backend"],"context_penalty":["java","csharp","golang"],"priority":"high"}

Python

Overview

Modern Python development patterns including type hints, async programming, and Pythonic idioms.

---

Type Hints

Basic Types

from typing import (
    Optional, Union, List, Dict, Set, Tuple,
    TypeVar, Generic, Callable, Any,
    Literal, TypedDict, Protocol
)
from dataclasses import dataclass
from datetime import datetime

# Basic type hints
def greet(name: str) -> str:
    return f"Hello, {name}!"

# Optional (can be None)
def find_user(user_id: str) -> Optional['User']:
    return users.get(user_id)

# Union types
def process(value: Union[str, int]) -> str:
    return str(value)

# Python 3.10+ union syntax
def process_new(value: str | int | None) -> str:
    return str(value) if value else ""

# Collections
def process_items(
    items: List[str],
    mapping: Dict[str, int],
    unique: Set[str],
    pair: Tuple[str, int]
) -> None:
    pass

# Python 3.9+ built-in generics
def process_items_new(
    items: list[str],
    mapping: dict[str, int],
    unique: set[str]
) -> None:
    pass

Advanced Types

# TypeVar for generics
T = TypeVar('T')
K = TypeVar('K')
V = TypeVar('V')

def first(items: list[T]) -> T | None:
    return items[0] if items else None

# Generic classes
class Repository(Generic[T]):
    def __init__(self) -> None:
        self._items: dict[str, T] = {}

    def get(self, id: str) -> T | None:
        return self._items.get(id)

    def save(self, id: str, item: T) -> None:
        self._items[id] = item

# TypedDict for structured dicts
class UserDict(TypedDict):
    id: str
    name: str
    email: str
    age: int  # Required
    nickname: str  

 (TypedDict, total=):
    nickname:   


Mode = [, , ]

 () -> :
    


 ():
     () -> : ...

 () -> :
     source.read()


Handler = [[, ], ]
AsyncHandler = [[], ]

 () -> :
    

---

Dataclasses

from dataclasses import dataclass, field, asdict, astuple
from typing import ClassVar
from datetime import datetime

@dataclass
class User:
    id: str
    email: str
    name: str
    created_at: datetime = field(default_factory=datetime.now)
    tags: list[str] = field(default_factory=list)
    _cache: dict = field(default_factory=dict, repr=False, compare=False)

    # Class variable (not instance field)
    MAX_TAGS: ClassVar[int] = 10

    def __post_init__(self):
        # Validation after init
        if len(self.tags) > self.MAX_TAGS:
            raise ValueError(f"Too many tags (max {self.MAX_TAGS})")

# Frozen (immutable)
@dataclass(frozen=True)
class Point:
    x: float
    y: float

    def distance_from_origin(self) -> float:
        return (self.x **  + .y ** ) ** 



 :
    : 
    name: 


user = User(=, email=, name=)
user_dict = asdict(user)
user_tuple = astuple(user)

---

Decorators

from functools import wraps
from typing import TypeVar, Callable, ParamSpec
import time

P = ParamSpec('P')
R = TypeVar('R')

# Basic decorator
def timer(func: Callable[P, R]) -> Callable[P, R]:
    @wraps(func)
    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

# Decorator with arguments
def retry(max_attempts: int = 3, delay: float = 1.0):
    def decorator(func: Callable[P, R]) -> Callable[P, R]:
        @wraps(func)
        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
            last_exception: Exception | None = None
            for attempt in range(max_attempts):
                :
                     func(*args, **kwargs)
                 Exception  e:
                    last_exception = e
                     attempt < max_attempts - :
                        time.sleep(delay)
             last_exception
         wrapper
     decorator


 ():
    instances = {}

     ():
         cls   instances:
            instances[cls] = cls(*args, **kwargs)
         instances[cls]
     get_instance




 () -> :
    
    


 :
     ():
        .connection_string = connection_string

---

Async Programming

import asyncio
from typing import AsyncIterator
import aiohttp

# Async function
async def fetch_url(url: str) -> str:
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

# Parallel execution
async def fetch_all(urls: list[str]) -> list[str]:
    tasks = [fetch_url(url) for url in urls]
    return await asyncio.gather(*tasks)

# With error handling
async def fetch_all_safe(urls: list[str]) -> list[str | None]:
    tasks = [fetch_url(url) for url in urls]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    return [r if isinstance(r, str) else None  r  results]


 :
      () -> :
         .connect()
         

      () -> :
         .disconnect()

      () -> :
        ()

      () -> :
        ()


  () -> AsyncIterator[T]:
    page = 
     :
        items =  fetch_page(page)
          items:
            
         item  items:
             item
        page += 


  ():
      item  paginate(fetch_page):
         process_item(item)


  ():
    semaphore = asyncio.Semaphore(max_concurrent)

      () -> :
          semaphore:
              fetch_url(url)

      asyncio.gather(*[fetch_limited(url)  url  urls])

---

Context Managers

from contextlib import contextmanager, asynccontextmanager
from typing import Generator, AsyncGenerator

# Class-based context manager
class Timer:
    def __init__(self, name: str):
        self.name = name
        self.start: float = 0
        self.elapsed: float = 0

    def __enter__(self) -> 'Timer':
        self.start = time.perf_counter()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
        self.elapsed = time.perf_counter() - self.start
        print(f"{self.name}: {self.elapsed:.4f}s")

# Generator-based context manager
@contextmanager
def timer(name: str) -> Generator[None, None, None]:
    start = time.perf_counter()
    try:
        yield
    finally:
        elapsed = time.perf_counter() - start
        ()



  () -> AsyncGenerator[, ]:
    start = time.perf_counter()
    :
        
    :
        elapsed = time.perf_counter() - start
        ()


 timer():
    do_something()

  async_timer():
     do_something_async()

---

Itertools and Generators

from itertools import (
    chain, islice, groupby, takewhile, dropwhile,
    combinations, permutations, product, accumulate
)
from typing import Iterator, Iterable

# Generator function
def fibonacci() -> Iterator[int]:
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# Take first n
first_10_fib = list(islice(fibonacci(), 10))

# Generator expression
squares = (x ** 2 for x in range(10))

# Chain multiple iterables
all_items = chain(list1, list2, list3)

# Group by
data = [
    {"type": "a", "value": 1},
    {"type": "a", "value": 2},
    {"type": "b", "value": 3},
]
for key, group in groupby(sorted(data, key=lambda x: x["type"]), key=lambda x: x["type"]):
    print(f"{key}: {list(group)}")

# Batching
def batch() -> Iterator[[T]]:
    iterator = (iterable)
     batch := (islice(iterator, size)):
         batch


 () -> Iterator[[T, ...]]:
     collections  deque
    iterator = (iterable)
    window = deque(islice(iterator, size), maxlen=size)
     (window) == size:
         (window)
     item  iterator:
        window.append(item)
         (window)

---

Error Handling

from typing import TypeVar, Generic
from dataclasses import dataclass

T = TypeVar('T')
E = TypeVar('E', bound=Exception)

# Custom exceptions
class AppError(Exception):
    def __init__(self, message: str, code: str):
        super().__init__(message)
        self.code = code

class ValidationError(AppError):
    def __init__(self, message: str, fields: dict[str, list[str]]):
        super().__init__(message, "VALIDATION_ERROR")
        self.fields = fields

# Result type pattern
@dataclass
class Ok(Generic[T]):
    value: T

    def is_ok(self) -> bool:
        return True

    def is_err(self) -> bool:
        return False

@dataclass
class ([E]):
    error: E

     () -> :
         

     () -> :
         

Result = Ok[T] | Err[E]

 () -> Result[, ValueError]:
    :
         Ok((s))
     ValueError  e:
         Err(e)


:
    process_data()
 ValueError  e:
     AppError(, )  e

---

Related Skills

• [[ai-ml-integration]] - ML/AI with Python
• [[backend]] - FastAPI/Django
• [[automation-scripts]] - Scripting and automation