Tratamento de Erros em Python

Crie aplicações Python robustas com validação de entrada adequada, exceções significativas e tratamento de falhas elegante. Um bom tratamento de erros facilita a depuração e torna os sistemas mais confiáveis.

Quando Usar Esta Habilidade

• Validar entrada do usuário e parâmetros de API
• Projetar hierarquias de exceção para aplicações
• Lidar com falhas parciais em operações em lote
• Converter dados externos para tipos de domínio
• Criar mensagens de erro amigáveis ao usuário
• Implementar padrões de validação "fail-fast" (falhar rápido)

Conceitos Principais

1. Falhar Rápido (Fail Fast)

Valide as entradas cedo, antes de operações custosas. Relate todos os erros de validação de uma vez, quando possível.

2. Exceções Significativas

Use tipos de exceção apropriados com contexto. As mensagens devem explicar o que falhou, por quê e como corrigir.

3. Falhas Parciais

Em operações em lote, não deixe que uma falha aborte tudo. Rastreie sucessos e falhas separadamente.

4. Preservar Contexto

Encadeie exceções para manter o rastro completo de erros para depuração.

Início Rápido

def fetch_page(url: str, page_size: int) -> Page:
    if not url:
        raise ValueError("'url' is required")
    if not 1 <= page_size <= 100:
        raise ValueError(f"'page_size' must be 1-100, got {page_size}")
    # Now safe to proceed...

Padrões Fundamentais

Padrão 1: Validação Antecipada de Entrada

Valide todas as entradas nos limites da API antes que qualquer processamento comece.

def process_order(
    order_id: str,
    quantity: int,
    discount_percent: float,
) -> OrderResult:
    """Process an order with validation."""
    # Validate required fields
    if not order_id:
        raise ValueError("'order_id' is required")

    # Validate ranges
    if quantity <= 0:
        raise ValueError(f"'quantity' must be positive, got {quantity}")

    if not 0 <= discount_percent <= 100:
        raise ValueError(
            f"'discount_percent' must be 0-100, got {discount_percent}"
        )

    # Validation passed, proceed with processing
    return _process_validated_order(order_id, quantity, discount_percent)

Padrão 2: Converter para Tipos de Domínio Cedo

Analise strings e dados externos em objetos de domínio tipados nos limites do sistema.

from enum import Enum

class OutputFormat(Enum):
    JSON = "json"
    CSV = "csv"
    PARQUET = "parquet"

def parse_output_format(value: str) -> OutputFormat:
    """Parse string to OutputFormat enum.

    Args:
        value: Format string from user input.

    Returns:
        Validated OutputFormat enum member.

    Raises:
        ValueError: If format is not recognized.
    """
    try:
        return OutputFormat(value.lower())
    except ValueError:
        valid_formats = [f.value for f in OutputFormat]
        raise ValueError(
            f"Invalid format '{value}'. "
            f"Valid options: {', '.join(valid_formats)}"
        )

# Usage at API boundary
def export_data(data: list[dict], format_str: str) -> bytes:
    output_format = parse_output_format(format_str)  # Fail fast
    # Rest of function uses typed OutputFormat
    ...

Padrão 3: Pydantic para Validação Complexa

Use modelos Pydantic para validação de entrada estruturada com mensagens de erro automáticas.

from pydantic import BaseModel, Field, field_validator

class CreateUserInput(BaseModel):
    """Input model for user creation."""

    email: str = Field(..., min_length=5, max_length=255)
    name: str = Field(..., min_length=1, max_length=100)
    age: int = Field(ge=0, le=150)

    @field_validator("email")
    @classmethod
    def validate_email_format(cls, v: str) -> str:
        if "@" not in v or "." not in v.split("@")[-1]:
            raise ValueError("Invalid email format")
        return v.lower()

    @field_validator("name")
    @classmethod
    def normalize_name(cls, v: str) -> str:
        return v.strip().title()

# Usage
try:
    user_input = CreateUserInput(
        email="user@example.com",
        name="john doe",
        age=25,
    )
except ValidationError as e:
    # Pydantic provides detailed error information
    print(e.errors())

Padrão 4: Mapear Erros para Exceções Padrão

Use os tipos de exceção integrados do Python apropriadamente, adicionando contexto conforme necessário.

…