plano de voo

O que vamos aprender hoje

de onde paramos · 5 dias atrás

Classes abstratas — o que vimos na aula 10

Antes de seguir, três coisas pra colocar de volta na ponta da língua.

• 🏛️ ABC + @abstractmethod transformam um método de sugestão em obrigação — subclasses são forçadas a implementar.
• 🛑 O ganho: classes incompletas nem chegam a nascer — TypeError antes do bug virar produção.
• 🏗️ Convivência: métodos abstratos (o que varia) e métodos concretos (o que se repete) moram na mesma classe-mãe.

memória muscular

O contrato em ação — aula 10

Toda subclasse de Pagamento era obrigada a implementar processar e gerar_recibo. Esquecer um? TypeError na hora.

from abc import ABC, abstractmethod

class Pagamento(ABC):
    def __init__(self, cliente):
        self.cliente = cliente

    @abstractmethod
    def processar(self, valor):
        pass

    @abstractmethod
    def gerar_recibo(self, valor):
        pass

class PagamentoPix(Pagamento):
    def processar(self, valor):
        print(f"Transferência Pix de R$ {valor:.2f} de {self.cliente}")
        return True

    def gerar_recibo(self, valor):
        return f"[PIX] {self.cliente} — R$ {valor:.2f}"

pergunta pra turma · 2 minutos

Pra esquentar a cabeça

Discutam em duplas. Depois levantem a mão e respondam no quadro.

• ❓ Em Java ou C#, posso escrever somar(int, int) e também somar(int, int, int) na mesma classe — o compilador escolhe pela quantidade de argumentos. Em Python, se eu definir def somar(self, a, b) e logo depois def somar(self, a, b, c), o que acontece?

a resposta · e por que ela importa

A segunda definição apaga a primeira

Python não procura por assinatura. Procura por nome. E se o nome já existe, o novo valor substitui — silenciosamente.

• 🪦 O Python vê dois def somar e simplesmente regrava o atributo da classe. O segundo apaga o primeiro — como se você fizesse x = 1; x = 2.
• 🚩 Resultado: chamar c.somar(1, 2) dispara TypeError: missing 1 required positional argument: 'c'. Você perdeu uma versão sem perceber.

parte 1 · começando pelo problema

Em outras linguagens, isso é normal

Linguagens com tipagem estática escolhem o método pela assinatura — nome + tipos + quantidade de parâmetros. Cada assinatura é um método diferente.

• 🧰 Lá: o compilador olha a chamada, casa com a assinatura correta, executa. Várias versões coexistem na mesma classe porque cada uma é única — Java, C#, C++ funcionam assim.
• 🐍 Em Python: método é só um nome no dicionário da classe. Sem assinatura gravada, sem compilador escolhendo — só o último def permanece.

o problema em código

O Python sobrescreve em silêncio

Veja o que acontece quando alguém vindo de Java tenta replicar o padrão de sobrecarga em Python.

class Calculadora:
    def somar(self, a, b):
        return a + b

    def somar(self, a, b, c):    # 💥 sobrescreve o de cima
        return a + b + c

c = Calculadora()
print(c.somar(1, 2, 3))   # 6  ← só esta versão existe
print(c.somar(1, 2))      # TypeError: missing 'c'

a ideia da solução

Em vez de várias versões, uma versão flexível

Se o Python só guarda um def somar, então esse único def precisa aceitar todas as variações de chamada que a gente quer suportar.

• 🎚️ A ideia: escrever um método com parâmetros flexíveis — alguns obrigatórios, outros opcionais, e uma rota de escape pra "quantos vierem".
• 🧰 Três ferramentas: valores default, *args e **kwargs. Cada uma resolve um tipo de variação.

as peças que você vai encontrar

Antes do código, conhece quem entra em cena

Três ferramentas, cada uma com um papel claro. Memorize: default para opcionais, *args para muitos posicionais, **kwargs para muitos nomeados.

• 🎯 Parâmetro default: escrever def somar(self, a, b, c=0) diz "se não me passar c, use zero". Resolve o caso "às vezes 2, às vezes 3 argumentos".
• 📦 *args: empacota qualquer quantidade de argumentos posicionais em uma tupla. def somar(self, *valores) aceita somar(1, 2), somar(1, 2, 3, 4), somar() — todos.
• 🏷️ **kwargs: empacota argumentos nomeados em um dicionário. def configurar(self, **opcoes) aceita configurar(cor="azul", tamanho=10).

ferramenta 1 · 90% dos casos

default — quando alguns argumentos são opcionais

Pro caso clássico 'às vezes 2 args, às vezes 3'. Você dá um valor padrão e quem chamar decide se passa.

class Calculadora:
    def somar(self, a, b, c=0):
        return a + b + c

c = Calculadora()
print(c.somar(1, 2))      # 3   (c assume 0)
print(c.somar(1, 2, 5))   # 8

ferramenta 2 · quantidade variável

*args — quando a quantidade de argumentos varia

Pro caso 'quero somar 2, ou 5, ou 50 números'. O * empacota tudo numa tupla.

class CalculadoraN:
    def somar(self, *valores):
        return sum(valores)

c = CalculadoraN()
print(c.somar())             # 0
print(c.somar(1, 2))         # 3
print(c.somar(1, 2, 3, 4))   # 10

ferramenta 3 · argumentos nomeados

**kwargs — quando os argumentos têm nome

Pro caso 'aceito várias opções e cada uma tem nome próprio'. Dois ** empacotam num dicionário.

class Config:
    def configurar(self, **opcoes):
        for chave, valor in opcoes.items():
            print(f"{chave} = {valor}")

c = Config()
c.configurar(cor="azul", tamanho=10, debug=True)
# cor = azul
# tamanho = 10
# debug = True

a solução em código

Uma calculadora que aceita 2, 3 ou N argumentos

Três versões da mesma ideia — escolha a que faz sentido pro seu caso. Em projetos reais, default cobre 90% dos casos.

# Versão 1: parâmetros default (2 OU 3 argumentos)
class Calculadora:
    def somar(self, a, b, c=0):
        return a + b + c

# Versão 2: *args (qualquer quantidade)
class CalculadoraN:
    def somar(self, *valores):
        return sum(valores)

# Versão 3: **kwargs (argumentos nomeados)
class CalculadoraConfig:
    def configurar(self, **opcoes):
        for chave, valor in opcoes.items():
            print(f"{chave} = {valor}")

o que muda do lado de fora

Os três jeitos em uso

Mesmo código de chamada que travava antes — agora cada um funciona.

from calculadora_flexivel import Calculadora, CalculadoraN, CalculadoraConfig

c = Calculadora()
print(c.somar(1, 2))       # 3
print(c.somar(1, 2, 3))    # 6

cn = CalculadoraN()
print(cn.somar(1, 2))            # 3
print(cn.somar(1, 2, 3, 4, 5))   # 15
print(cn.somar())                # 0

cc = CalculadoraConfig()
cc.configurar(cor="azul", tamanho=10, debug=True)
# cor = azul
# tamanho = 10
# debug = True

agora podemos dar o nome

Isso se chama simular sobrecarga

Sobrecarga de método — no sentido clássico (Java, C++) — não existe em Python. O que fazemos é simular usando os recursos da própria linguagem.

• 🪞 Sobrecarga clássica: várias versões do mesmo método, escolhidas em compilação. Linguagens estáticas, com assinaturas rígidas.
• 🐍 Em Python: uma versão com parâmetros flexíveis (default, *args, **kwargs) cobre os mesmos casos sem precisar de compilador escolhendo.

analogia · do mundo real

Pedido no balcão

Pensa no café da padaria. O atendente é um só — o que varia é o pedido.

• ☕ "Um café, por favor": chamada simples, com o mínimo. O atendente sabe entregar usando o padrão da casa (sem açúcar, copo médio, leite normal).
• 🧋 "Um café com dois açúcares, leite vegetal e canela": mesma função do atendente, mais informações no pedido. Ele se adapta sem precisar virar outra pessoa.

antes de ensinar, observar

Você já viu isso funcionar

Antes de implementar dunders nas suas classes, repara que o Python já faz isso com os tipos nativos — e você usa todo dia sem perceber.

print("abc" + "def")      # abcdef
print([1, 2] + [3, 4])    # [1, 2, 3, 4]
print((1, 2) + (3, 4))    # (1, 2, 3, 4)

print("abc" == "abc")     # True
print([1, 2] < [1, 3])    # True
print(len("abc"))         # 3

parte 2 · a outra sobrecarga

E quando a gente quer somar objetos?

A parte 1 resolveu chamadas do mesmo método com argumentos diferentes. Agora vamos pra outra dimensão de sobrecarga — bem mais visual. E ela já estava sob o seu nariz desde a aula 02.

• 🔍 Lembra dos nomes com dois sublinhados? __init__ (aulas 02 e 05), __str__ (aula 03), e o próprio ABC (aula 10) — todos seguem o padrão __nome__. Não é coincidência.
• 🧩 São contratos da linguagem: nomes que o Python procura automaticamente em resposta a operadores (+, ==), funções built-in (len(...), print(...)) e eventos do ciclo de vida do objeto.

o problema em código

Vetor + Vetor: o que o Python responde

Sem nenhuma configuração extra, tentar somar dois objetos da nossa classe trava com mensagem clara.

class Vetor:
    def __init__(self, x, y):
        self.x = x
        self.y = y

v1 = Vetor(1, 2)
v2 = Vetor(3, 4)

print(v1 + v2)
# TypeError: unsupported operand type(s) for +: 'Vetor' and 'Vetor'

print(v1 == Vetor(1, 2))
# False  ← e isso é ainda pior: aceita, mas dá errado

a ideia da solução

E se a gente ensinasse o Python?

O Python não adivinha como somar objetos nossos — mas tem um sistema pronto pra você contar pra ele.

• 📖 A ideia: existem métodos com nomes especiais — começam e terminam com __ — que o Python chama automaticamente quando vê certos operadores.
• ⚡ O efeito: implementa __add__ na sua classe e, daí em diante, v1 + v2 funciona — Python chama v1.__add__(v2) nos bastidores.

você já conhece dois

Dunder methods não são novidade

Toda vez que você escreveu __init__ ou __str__, você já estava sobrecarregando operador — só não tinha esse nome.

• 🏗️ __init__ (aulas 02 e 05) é chamado quando você faz Vetor(1, 2). Os parênteses depois do nome da classe são o "operador de criação".
• 🖨️ __str__ (aula 03) é chamado quando você faz print(v) ou str(v). O print é o "operador de imprimir".

a solução em código

Vetor que entende +, -, == e print

Quatro métodos. Cada um corresponde a um operador. Os nomes são fixos — o Python só procura por eles se forem escritos exatamente assim.

class Vetor:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, outro):              # v1 + v2
        return Vetor(self.x + outro.x, self.y + outro.y)

    def __sub__(self, outro):              # v1 - v2
        return Vetor(self.x - outro.x, self.y - outro.y)

    def __eq__(self, outro):                # v1 == v2
        return self.x == outro.x and self.y == outro.y

    def __str__(self):                       # print(v1)
        return f"Vetor({self.x}, {self.y})"

o que muda do lado de fora

Agora o Vetor se comporta como tipo nativo

O mesmo código que travava antes — agora roda limpo. E o objeto se comporta como você esperaria de um número.

v1 = Vetor(1, 2)
v2 = Vetor(3, 4)

print(v1 + v2)        # Vetor(4, 6)
print(v2 - v1)        # Vetor(2, 2)

print(v1 == Vetor(1, 2))   # True
print(v1 == v2)            # False

soma = v1 + v2
print(soma)           # Vetor(4, 6)

pergunta pra turma · 3 minutos

E que outros operadores fariam sentido?

Em duplas. Pensando num Vetor 2D (posição, deslocamento, velocidade) — discutam:

• 🤔 Quais operadores fariam sentido natural? Pensem em * (multiplicar por escalar?), /, < (qual seria "menor"?), len(v) (o tamanho do vetor?), -v (o vetor oposto?).
• ⛔ E quais NÃO fariam sentido? Pensem em casos onde a operação seria ambígua, estranha pro leitor, ou simplesmente sem significado matemático.

panorama · os dunder methods mais usados

O mapa: operador → método

analogia do cotidiano

Tomada universal

Pensa numa tomada. Ela tem um padrão — três pinos, voltagem específica. Qualquer aparelho que respeitar esse padrão se conecta sem o eletricista precisar saber se é geladeira ou ventilador.

• 🔌 O padrão (+, ==, print) é o formato da tomada. Quem chama o operador é o eletricista — não precisa abrir o aparelho.
• 📱 Implementar __add__ é colocar o plugue certo no seu aparelho. Daí em diante, ele encaixa em qualquer tomada do tipo +.

anatomia

Como sobrecarregar um operador, passo a passo

Toda sobrecarga de operador segue o mesmo esqueleto. Decora esse padrão e o resto é variação.

armadilha · não faça isso

Operador não modifica — devolve

Quando você escreve 1 + 2, nem o 1 nem o 2 mudam. O mesmo vale pros seus dunders. Erro clássico: alterar self dentro de __add__.

# Errado: modifica self silenciosamente
class VetorRuim:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, outro):
        self.x = self.x + outro.x   # muda self
        self.y = self.y + outro.y   # muda self
        return self

# Certo: devolve novo objeto
class VetorBom:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, outro):
        return VetorBom(self.x + outro.x, self.y + outro.y)

antes e depois · lado a lado

A diferença que os dunders fazem

uso com critério

Quando usar (e quando não usar)

Sobrecarregar operador é poderoso, mas não toda classe ganha com isso. Use quando o operador de fato tem significado natural na sua classe.

• ✅ Use quando: a operação tem sentido matemático ou intuitivo. Vetor, Fração, Dinheiro, Tempo, Ponto — somam, subtraem, comparam.
• ⛔ Evite quando: a operação não é óbvia. Cliente + Cliente não faz sentido — use um método com nome explícito, tipo juntar(outro_cliente).

cuidado especial · __eq__

Mexeu em __eq__? Mexa em __hash__ também

Um cuidado pra guardar pra mais tarde. O Python identifica cada objeto por um número chamado hash — pensa numa "impressão digital". Quando você cria seu próprio __eq__, o Python desativa essa impressão digital por segurança, e o objeto deixa de funcionar em algumas estruturas (como set e chave de dict). Não precisa dominar hash agora — só siga a regra de bolso abaixo.

class Produto:
    def __init__(self, codigo, nome):
        self.codigo = codigo
        self.nome = nome

    def __eq__(self, outro):
        return self.codigo == outro.codigo

    def __hash__(self):
        return hash(self.codigo)   # mesmo atributo do __eq__

glossário rápido

Os termos de hoje, em uma frase cada

laboratório em sala · duplas

Exercício ao Vivo: Classe Fração

Em duplas. 30 minutos. Objetivo: construir uma Fracao que se comporta como um número — soma, subtrai, multiplica, divide, compara e imprime bonito.

resolução · passo 1

Estrutura e simplificação

O __init__ já simplifica na construção — assim toda Fracao na vida do programa já nasce reduzida.

from math import gcd

class Fracao:
    def __init__(self, numerador, denominador):
        self.numerador = numerador
        self.denominador = denominador
        # simplifica logo ao criar: toda Fracao nasce reduzida
        self._simplificar()

    def _simplificar(self):
        # gcd = maior número que divide os dois sem deixar resto
        divisor = gcd(self.numerador, self.denominador)
        # //= divide e guarda de volta (divisão inteira, sem virar decimal)
        self.numerador //= divisor
        self.denominador //= divisor

resolução · passo 2

As quatro operações + igualdade + print

Sete dunders, cada um devolvendo uma nova Fracao ou um booleano. A simplificação acontece de graça no __init__.

    def __add__(self, outra):
        # soma de frações: cruza numerador com denominador da outra
        n = self.numerador * outra.denominador + outra.numerador * self.denominador
        d = self.denominador * outra.denominador
        # devolve uma Fracao NOVA (não altera self) — já sai simplificada
        return Fracao(n, d)

    def __sub__(self, outra):
        # subtração: mesma lógica da soma, trocando + por -
        n = self.numerador * outra.denominador - outra.numerador * self.denominador
        d = self.denominador * outra.denominador
        return Fracao(n, d)

    def __mul__(self, outra):
        # multiplicação: numerador x numerador, denominador x denominador
        return Fracao(self.numerador * outra.numerador,
                      self.denominador * outra.denominador)

    def __truediv__(self, outra):
        # divisão: multiplica pela fração invertida (numerador vira denominador)
        return Fracao(self.numerador * outra.denominador,
                      self.denominador * outra.numerador)

    def __eq__(self, outra):
        # iguais se numerador E denominador batem (ambas já simplificadas)
        return (self.numerador == outra.numerador and
                self.denominador == outra.denominador)

    def __str__(self):
        # define como a Fracao aparece no print: "1/2"
        return f"{self.numerador}/{self.denominador}"

resolução · passo 3

Usando a Fração

Mesmo código que você escreveria pra int — só que com Fracao no lugar.

from fracao import Fracao

metade = Fracao(1, 2)
quarto = Fracao(1, 4)
dois_tercos = Fracao(2, 3)

# graças aos dunders, usamos + - * / direto, como se fosse número
print(f"1/2 + 1/4 = {metade + quarto}")
print(f"1/2 - 1/4 = {metade - quarto}")
print(f"2/3 * 3/4 = {dois_tercos * Fracao(3, 4)}")
print(f"1/2 / 1/4 = {metade / quarto}")

# __eq__ em ação: 2/4 e 1/2 são iguais porque ambas viram 1/2 ao nascer
print(f"\n2/4 == 1/2 ? {Fracao(2, 4) == metade}")
print(f"6/8 == 3/4 ? {Fracao(6, 8) == Fracao(3, 4)}")

resolução · saída

Saída esperada no terminal

Quatro operações e duas comparações — todas com resultado já simplificado.

$ python main.py
1/2 + 1/4 = 3/4
1/2 - 1/4 = 1/4
2/3 * 3/4 = 1/2
1/2 / 1/4 = 2/1

2/4 == 1/2 ? True
6/8 == 3/4 ? True

encerramento

O que dominamos hoje

• ✓
  Entendemos por que o Python não tem sobrecarga clássica — e que isso não é limitação, é só um jeito diferente de resolver.
• ✓
  A solução parte 1: parâmetros default, *args e **kwargs simulam o efeito.
• ✓
  A regra: uma versão flexível em vez de várias versões fixas.
• ✓
  A solução parte 2: dunder methods — __add__, __eq__, __str__ e companhia.
• ✓
  A ponte com a linguagem: o Python chama o dunder certo pra cada operador. + chama __add__, == chama __eq__.
• ✓
  Na prática: classe Fracao que opera como número nativo — soma, subtrai, multiplica, divide, compara e imprime.

exercícios · visão geral

Para praticar em casa

Sete exercícios em quatro níveis. Faça pelo menos um de cada nível antes da próxima aula.

exercícios · nível fácil

Para fixar simulação de sobrecarga

exercícios · nível médio

Sobrecarregar operadores em classes reais

exercícios · nível difícil

Para ir além

exercícios · nível avançado

O desafio que junta tudo

Um exercício só, mas que usa as duas metades da aula ao mesmo tempo.

resumo final

Em uma linha cada

• ✓
  Sobrecarga de método em Python é simulada — uma versão flexível em vez de várias.
• ✓
  default, *args e **kwargs cobrem 99% das necessidades de sobrecarga.
• ✓
  Operadores chamam dunders — + chama __add__, == chama __eq__.
• ✓
  Você já vinha sobrecarregando operador desde a aula 03 com __str__.
• ✓
  Use operator overloading quando o operador faz sentido óbvio na sua classe — não force a barra.