CS Fundamentals Trainer · Guias
Classes, herança e tipagem em Python
Busca de atributos, a MRO e o super(), properties e descritores, dataclasses e o que custam, classes base abstratas, Protocols e o que as dicas de tipo garantem e não garantem em tempo de execução.
18 min de leitura
As classes em Python são menos especiais do que parecem. Uma classe é um objeto, uma instância é um objeto com um dicionário de atributos e um vínculo com a sua classe, e quase tudo o que uma classe faz (acesso a atributos, property, chamadas de método, operadores, super()) é uma regra de busca que você pode ler e testar. As dicas de tipo, por sua vez, são comentários que o interpretador guarda mas nunca verifica. Este guia cobre como a busca de atributos e a herança realmente funcionam, o que são @property e descritores, o que as dataclasses geram, quando cabe uma classe base abstrata ou um Protocol, e o que as dicas de tipo garantem e não garantem. Cada afirmação vem com um script rodado no CPython 3.13 (no apêndice). Ele pressupõe que você leu como o Python funciona, em particular a seção sobre métodos especiais.
Um limite logo de início: o ambiente em que rodei estes scripts não tinha verificador de tipos instalado (mypy, pyright), então este guia descreve o que os verificadores fazem a partir da documentação deles, e toda saída mostrada vem do interpretador em execução.
1. Busca de atributos
Quando você escreve obj.name, o Python procura em uma ordem fixa:
- Um descritor de dados na classe (por exemplo uma
propertyou qualquer coisa que defina__set__) vem primeiro. - Depois o
__dict__da própria instância. - Depois descritores que não são de dados e atributos simples da classe, seguindo a ordem de herança (seção 2).
- Por fim
__getattr__, se a classe o define.
Os efeitos práticos, todos testados:
- Atributos de instância ocultam atributos de classe. Com
class Shadow: x = "class", lers.xdeu"class"; depois des.x = "instance"deu"instance", enquantoShadow.xcontinuava"class". Atribuir por uma instância nunca muda o atributo da classe. (Mutar um atributo de classe mutável compartilhado muda, como o guia anterior mostrou.) - Métodos são funções comuns guardadas na classe. Eles viram métodos vinculados quando buscados por uma instância:
k.m.__self__ is kfoiTrue, eK.mera o mesmo objeto função queK.__dict__["m"]. Esse é todo o truque por trás doself:k.m()éK.m(k). isinstance(x, Base)segue a herança,type(x) is Basenão. Para uma instância deSub(Base)o primeiro foiTruee o segundoFalse. Prefiraisinstance, para que as subclasses continuem funcionando onde quer que a base seja aceita.
2. Herança e a ordem de resolução de métodos
Uma classe pode ter vários pais. O Python achata a hierarquia em uma única lista, a ordem de resolução de métodos (MRO), calculada pelo algoritmo de linearização C3. Uma busca percorre essa lista da esquerda para a direita e usa a primeira correspondência. Para o clássico losango (D(B, C), em que B e C estendem A) a MRO foi:
['D', 'B', 'C', 'A', 'object']
A vem depois dos dois filhos, e object é sempre o último. Se os pais são listados em uma ordem contraditória, o Python se recusa a construir a classe: class X(A, B) em que B já estende A levantou TypeError: Cannot create a consistent method resolution order (MRO) for bases A, B.
O que o super() realmente faz
O super() não significa "meu pai". Significa "a próxima classe depois de mim na MRO do tipo real do objeto". É isso que faz a herança múltipla cooperativa funcionar. No losango, cada método hello acrescentou o próprio nome e chamou super().hello(); chamar D().hello() deu:
['D', 'B', 'C', 'A']
O super() de B foi para C, não para A, porque C é o próximo na MRO de um D. Cada classe da cadeia rodou exatamente uma vez. As regras que mantêm isso funcionando: chame super() em todo método cooperante, aceite *args, **kwargs e repasse-os quando as assinaturas diferirem, e mantenha os métodos __init__ cooperativos.
Herança ou composição?
A herança diz "é um"; a composição diz "tem um". A herança acopla a subclasse a todos os detalhes do pai (uma mudança nas partes internas do pai pode quebrar o filho), então prefira a composição por padrão: guarde outro objeto e delegue a ele. Use herança quando a subclasse for de fato uma especialização que pode substituir o pai em qualquer lugar onde ele for aceito (o princípio da substituição de Liskov), quando um framework exigir, ou para pequenos mixins que acrescentam um comportamento. Se você pensar em herança múltipla de estado real, pare e reconsidere.
O __init_subclass__ permite que uma classe base reaja quando é herdada, o que substitui muitos usos de metaclasses. Uma base Plugin que adicionava o nome de cada subclasse a um registro produziu ['P1', 'P2'] depois que duas subclasses foram definidas, sem decorador nem metaclasse.
3. Propriedades e descritores
Uma property transforma chamadas de método em acesso a atributo, de modo que você pode começar com um atributo simples e acrescentar validação depois sem mudar quem o chama:
class Temp:
@property
def celsius(self): return self._c
@celsius.setter
def celsius(self, v):
if v < -273.15: raise ValueError("below absolute zero")
self._c = v
@property
def fahrenheit(self): return self._c * 9 / 5 + 32 # computed, read-only
Atribuir t.celsius = -300 levantou ValueError: below absolute zero, e atribuir a t.fahrenheit levantou AttributeError: property 'fahrenheit' of 'Temp' object has no setter. É por isso que o código Python não escreve getters e setters de antemão: um atributo público pode virar uma property depois sem quebrar ninguém.
Uma property é construída sobre o protocolo de descritores: qualquer objeto em uma classe com __get__ e, opcionalmente, __set__ ou __set_name__, controla o acesso ao atributo sob o qual está guardado. Escrevi um descritor reutilizável Positive e o usei em dois campos de uma classe Item; Item(5, 2) funcionou (preço vezes quantidade deu 10) e Item(-1, 1) levantou ValueError: must be positive. Funções, classmethod, staticmethod e __slots__ também são descritores. Você raramente escreverá um, mas ele explica como a linguagem se comporta.
__repr__ e __str__
O repr() é para desenvolvedores e deve ser inequívoco (idealmente algo que você poderia colar de volta no código); o str() é para leitores. Se uma classe define apenas __repr__, o str() recorre a ele, que foi o que vi: str(P("a")), repr(P("a")) e o repr de uma lista que o continha foram todos P('a'). Sempre defina __repr__; é o que você vê em logs e tracebacks.
4. Dataclasses
Uma classe que basicamente guarda campos precisa do mesmo código repetitivo todas as vezes: __init__, __repr__, __eq__. O decorador @dataclass o gera a partir das anotações:
@dataclass
class Point:
x: int
y: int = 0
Point(1, 2) foi impresso como Point(x=1, y=2), foi igual a outro Point(1, 2) e não era o mesmo objeto. As opções que importam:
| Opção | O que faz | O que vi |
|---|---|---|
eq=True (padrão) | gera __eq__ e define __hash__ como None | {p: 1} levantou TypeError: unhashable type: 'Point' |
frozen=True | proíbe atribuição depois da criação e gera __hash__ | atribuir levantou FrozenInstanceError; instâncias iguais tinham hashes iguais |
order=True | gera <, <=, >, >= comparando os campos como tuplas | sorted() ordenou Version(0, 9), Version(1, 2), Version(1, 10) |
slots=True | usa __slots__ (3.10+) | veja a tabela de memória abaixo |
Auxiliares: dataclasses.replace(obj, field=value) faz uma cópia modificada (o jeito de "mudar" um objeto congelado), e asdict(obj) converte para um dict.
Padrões mutáveis são rejeitados. tags: list = [] levantou ValueError: mutable default <class 'list'> for field tags is not allowed: use default_factory, protegendo você do bug do padrão compartilhado. Escreva tags: list = field(default_factory=list); duas instâncias passaram então a ter listas separadas (['x'] e []).
Escolha conforme a necessidade: uma dataclass para um registro mutável ou congelado com métodos; uma NamedTuple para um registro imutável pequeno que também deve se comportar como tupla; um dict simples para dados de formato desconhecido; uma classe quando o comportamento domina. Para validar entrada não confiável (JSON de uma requisição), uma biblioteca de validação como a pydantic checa tipos em tempo de execução; as dataclasses não.
O que um registro custa
Criei 500.000 objetos de dois campos de cada tipo e dividi a memória rastreada pela contagem:
| Tipo | Bytes por objeto |
|---|---|
classe simples com __init__ | 96 |
@dataclass | 96 |
@dataclass(slots=True) | 56 |
namedtuple | 72 |
tuple | 64 |
(Os inteiros pequenos lá dentro são objetos compartilhados, então estes valores são só do contêiner.) Uma dataclass tem o mesmo tamanho que a classe escrita à mão; slots=True remove o dicionário por instância. Isso só importa quando você guarda milhões de instâncias.
5. Classes base abstratas
Uma classe base abstrata (ABC) declara métodos que as subclasses devem fornecer. O Python faz isso valer quando você tenta criar uma instância:
class Shape(ABC):
@abstractmethod
def area(self) -> float: ...
class Half(Shape): pass
Half() # TypeError: Can't instantiate abstract class Half without an implementation for abstract method 'area'
Uma subclasse que implementou area funcionou (Sq(3).area() deu 9). Use ABCs quando você controla uma família de classes e quer uma falha na construção, em vez de na primeira chamada. O módulo collections.abc tem algumas prontas (Iterable, Mapping, Sequence) das quais você pode herdar ou que pode usar com isinstance.
6. Dicas de tipo: o que são e o que não são
Anotações como def double(n: int) -> int são guardadas e, fora isso, ignoradas quando o programa roda. Chamei double("ab") e obtive 'abab'; as dicas simplesmente estavam em double.__annotations__. Um campo de dataclass anotado como n: int guardou sem problemas a string 'not an int'. As dicas são lidas por:
- Verificadores estáticos de tipos (mypy, pyright e os verificadores embutidos nos editores), que analisam seu código-fonte sem executá-lo e apontam chamadas que contradizem os tipos declarados, verificações de
Noneesquecidas e erros parecidos; - editores e ferramentas de documentação, para autocompletar e exibir;
- bibliotecas que as usam de propósito em tempo de execução (pydantic, FastAPI, conversores de dataclass).
Assim, as dicas dão detecção de bugs cedo e barata e melhor documentação se você roda um verificador na CI, e nenhuma proteção caso contrário. Hábitos úteis:
- Anote primeiro as assinaturas das funções; elas são o contrato. Deixe o verificador inferir as variáveis locais.
- Use a sintaxe moderna:
list[str],dict[str, int],X | None(3.10+) eOptional[X]nas versões mais antigas. Uma função que retornaOptional[str]obriga quem a chama a tratarNone;first([])retornouNone. - Prefira tipos abstratos nos parâmetros (
Iterable,Mapping,Sequence) e tipos concretos nos valores de retorno. - Adote aos poucos. Tipar uma base de código grande de uma vez raramente funciona; comece pelos módulos novos e pelas interfaces públicas.
- Dicas não são validação. Verifique a entrada não confiável na fronteira do seu programa.
Protocolos: duck typing, por escrito
O estilo nativo do Python é o duck typing: se tem um método close(), trate como algo fechável. Um typing.Protocol permite descrever esse formato para que um verificador possa conferi-lo, sem exigir herança:
@runtime_checkable
class Closeable(Protocol):
def close(self) -> None: ...
Uma classe F com um método close contou como um Closeable sem herdar de nada (isinstance deu True), e uma classe sem ele não contou (False). Com @runtime_checkable, o isinstance verifica apenas que os métodos existem, não suas assinaturas ou tipos; um verificador estático confere o resto. A escolha entre as duas ferramentas:
| Necessidade | Use |
|---|---|
| Aceitar qualquer objeto com os métodos certos, inclusive classes de terceiros | Protocol |
| Compartilhar implementação e exigir que as subclasses preencham métodos | ABC |
| Apenas uma função que funciona com qualquer coisa razoável | nenhuma declaração; documente |
7. Erros comuns
- Atributos de classe mutáveis compartilhados (
items = []no corpo da classe). Crie-os em__init__. - Padrões mutáveis em funções e dataclasses (use
Noneoudefault_factory). - Definir
__eq__sem__hash__, ou mutar um campo que alimenta o hash enquanto o objeto está em um set ou dict. - Tratar o
super()como "o pai" e pulá-lo em hierarquias cooperativas, de modo que alguns métodos__init__ouclosenunca rodam. - Árvores de herança profundas e herança múltipla de classes com estado; prefira a composição.
- Getters e setters escritos com antecedência. Use um atributo simples; promova-o a property quando precisar de lógica.
- Acreditar que as dicas de tipo são verificadas em tempo de execução. Não são (
double("ab")retornou'abab'). - Verificar
type(x) == Baseem vez deisinstance. - Um
__repr__que esconde o estado ou levanta exceção, o que deixa os logs inúteis. - Usar
isinstancecom@runtime_checkablecomo validação (ele só confere nomes).
8. Perguntas que os entrevistadores gostam de fazer
"O que é a MRO e o que o super() faz?"
A MRO é a ordem linear em que o Python procura em uma classe e em seus pais, calculada pela linearização C3 (Class.__mro__). O super() encontra a próxima classe depois da atual na MRO do tipo da instância, então em um losango cada classe roda uma vez.
"Qual é a diferença entre um atributo de classe e um atributo de instância?"
Um atributo de classe é guardado na classe e compartilhado; um atributo de instância é guardado no __dict__ da instância e oculta o atributo da classe nas leituras. Atribuir pela instância nunca muda o atributo da classe, mas mutar um compartilhado mutável muda.
"Como funciona o @property?"
É um descritor de dados guardado na classe: ler chama o getter, atribuir chama o setter, e não há armazenamento por instância a não ser que o getter e o setter o criem. Permite acrescentar validação ou cálculo sem mudar a sintaxe do atributo.
"@dataclass, NamedTuple ou uma classe simples?"
Uma dataclass para um registro que pode ser mutável e ter métodos; NamedTuple para um registro imutável parecido com tupla; uma classe simples quando o comportamento importa mais que os campos. Use frozen=True para registros hasheáveis e slots=True quando houver milhões deles.
"As dicas de tipo tornam o Python estaticamente tipado?"
Não. O interpretador as ignora. Elas só ajudam se um verificador roda, e para bibliotecas que as leem em tempo de execução.
"Protocol ou ABC?"
Um Protocol descreve estrutura e funciona com classes que não herdam dele (subtipagem estrutural); uma ABC é nominal, exige implementação na construção e pode carregar código compartilhado.
"Por que __eq__ sem __hash__ é um problema?"
Definir __eq__ faz __hash__ ser None, então as instâncias ficam não hasheáveis e não podem ser chaves de dict nem membros de set.
9. Coisas a mencionar em uma entrevista
- Ordem de busca de atributos; atributos de instância contra os de classe; métodos como funções vinculadas.
- MRO e C3; como o
super()segue a MRO; herança múltipla cooperativa; composição acima de herança. - Propriedades e o protocolo de descritores;
__repr__contra__str__;__init_subclass__. - O que o
@dataclassgera e suas opções (frozen,order,slots,default_factory). - ABCs contra Protocols; duck typing.
- Dicas de tipo como metadados de análise estática, não verificações em tempo de execução; adoção gradual; validação na fronteira.
Resumo rápido
obj.nameolha os descritores de dados, depois o dicionário da instância, depois a classe e seus pais na ordem da MRO.- A MRO do losango foi
D, B, C, A, object, e osuper()a segue, entãoD().hello()rodou cada classe uma vez:['D', 'B', 'C', 'A']. - Uma property é um descritor; use atributos simples primeiro e acrescente properties quando precisar de lógica.
@dataclassgera__init__,__repr__e__eq__;eqdeixa as instâncias não hasheáveis a menos quefrozen=True; padrões mutáveis precisam dedefault_factory;slots=Truereduziu um objeto de 96 bytes para 56.- ABCs falham na construção quando falta um método abstrato; um Protocol aceita qualquer coisa com os métodos certos.
- As dicas de tipo não fizeram nada em tempo de execução (
double("ab")retornou'abab'); o valor delas vem de um verificador na CI e de interfaces mais claras.
Apêndice: o código dos experimentos
Python 3.13 (CPython), apenas biblioteca padrão. Rode cada arquivo com python3 file.py. O texto exato das mensagens de erro e os tamanhos por objeto podem diferir entre versões do Python.
mro.py: ordem de busca, a MRO e o super(), properties, um descritor, __repr__ e __init_subclass__:
# 1. method resolution order and super()
class A:
def hello(self): return ["A"]
class B(A):
def hello(self): return ["B"] + super().hello()
class C(A):
def hello(self): return ["C"] + super().hello()
class D(B, C):
def hello(self): return ["D"] + super().hello()
print("MRO:", [k.__name__ for k in D.__mro__])
print("D().hello():", D().hello())
# 2. inconsistent hierarchy
try:
class X(A, B): pass
except TypeError as e: print("TypeError:", e)
# 3. attribute lookup order: data descriptor > instance dict > class attr
class Temp:
def __init__(self): self._c = 0
@property
def celsius(self): return self._c
@celsius.setter
def celsius(self, v):
if v < -273.15: raise ValueError("below absolute zero")
self._c = v
@property
def fahrenheit(self): return self._c * 9 / 5 + 32
t = Temp(); t.celsius = 100
print("fahrenheit:", t.fahrenheit)
try: t.celsius = -300
except ValueError as e: print("ValueError:", e)
try: t.fahrenheit = 1
except AttributeError as e: print("AttributeError:", e)
class Shadow:
x = "class"
s = Shadow(); print("before:", s.x); s.x = "instance"; print("after:", s.x, "| class still:", Shadow.x)
# methods are functions bound on access
class K:
def m(self): return 1
k = K()
print("bound method:", k.m.__self__ is k, "| same function:", K.m is K.__dict__["m"])
# 4. a descriptor
class Positive:
def __set_name__(self, owner, name): self.name = "_" + name
def __get__(self, obj, owner): return self if obj is None else getattr(obj, self.name)
def __set__(self, obj, v):
if v <= 0: raise ValueError("must be positive")
setattr(obj, self.name, v)
class Item:
price = Positive()
qty = Positive()
def __init__(self, price, qty): self.price = price; self.qty = qty
i = Item(5, 2); print("descriptor ok:", i.price * i.qty)
try: Item(-1, 1)
except ValueError as e: print("descriptor rejects:", e)
# 5. __repr__ vs __str__
class P:
def __init__(self, n): self.n = n
def __repr__(self): return f"P({self.n!r})"
print(str(P("a")), repr(P("a")), [P("a")])
# 6. isinstance vs type
class Base: pass
class Sub(Base): pass
print(isinstance(Sub(), Base), type(Sub()) is Base)
# 7. __init_subclass__ registry
registry = []
class Plugin:
def __init_subclass__(cls, **kw): super().__init_subclass__(**kw); registry.append(cls.__name__)
class P1(Plugin): pass
class P2(Plugin): pass
print("registered:", registry)
dc_typing.py: dataclasses e suas opções, anotações em tempo de execução, uma ABC, um Protocol e a memória dos tipos de registro:
import sys, tracemalloc
from dataclasses import dataclass, field, replace, asdict, FrozenInstanceError
from abc import ABC, abstractmethod
from typing import Protocol, runtime_checkable, Optional
# dataclass gives __init__, __repr__, __eq__
@dataclass
class Point:
x: int
y: int = 0
p = Point(1, 2)
print(p, p == Point(1, 2), p is Point(1, 2))
# eq without frozen -> unhashable
try: {p: 1}
except TypeError as e: print("TypeError:", e)
# frozen + order
@dataclass(frozen=True, order=True)
class Version:
major: int
minor: int = 0
v = Version(1, 2)
try: v.major = 2
except FrozenInstanceError as e: print("FrozenInstanceError:", type(e).__name__)
print(sorted([Version(1, 10), Version(1, 2), Version(0, 9)]), hash(v) == hash(Version(1, 2)))
print("replace:", replace(v, minor=5), "| asdict:", asdict(v))
# mutable default
try:
@dataclass
class Bad:
tags: list = []
except ValueError as e: print("ValueError:", e)
@dataclass
class Good:
tags: list = field(default_factory=list)
a, b = Good(), Good(); a.tags.append("x"); print("default_factory:", a.tags, b.tags)
# annotations are not enforced at runtime
def double(n: int) -> int: return n * 2
print("double('ab') =", double("ab"), "| annotations:", double.__annotations__)
@dataclass
class Typed: n: int
print("dataclass does not validate:", Typed("not an int"))
# Optional / None handling
def first(xs: list[str]) -> Optional[str]: return xs[0] if xs else None
print("first([]) =", first([]))
# ABC enforcement
class Shape(ABC):
@abstractmethod
def area(self) -> float: ...
class Sq(Shape):
def __init__(self, s): self.s = s
def area(self): return self.s ** 2
class Half(Shape): pass
print("Sq area:", Sq(3).area())
try: Half()
except TypeError as e: print("TypeError:", e)
# Protocol: structural typing (duck typing + checkable)
@runtime_checkable
class Closeable(Protocol):
def close(self) -> None: ...
class F:
def close(self): pass
class NoClose: pass
print("isinstance Protocol:", isinstance(F(), Closeable), isinstance(NoClose(), Closeable))
# memory: plain vs dataclass vs slots dataclass vs tuple
@dataclass
class DC: a: int; b: int
@dataclass(slots=True)
class DS: a: int; b: int
class Plain:
def __init__(self, a, b): self.a = a; self.b = b
from collections import namedtuple
NT = namedtuple("NT", "a b")
for name, mk in (("plain class", lambda: Plain(1, 2)), ("dataclass", lambda: DC(1, 2)), ("dataclass(slots=True)", lambda: DS(1, 2)), ("namedtuple", lambda: NT(1, 2)), ("tuple", lambda: tuple([1, 2]))):
tracemalloc.start(); objs = [mk() for _ in range(500_000)]; cur, _ = tracemalloc.get_traced_memory(); tracemalloc.stop()
print(f"{name:22s} {cur/500_000:6.0f} bytes each"); del objs
Fontes
- Documentação do Python, Data model (métodos especiais,
__slots__,__init_subclass__, descritores). - Documentação do Python, Descriptor HowTo Guide, e The Python 2.3 Method Resolution Order (linearização C3).
- Documentação do Python,
dataclasses,abc,typingecollections.abc. - Python Enhancement Proposals: PEP 557: Data Classes, PEP 544: Protocols: Structural subtyping, PEP 484: Type Hints, PEP 487: Simpler customisation of class creation.
- Raymond Hettinger, Super considered super! (2011).
- Documentação do mypy, Type hints cheat sheet, e a especificação de tipagem em typing.python.org.
Pratique este tema: Python