Python Academy · Aula

TypeVar, classes genéricas e Protocol

Defina tipos genéricos reutilizáveis e subtipagem estrutural com Protocol.

TypeVar, classes genéricas e Protocol é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

O que é TypeVar?

TypeVar declara uma variável de tipo — um marcador que pode representar qualquer tipo, com restrições se necessário. É usado em funções e classes genéricas.

from typing import TypeVar

T = TypeVar("T")

def identity(value: T) -> T:
    return value

print(identity(42))      # int
print(identity("hello")) # str

Funções genéricas

Uma função que usa TypeVar nos tipos dos parâmetros e do retorno permite que o mypy deduza o tipo de retorno a partir do tipo do argumento.

from typing import TypeVar

T = TypeVar("T")

def first(items: list[T]) -> T:
    return items[0]

x: int = first([1, 2, 3])     # mypy knows x is int
s: str = first(["a","b","c"]) # mypy knows s is str

TypeVar com restrições

Passe restrições de tipo para TypeVar a fim de limitar os tipos aceitáveis.

from typing import TypeVar

Numeric = TypeVar("Numeric", int, float)

def double(n: Numeric) -> Numeric:
    return n * 2

print(double(5))    # 10
print(double(2.5))  # 5.0
# double("x")  # mypy error

Classes genéricas

Herde de Generic[T] para criar uma classe parametrizada por uma variável de tipo.

from typing import Generic, TypeVar

T = TypeVar("T")

class Stack(Generic[T]):
    def __init__(self) -> None:
        self._items: list[T] = []

    def push(self, item: T) -> None:
        self._items.append(item)

    def pop(self) -> T:
        return self._items.pop()

stack: Stack[int] = Stack()
stack.push(1)
print(stack.pop())   # 1

Vários TypeVars

Use vários TypeVars para parametrizar uma classe ou função com base em dois tipos independentes.

from typing import Generic, TypeVar

K = TypeVar("K")
V = TypeVar("V")

class Pair(Generic[K, V]):
    def __init__(self, key: K, value: V) -> None:
        self.key = key
        self.value = value

p: Pair[str, int] = Pair("age", 30)
print(p.key, p.value)   # age 30

Protocol — Subtipagem estrutural

Protocol define uma interface pelos métodos e atributos que uma classe deve ter, sem exigir herança explícita ("tipagem pato, verificada por tipos").

from typing import Protocol

class Drawable(Protocol):
    def draw(self) -> None: ...

def render(obj: Drawable) -> None:
    obj.draw()

class Circle:
    def draw(self) -> None:
        print("Drawing circle")

render(Circle())   # works — Circle satisfies Drawable

Protocolo com runtime_checkable

Adicione @runtime_checkable a um Protocol para habilitar verificações isinstance() em tempo de execução.

from typing import Protocol, runtime_checkable

@runtime_checkable
class Closeable(Protocol):
    def close(self) -> None: ...

class File:
    def close(self) -> None: print("closed")

print(isinstance(File(), Closeable))   # True

Protocolo versus ABC

As ABCs exigem herança explícita (class Dog(Animal)). Os Protocols funcionam por correspondência estrutural: se uma classe tiver os métodos corretos, ela satisfará o protocolo independentemente da herança.

from typing import Protocol
from abc import ABC, abstractmethod

# ABC: nominal typing
class Printable(ABC):
    @abstractmethod
    def display(self) -> None: ...

# Protocol: structural typing
class Displayable(Protocol):
    def display(self) -> None: ...

TypeVar com bound

TypeVar("T", bound=BaseClass) restringe T a BaseClass ou a qualquer uma de suas subclasses.

from typing import TypeVar

class Animal:
    def speak(self) -> str: return "..."

A = TypeVar("A", bound=Animal)

def make_speak(animal: A) -> str:
    return animal.speak()

Alias genérico — Python 3.12

O Python 3.12 introduz a instrução type para criar apelidos de tipo de forma simples e a sintaxe class Foo[T] para genéricos sem importar TypeVar.

# Python 3.12+
type Vector = list[float]
type Matrix = list[Vector]

class Stack[T]:
    def __init__(self) -> None: self._items: list[T] = []
    def push(self, item: T) -> None: self._items.append(item)
    def pop(self) -> T: return self._items.pop()

Tipo Self

Self (de typing no Python 3.11 ou posterior) anota métodos que retornam a classe atual, sendo útil em interfaces encadeadas e subclasses.

from typing import Self

class Builder:
    def __init__(self) -> None:
        self.parts: list[str] = []

    def add(self, part: str) -> Self:
        self.parts.append(part)
        return self

b = Builder().add("a").add("b")
print(b.parts)   # ["a", "b"]

Verificação rápida

Qual é a principal diferença entre um Protocol e uma ABC na tipagem do Python?

Recapitulação

TypeVar cria marcadores de tipo para funções e classes genéricas. Generic[T] parametriza classes. Protocol permite subtipagem estrutural sem herança. Use bound= ou restrições de tipo em TypeVar para limitar os tipos aceitáveis.

Perguntas Frequentes

A aula “TypeVar, classes genéricas e Protocol” é grátis?

Sim — o texto completo de “TypeVar, classes genéricas e Protocol” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “TypeVar, classes genéricas e Protocol”?

Defina tipos genéricos reutilizáveis e subtipagem estrutural com Protocol. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “TypeVar, classes genéricas e Protocol”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Anotações básicas de tipos
Tipos complexos: List, Dict, Optional, Union
TypeVar, classes genéricas e Protocol
Executando mypy e corrigindo erros de tipos

← Voltar para Python Academy