Checklist de Anti-Padrões em Python

Um checklist de referência de erros comuns e anti-padrões em código Python. Revise isso antes de finalizar implementações para identificar problemas cedo.

Quando Usar Esta Habilidade

• Revisar código antes de mesclar (merge)
• Depurar problemas misteriosos
• Ensinar ou aprender boas práticas em Python
• Estabelecer padrões de codificação da equipe
• Refatorar código legado

Nota: Esta habilidade foca no que evitar. Para orientação sobre padrões positivos e arquitetura, veja a habilidade python-design-patterns.

Anti-Padrões de Infraestrutura

Lógica de Timeout/Tentativa Espalhada

# BAD: Timeout logic duplicated everywhere
def fetch_user(user_id):
    try:
        return requests.get(url, timeout=30)
    except Timeout:
        logger.warning("Timeout fetching user")
        return None

def fetch_orders(user_id):
    try:
        return requests.get(url, timeout=30)
    except Timeout:
        logger.warning("Timeout fetching orders")
        return None

Correção: Centralize em decoradores (decorators) ou wrappers de cliente.

# GOOD: Centralized retry logic
@retry(stop=stop_after_attempt(3), wait=wait_exponential())
def http_get(url: str) -> Response:
    return requests.get(url, timeout=30)

Tentativa Dupla (Double Retry)

# BAD: Retrying at multiple layers
@retry(max_attempts=3)  # Application retry
def call_service():
    return client.request()  # Client also has retry configured!

Correção: Tente em apenas uma camada. Conheça o comportamento de tentativa da sua infraestrutura.

Configuração Codificada (Hard-Coded)

# BAD: Secrets and config in code
DB_HOST = "prod-db.example.com"
API_KEY = "sk-12345"

def connect():
    return psycopg.connect(f"host={DB_HOST}...")

Correção: Use variáveis de ambiente com configurações tipadas.

# GOOD
from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    db_host: str = Field(alias="DB_HOST")
    api_key: str = Field(alias="API_KEY")

settings = Settings()

Anti-Padrões de Arquitetura

Tipos Internos Expostos

# BAD: Leaking ORM model to API
@app.get("/users/{id}")
def get_user(id: str) -> UserModel:  # SQLAlchemy model
    return db.query(UserModel).get(id)

Correção: Use DTOs (Data Transfer Objects)/modelos de resposta.

# GOOD
@app.get("/users/{id}")
def get_user(id: str) -> UserResponse:
    user = db.query(UserModel).get(id)
    return UserResponse.from_orm(user)

Lógica de I/O e de Negócios Misturada

# BAD: SQL embedded in business logic
def calculate_discount(user_id: str) -> float:
    user = db.query("SELECT * FROM users WHERE id = ?", user_id)
    orders = db.query("SELECT * FROM orders WHERE user_id = ?", user_id)
    # Business logic mixed with data access
    if len(orders) > 10:
        return 0.15
    return 0.0

Correção: Padrão Repository (Repositório). Mantenha a lógica de negócios pura.

# GOOD
def calculate_discount(user: User, orders: list[Order]) -> float:
    # Pure business logic, easily testable
    if len(orders) > 10:
        return 0.15
    return 0.0

Anti-Padrões de Tratamento de Erros

Tratamento de Exceção Genérico (Bare Exception Handling)

# BAD: Swallowing all exceptions
try:
    process()
except Exception:
    pass  # Silent failure - bugs hidden forever

Correção: Capture exceções específicas. Registre (log) ou trate apropriadamente.

# GOOD
try:
    process()
except ConnectionError as e:
    logger.warning("Connection failed, will retry", error=str(e))
    raise
except ValueError as e:
    logger.error("Invalid input", error=str(e))
    raise BadRequestError(str(e))

Falhas Parciais Ignoradas

# BAD: Stops on first error
def process_batch(items):
    results = []
    for item in items:
        result = process(item)  # Raises on error - batch aborted
        results.append(result)
    return results

Correção: Capture tanto sucessos quanto falhas.

# GOOD
def process_batch(items) -> BatchResult:
    succeeded = {}
    failed = {}
    for idx, item in enumerate(items):
        try:
            succeeded[idx] = process(item)
        except Exception as e:
            failed[idx] = e
    return BatchResult(succeeded, failed)

Validação de Entrada Ausente

# BAD: No validation
def create_user(data: dict):
    return User(**data)  # Crashes deep in code on bad input

Correção: Valide cedo nos limites da API.

# GOOD
def create_user(data: dict) -> User:
    validated = CreateUserInput.model_validate(data)
    return User.from_input(validated)

Anti-Padrões de Recursos

…