Callable, Any e apelidos de tipo

Callable: quando a função é o argumento

Funções são objetos em Python, então uma função pode receber outra função como argumento. Para anotar isso existe o Callable, importado do typing. A sintaxe tem duas partes: uma lista com os tipos dos parâmetros e, depois, o tipo de retorno. Callable[[int, int], int] descreve uma função que recebe dois inteiros e devolve um inteiro. Isso é comum em código que recebe uma função de comparação, um callback ou uma operação para aplicar.

from typing import Callable

def aplicar(operacao: Callable[[int, int], int], a: int, b: int) -> int:
    return operacao(a, b)

def somar(x: int, y: int) -> int:
    return x + y

def multiplicar(x: int, y: int) -> int:
    return x * y

print(aplicar(somar, 3, 4))       # 7
print(aplicar(multiplicar, 3, 4))  # 12

aplicar recebe uma função Callable[[int, int], int] e a usa com dois inteiros.

No exemplo, aplicar aceita qualquer função que se encaixe no contrato: dois inteiros entram, um inteiro sai. Tanto somar quanto multiplicar servem. Se você tentasse passar uma função com assinatura diferente, o mypy avisaria. Quando os parâmetros não importam para a anotação, você pode usar reticências no lugar da lista: Callable[..., int] aceita qualquer assinatura desde que o retorno seja inteiro.

Any: o tipo que desliga a verificação

Any é um tipo especial que combina com tudo. Um valor anotado como Any pode receber qualquer coisa e ser usado de qualquer jeito, sem o mypy reclamar. Isso soa conveniente, mas é justamente o problema: onde entra Any, a verificação de tipos se desliga. Um pouco de Any é inevitável, por exemplo ao lidar com dados de fora ainda sem forma definida. Muito Any transforma o código tipado em código sem tipos, com todo o custo de escrever anotações e nenhum benefício.

Apelidos de tipo para legibilidade

Quando um tipo fica longo, repeti-lo em várias assinaturas polui o código. Um apelido de tipo resolve isso: você atribui o tipo a um nome e usa o nome no lugar. Se um sistema de coordenadas usa muito list[tuple[float, float]], criar Trajeto = list[tuple[float, float]] deixa as assinaturas curtas e o significado claro. O apelido não cria um tipo novo; é só um nome mais legível para o mesmo tipo. Em versões recentes há a palavra type para deixar isso ainda mais explícito.

Trajeto = list[tuple[float, float]]
TabelaPrecos = dict[str, float]

def distancia_total(rota: Trajeto) -> float:
    total = 0.0
    for i in range(1, len(rota)):
        x1, y1 = rota[i - 1]
        x2, y2 = rota[i]
        total += ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
    return total

caminho: Trajeto = [(0.0, 0.0), (3.0, 4.0)]
print(distancia_total(caminho))  # 5.0

Trajeto é um apelido para list[tuple[float, float]]; a assinatura fica legível.

O apelido Trajeto conta a intenção que list[tuple[float, float]] esconde. Quem lê distancia_total(rota: Trajeto) entende de imediato que a função recebe um caminho, não uma lista qualquer de pares. Esse tipo de nomeação é engenharia de legibilidade: o programa faz o mesmo, mas fica mais fácil de manter. Na próxima aula você conhece TypeVar e generics, que levam essa ideia adiante ao escrever código que funciona para qualquer tipo sem abrir mão da verificação.