@dataclass: menos código, mais intenção

O que o decorador gera para você

Uma classe cujo papel é só guardar dados costuma render muito código repetitivo: um __init__ que recebe cada atributo e o atribui a self, um __repr__ para imprimir o objeto de forma legível, e um __eq__ para comparar dois objetos por conteúdo. O decorador @dataclass, da biblioteca padrão, gera tudo isso a partir dos campos que você declara. Você escreve apenas o nome e o tipo de cada campo, e o Python monta os métodos por baixo dos panos.

from dataclasses import dataclass

@dataclass
class Ponto:
    x: float
    y: float

p = Ponto(3.0, 4.0)
print(p)          # Ponto(x=3.0, y=4.0)  <- __repr__ gerado
print(p == Ponto(3.0, 4.0))  # True         <- __eq__ gerado
print(p.x, p.y)   # 3.0 4.0

Só os campos x e y foram declarados; o __init__, o __repr__ e o __eq__ vieram de graça.

Repare no que você não escreveu: nenhum __init__, nenhum __repr__, nenhum __eq__. Mesmo assim, Ponto(3.0, 4.0) constrói o objeto, print mostra Ponto(x=3.0, y=4.0) em vez de um endereço de memória, e a comparação por igualdade funciona campo a campo. Tudo isso saiu dos dois campos anotados. É menos código para escrever, menos para errar e menos para manter.

A mesma classe, à mão e com dataclass

Para sentir a diferença, vale ver a versão manual. Sem dataclass, a classe Ponto exigiria escrever o construtor atribuindo cada parâmetro, mais um __repr__ que monta o texto à mão, mais um __eq__ que compara os campos e ainda checa o tipo do outro objeto. São dezenas de linhas para algo que o decorador resolve em duas. E quanto mais campos, maior a economia e menor a chance de esquecer um deles em algum dos métodos.

# Versao manual, sem dataclass:
class PontoManual:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __repr__(self):
        return f"PontoManual(x={self.x}, y={self.y})"
    def __eq__(self, outro):
        if not isinstance(outro, PontoManual):
            return NotImplemented
        return self.x == outro.x and self.y == outro.y

# Versao com dataclass faz o mesmo em duas linhas de campo.

A versão manual repete o que a dataclass gera sozinha a partir dos campos.

Valores padrão nos campos

Campos podem ter valor padrão, escrito com o sinal de igual depois do tipo. Um campo com padrão pode ser omitido na construção. Assim como em funções, os campos com padrão precisam vir depois dos campos sem padrão, porque a ordem vira a ordem dos argumentos do __init__ gerado. Isso cobre o caso simples de valores imutáveis como números, textos e booleanos. Para valores mutáveis, como listas, há uma regra especial que a próxima aula detalha.

from dataclasses import dataclass

@dataclass
class Produto:
    nome: str
    preco: float
    em_estoque: bool = True
    desconto: float = 0.0

print(Produto("Caneca", 25.0))
# Produto(nome='Caneca', preco=25.0, em_estoque=True, desconto=0.0)

print(Produto("Livro", 40.0, False, 0.1))
# Produto(nome='Livro', preco=40.0, em_estoque=False, desconto=0.1)

Campos com padrão (em_estoque, desconto) podem ser omitidos e vêm depois dos sem padrão.

No exemplo, nome e preco são obrigatórios; em_estoque e desconto têm padrão e podem ficar de fora. O __init__ gerado respeita essa ordem. Com isso você já modela a maioria das classes de dados simples do dia a dia. As próximas aulas acrescentam as ferramentas para casos mais exigentes: campos com valores mutáveis, imutabilidade e validação na construção.