antonino, Autor em Área de Trampo

Polimorfismo em Python

22/05/202622/04/2026 Por antonino

Polimorfismo significa “muitas formas” em grego. Ele permite que objetos diferentes respondam à mesma mensagem. Primeiramente, isso torna o código mais flexível e extensível. Por exemplo, cachorro.falar() e gato.falar() têm resultados diferentes. Além disso, você pode tratar objetos distintos de forma uniforme. Assim, a complexidade do sistema diminui significativamente. Consequentemente, a manutenção se torna muito mais fácil. Quando utilizar polimorfismo? Em sistemas que precisam de extensibilidade. Também quando você quer código que funcione com tipos futuros. Por outro lado, para scripts pequenos, polimorfismo é exagero. Python implementa polimorfismo de forma natural e flexível. Então, vamos explorar três tipos principais com exemplos práticos. Três subtítulos guiarão você pelo polimorfismo em Python. Portanto, ao final, você escreverá código mais genérico e reutilizável.

Polimorfismo por herança (subtipagem)

Classes filhas podem sobrescrever métodos da classe mãe. Uma variável do tipo mãe pode receber qualquer filha. Quando usar polimorfismo por herança? Em hierarquias claras. Por exemplo, um sistema de formas geométricas. Além disso, a herança fornece uma estrutura sólida. Exemplo de polimorfismo por herança:

# Classe base (abstrata conceitualmente)
class Forma:
    """Classe base para todas as formas."""
    
    def area(self):
        raise NotImplementedError("Subclasse deve implementar area()")
    
    def perimetro(self):
        raise NotImplementedError("Subclasse deve implementar perimetro()")
    
    def descricao(self):
        return f"Área: {self.area():.2f}, Perímetro: {self.perimetro():.2f}"

# Classes filhas com implementações específicas
class Retangulo(Forma):
    def __init__(self, largura, altura):
        self.largura = largura
        self.altura = altura
    
    def area(self):
        return self.largura * self.altura
    
    def perimetro(self):
        return 2 * (self.largura + self.altura)

class Circulo(Forma):
    def __init__(self, raio):
        self.raio = raio
    
    def area(self):
        return 3.14159 * self.raio ** 2
    
    def perimetro(self):
        return 2 * 3.14159 * self.raio

class Triangulo(Forma):
    def __init__(self, base, altura, lado1, lado2, lado3):
        self.base = base
        self.altura = altura
        self.lado1 = lado1
        self.lado2 = lado2
        self.lado3 = lado3
    
    def area(self):
        return (self.base * self.altura) / 2
    
    def perimetro(self):
        return self.lado1 + self.lado2 + self.lado3

# Função polimórfica (aceita qualquer Forma)
def imprimir_informacoes(formas):
    """Processa qualquer lista de formas polimorficamente."""
    print("=== Informações das Formas ===")
    for i, forma in enumerate(formas, 1):
        print(f"{i}. {forma.__class__.__name__}: {forma.descricao()}")

# Demonstração
print("=== Polimorfismo por Herança ===\n")

formas = [
    Retangulo(5, 3),
    Circulo(4),
    Triangulo(6, 4, 3, 4, 5),
    Retangulo(2, 8),
    Circulo(2.5)
]

imprimir_informacoes(formas)

# Outro exemplo com animais
class Animal:
    def som(self):
        pass

class Cachorro(Animal):
    def som(self):
        return "Au au!"

class Gato(Animal):
    def som(self):
        return "Miau!"

class Vaca(Animal):
    def som(self):
        return "Muuu!"

def fazer_barulho(animais):
    """Função polimórfica para sons de animais."""
    for animal in animais:
        print(f"{animal.__class__.__name__}: {animal.som()}")

print("\n=== Sons de Animais ===")
animais = [Cachorro(), Gato(), Vaca()]
fazer_barulho(animais)

# Classe base (abstrata conceitualmente)

class Forma:

"""Classe base para todas as formas."""

def area(self):

raise NotImplementedError("Subclasse deve implementar area()")

def perimetro(self):

raise NotImplementedError("Subclasse deve implementar perimetro()")

def descricao(self):

return f"Área: {self.area():.2f}, Perímetro: {self.perimetro():.2f}"

# Classes filhas com implementações específicas

class Retangulo(Forma):

def __init__(self, largura, altura):

self.largura = largura

self.altura = altura

def area(self):

return self.largura * self.altura

def perimetro(self):

return 2 * (self.largura + self.altura)

class Circulo(Forma):

def __init__(self, raio):

self.raio = raio

def area(self):

return 3.14159 * self.raio ** 2

def perimetro(self):

return 2 * 3.14159 * self.raio

class Triangulo(Forma):

def __init__(self, base, altura, lado1, lado2, lado3):

self.base = base

self.altura = altura

self.lado1 = lado1

self.lado2 = lado2

self.lado3 = lado3

def area(self):

return (self.base * self.altura) / 2

def perimetro(self):

return self.lado1 + self.lado2 + self.lado3

# Função polimórfica (aceita qualquer Forma)

def imprimir_informacoes(formas):

"""Processa qualquer lista de formas polimorficamente."""

print("=== Informações das Formas ===")

for i, forma in enumerate(formas, 1):

print(f"{i}. {forma.__class__.__name__}: {forma.descricao()}")

# Demonstração

print("=== Polimorfismo por Herança ===\n")

formas = [

Retangulo(5, 3),

Circulo(4),

Triangulo(6, 4, 3, 4, 5),

Retangulo(2, 8),

Circulo(2.5)

]

imprimir_informacoes(formas)

# Outro exemplo com animais

class Animal:

def som(self):

pass

class Cachorro(Animal):

def som(self):

return "Au au!"

class Gato(Animal):

def som(self):

return "Miau!"

class Vaca(Animal):

def som(self):

return "Muuu!"

def fazer_barulho(animais):

"""Função polimórfica para sons de animais."""

for animal in animais:

print(f"{animal.__class__.__name__}: {animal.som()}")

print("\n=== Sons de Animais ===")

animais = [Cachorro(), Gato(), Vaca()]

fazer_barulho(animais)

O mesmo código imprimir_informacoes funciona com qualquer forma. Novas formas podem ser adicionadas sem modificar a função. Portanto, o sistema cresce sem quebrar o existente.

Polimorfismo por duck typing

Python usa tipagem pato: “se anda como pato, é um pato”. O tipo do objeto não importa, apenas seus métodos. Quando usar duck typing? Em código que prioriza flexibilidade. Por exemplo, funções que aceitam qualquer iterável. Assim, você obtém máxima reutilização de código. Exemplo de duck typing:

# Classes completamente independentes (sem herança comum)
class Pato:
    def falar(self):
        return "Quack quack!"
    
    def voar(self):
        return "Pato voando baixo"

class Papagaio:
    def falar(self):
        return "Olá! Quer biscoito?"
    
    def voar(self):
        return "Papagaio voando colorido"

class Cachorro:
    def falar(self):
        return "Au au!"
    
    def correr(self):
        return "Cachorro correndo"

class Carro:
    def buzinar(self):
        return "Biiiiii!"
    
    def acelerar(self):
        return "Vruum vruum"

# Função polimórfica por duck typing
def fazer_falar(animal):
    """Aceita qualquer objeto com método 'falar'."""
    # Verifica se o método existe (opcional, mas elegante)
    if hasattr(animal, 'falar'):
        print(f"{animal.__class__.__name__}: {animal.falar()}")
    else:
        print(f"{animal.__class__.__name__} não sabe falar!")

def fazer_voar(ser_voador):
    """Aceita qualquer objeto com método 'voar'."""
    if hasattr(ser_voador, 'voar'):
        print(f"{ser_voador.__class__.__name__}: {ser_voador.voar()}")
    else:
        print(f"{ser_voador.__class__.__name__} não pode voar")

print("=== Duck Typing em Ação ===\n")

animais = [Pato(), Papagaio(), Cachorro(), Carro()]

print("Fazendo falar:")
for animal in animais:
    fazer_falar(animal)

print("\nFazendo voar:")
for ser in animais:
    fazer_voar(ser)

# Exemplo com diferentes objetos que suportam len()
print("\n=== Duck Typing com len() ===")
objetos = [
    [1, 2, 3],
    "Python",
    {"a": 1, "b": 2},
    range(10)
]

for obj in objetos:
    print(f"{type(obj).__name__}: len={len(obj)}")

# Função que aceita qualquer coisa que possa ser iterada
def somar_tudo(iteravel):
    """Soma todos os números de qualquer iterável."""
    total = 0
    for item in iteravel:
        total += item
    return total

print("\nSomar tudo:")
print(f"Lista: {somar_tudo([1, 2, 3, 4])}")
print(f"Tupla: {somar_tudo((5, 6, 7))}")
print(f"Range: {somar_tudo(range(1, 6))}")

# Classes completamente independentes (sem herança comum)

class Pato:

def falar(self):

return "Quack quack!"

def voar(self):

return "Pato voando baixo"

class Papagaio:

def falar(self):

return "Olá! Quer biscoito?"

def voar(self):

return "Papagaio voando colorido"

class Cachorro:

def falar(self):

return "Au au!"

def correr(self):

return "Cachorro correndo"

class Carro:

def buzinar(self):

return "Biiiiii!"

def acelerar(self):

return "Vruum vruum"

# Função polimórfica por duck typing

def fazer_falar(animal):

"""Aceita qualquer objeto com método 'falar'."""

# Verifica se o método existe (opcional, mas elegante)

if hasattr(animal, 'falar'):

print(f"{animal.__class__.__name__}: {animal.falar()}")

else:

print(f"{animal.__class__.__name__} não sabe falar!")

def fazer_voar(ser_voador):

"""Aceita qualquer objeto com método 'voar'."""

if hasattr(ser_voador, 'voar'):

print(f"{ser_voador.__class__.__name__}: {ser_voador.voar()}")

else:

print(f"{ser_voador.__class__.__name__} não pode voar")

print("=== Duck Typing em Ação ===\n")

animais = [Pato(), Papagaio(), Cachorro(), Carro()]

print("Fazendo falar:")

for animal in animais:

fazer_falar(animal)

print("\nFazendo voar:")

for ser in animais:

fazer_voar(ser)

# Exemplo com diferentes objetos que suportam len()

print("\n=== Duck Typing com len() ===")

objetos = [

[1, 2, 3],

"Python",

{"a": 1, "b": 2},

range(10)

]

for obj in objetos:

print(f"{type(obj).__name__}: len={len(obj)}")

# Função que aceita qualquer coisa que possa ser iterada

def somar_tudo(iteravel):

"""Soma todos os números de qualquer iterável."""

total = 0

for item in iteravel:

total += item

return total

print("\nSomar tudo:")

print(f"Lista: {somar_tudo([1, 2, 3, 4])}")

print(f"Tupla: {somar_tudo((5, 6, 7))}")

print(f"Range: {somar_tudo(range(1, 6))}")

Duck typing é extremamente flexível e pythonico. Ele prioriza interfaces implícitas sobre herança explícita. Portanto, você escreve menos código com mais resultado.

Polimorfismo com métodos especiais

Métodos especiais (dunder) permitem polimorfismo nativo. Por exemplo, __add__ define o comportamento de +. Quando usar métodos especiais? Para tornar objetos mais naturais. Também para integrar seu código com a linguagem. Além disso, a legibilidade do código melhora muito. Exemplo de polimorfismo com métodos especiais:

# Classe que implementa métodos especiais
class Dinheiro:
    """Representa um valor monetário."""
    
    def __init__(self, valor, moeda="BRL"):
        self.valor = float(valor)
        self.moeda = moeda
    
    def __add__(self, outro):
        """Polimorfismo para o operador +."""
        if isinstance(outro, Dinheiro):
            if self.moeda != outro.moeda:
                raise ValueError("Moedas diferentes não podem ser somadas")
            return Dinheiro(self.valor + outro.valor, self.moeda)
        elif isinstance(outro, (int, float)):
            return Dinheiro(self.valor + outro, self.moeda)
        return NotImplemented
    
    def __sub__(self, outro):
        """Polimorfismo para o operador -."""
        if isinstance(outro, Dinheiro):
            return Dinheiro(self.valor - outro.valor, self.moeda)
        return Dinheiro(self.valor - outro, self.moeda)
    
    def __mul__(self, escalar):
        """Multiplicação por escalar."""
        if isinstance(escalar, (int, float)):
            return Dinheiro(self.valor * escalar, self.moeda)
        return NotImplemented
    
    def __rmul__(self, escalar):
        """Escalar * Dinheiro."""
        return self.__mul__(escalar)
    
    def __eq__(self, outro):
        """Comparação de igualdade."""
        if isinstance(outro, Dinheiro):
            return self.valor == outro.valor and self.moeda == outro.moeda
        return self.valor == outro
    
    def __lt__(self, outro):
        """Menor que (<)."""
        if isinstance(outro, Dinheiro):
            return self.valor < outro.valor
        return self.valor < outro
    
    def __str__(self):
        simbolos = {"BRL": "R$", "USD": "$", "EUR": "€"}
        simbolo = simbolos.get(self.moeda, self.moeda)
        return f"{simbolo}{self.valor:.2f}"
    
    def __repr__(self):
        return f"Dinheiro({self.valor}, '{self.moeda}')"

# Demonstração
print("=== Polimorfismo com Métodos Especiais ===\n")

r1 = Dinheiro(100, "BRL")
r2 = Dinheiro(50, "BRL")
r3 = Dinheiro(30, "USD")

print(f"r1 = {r1}")
print(f"r2 = {r2}")
print(f"r1 + r2 = {r1 + r2}")
print(f"r1 + 25 = {r1 + 25}")
print(f"3 * r1 = {3 * r1}")
print(f"r1 - r2 = {r1 - r2}")
print(f"r1 > r2? {r1 > r2}")
print(f"r1 == 100? {r1 == 100}")

# Exemplo com diferentes objetos que implementam métodos especiais
print("\n=== Operações Polimórficas ===")
valores = [
    Dinheiro(200, "BRL"),
    150,
    Dinheiro(75, "BRL"),
    300
]

# Soma tudo (polimorfismo puro)
total = valores[0]
for v in valores[1:]:
    total = total + v
print(f"Soma total: {total}")

# Exemplo de função que funciona com qualquer tipo que tenha __len__
def tamanho_duplicado(obj):
    """Retorna o dobro do tamanho de qualquer objeto com __len__."""
    return len(obj) * 2

print(f"\nTamanho duplicado:")
print(f"Lista: {tamanho_duplicado([1, 2, 3])}")
print(f"String: {tamanho_duplicado('Python')}")
print(f"Dict: {tamanho_duplicado({'a':1, 'b':2})}")
print(f"Dinheiro: {tamanho_duplicado(Dinheiro(100))}")  # Não tem __len__

# Classe que implementa métodos especiais

class Dinheiro:

"""Representa um valor monetário."""

def __init__(self, valor, moeda="BRL"):

self.valor = float(valor)

self.moeda = moeda

def __add__(self, outro):

"""Polimorfismo para o operador +."""

if isinstance(outro, Dinheiro):

if self.moeda != outro.moeda:

raise ValueError("Moedas diferentes não podem ser somadas")

return Dinheiro(self.valor + outro.valor, self.moeda)

elif isinstance(outro, (int, float)):

return Dinheiro(self.valor + outro, self.moeda)

return NotImplemented

def __sub__(self, outro):

"""Polimorfismo para o operador -."""

if isinstance(outro, Dinheiro):

return Dinheiro(self.valor - outro.valor, self.moeda)

return Dinheiro(self.valor - outro, self.moeda)

def __mul__(self, escalar):

"""Multiplicação por escalar."""

if isinstance(escalar, (int, float)):

return Dinheiro(self.valor * escalar, self.moeda)

return NotImplemented

def __rmul__(self, escalar):

"""Escalar * Dinheiro."""

return self.__mul__(escalar)

def __eq__(self, outro):

"""Comparação de igualdade."""

if isinstance(outro, Dinheiro):

return self.valor == outro.valor and self.moeda == outro.moeda

return self.valor == outro

def __lt__(self, outro):

"""Menor que (<)."""

if isinstance(outro, Dinheiro):

return self.valor < outro.valor

return self.valor < outro

def __str__(self):

simbolos = {"BRL": "R$", "USD": "$", "EUR": "€"}

simbolo = simbolos.get(self.moeda, self.moeda)

return f"{simbolo}{self.valor:.2f}"

def __repr__(self):

return f"Dinheiro({self.valor}, '{self.moeda}')"

# Demonstração

print("=== Polimorfismo com Métodos Especiais ===\n")

r1 = Dinheiro(100, "BRL")

r2 = Dinheiro(50, "BRL")

r3 = Dinheiro(30, "USD")

print(f"r1 = {r1}")

print(f"r2 = {r2}")

print(f"r1 + r2 = {r1 + r2}")

print(f"r1 + 25 = {r1 + 25}")

print(f"3 * r1 = {3 * r1}")

print(f"r1 - r2 = {r1 - r2}")

print(f"r1 > r2? {r1 > r2}")

print(f"r1 == 100? {r1 == 100}")

# Exemplo com diferentes objetos que implementam métodos especiais

print("\n=== Operações Polimórficas ===")

valores = [

Dinheiro(200, "BRL"),

150,

Dinheiro(75, "BRL"),

300

]

# Soma tudo (polimorfismo puro)

total = valores[0]

for v in valores[1:]:

total = total + v

print(f"Soma total: {total}")

# Exemplo de função que funciona com qualquer tipo que tenha __len__

def tamanho_duplicado(obj):

"""Retorna o dobro do tamanho de qualquer objeto com __len__."""

return len(obj) * 2

print(f"\nTamanho duplicado:")

print(f"Lista: {tamanho_duplicado([1, 2, 3])}")

print(f"String: {tamanho_duplicado('Python')}")

print(f"Dict: {tamanho_duplicado({'a':1, 'b':2})}")

print(f"Dinheiro: {tamanho_duplicado(Dinheiro(100))}") # Não tem __len__

Métodos especiais tornam seus objetos cidadãos de primeira classe. A fórmula do polimorfismo pode ser expressa assim: $P = \frac{N_{\text{tipos suportados}}}{N_{\text{código repetido}}}$ Polimorfismo reduz drasticamente a duplicação de código. Portanto, domine essa técnica para sistemas verdadeiramente flexíveis. Seu código será mais limpo, curto e elegante. Finalmente, pratique com exemplos reais do seu dia a dia.

Herança em Python

22/05/202622/04/2026 Por antonino

Herança permite criar uma nova classe a partir de uma existente. A classe filha herda atributos e métodos da classe mãe. Primeiramente, isso promove reutilização de código e hierarquias. Por exemplo, Caminhao e Moto herdam de Veiculo. Além disso, a classe filha pode sobrescrever ou adicionar novos métodos. A voz passiva é usada aqui: “os métodos são herdados automaticamente”. Quando utilizar herança? Quando há uma relação “é um” entre conceitos. Por exemplo, “Gato é um Animal” e “Cachorro é um Animal”. Python suporta herança simples (uma mãe) e múltipla (várias mães). Vamos explorar ambos os tipos com exemplos práticos. Três subtítulos guiarão você pelo universo da herança. Ao final, você dominará hierarquias de classes em Python.

Herança simples: estendendo classes

Herança simples envolve apenas uma classe mãe. Use class Filha(Mae): para declarar herança. O método super() chama o construtor da classe mãe. Quando usar herança simples? Em hierarquias lineares claras. Por exemplo, sistemas de funcionários ou formas geométricas. A voz passiva é aplicada: “os atributos são inicializados pela mãe”. Exemplo de herança simples:

# Classe base (mãe)
class Animal:
    """Classe base para todos os animais."""
    
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade
    
    def fazer_som(self):
        return "Som genérico de animal"
    
    def mover(self):
        return f"{self.nome} está se movendo"
    
    def __str__(self):
        return f"Animal: {self.nome}, {self.idade} anos"

# Classe filha (herda de Animal)
class Cachorro(Animal):
    """Cachorro herda de Animal e adiciona comportamentos específicos."""
    
    def __init__(self, nome, idade, raca):
        # Chama o construtor da classe mãe
        super().__init__(nome, idade)
        self.raca = raca
    
    # Sobrescrevendo o método da mãe (override)
    def fazer_som(self):
        return "Au au au!"
    
    # Método exclusivo da classe filha
    def abanar_rabo(self):
        return f"{self.nome} está abanando o rabo"
    
    def __str__(self):
        return f"Cachorro: {self.nome} ({self.raca}), {self.idade} anos"

class Gato(Animal):
    """Gato herda de Animal."""
    
    def __init__(self, nome, idade, cor):
        super().__init__(nome, idade)
        self.cor = cor
    
    def fazer_som(self):
        return "Miau miau!"
    
    def arranhar(self):
        return f"{self.nome} está arranhando o sofá"
    
    def __str__(self):
        return f"Gato: {self.nome} ({self.cor}), {self.idade} anos"

# Demonstração
print("=== Herança Simples ===\n")

animal = Animal("Bicho", 5)
cachorro = Cachorro("Rex", 3, "Labrador")
gato = Gato("Mimi", 2, "Branco")

print(f"Animal: {animal.fazer_som()}")
print(f"Cachorro: {cachorro.fazer_som()}")
print(f"Gato: {gato.fazer_som()}")

print(f"\n{cachorro.abanar_rabo()}")
print(f"{gato.arranhar()}")
print(f"{cachorro.mover()}")  # Método herdado

print(f"\n{animal}")
print(cachorro)
print(gato)

# Verificando tipos
print(f"\nCachorro é Animal? {isinstance(cachorro, Animal)}")
print(f"Animal é Cachorro? {isinstance(animal, Cachorro)}")
print(f"Cachorro é subclasse de Animal? {issubclass(Cachorro, Animal)}")

# Exemplo com métodos da mãe ainda disponíveis
class Passaro(Animal):
    def __init__(self, nome, idade, envergadura):
        super().__init__(nome, idade)
        self.envergadura = envergadura
    
    # Não sobrescreve fazer_som, usa o da mãe
    def voar(self):
        return f"{self.nome} está voando com envergadura de {self.envergadura}cm"

passaro = Passaro("Piu", 1, 25)
print(f"\nPássaro: {passaro.fazer_som()}")  # Usa método da mãe
print(passaro.voar())

# Classe base (mãe)

class Animal:

"""Classe base para todos os animais."""

def __init__(self, nome, idade):

self.nome = nome

self.idade = idade

def fazer_som(self):

return "Som genérico de animal"

def mover(self):

return f"{self.nome} está se movendo"

def __str__(self):

return f"Animal: {self.nome}, {self.idade} anos"

# Classe filha (herda de Animal)

class Cachorro(Animal):

"""Cachorro herda de Animal e adiciona comportamentos específicos."""

def __init__(self, nome, idade, raca):

# Chama o construtor da classe mãe

super().__init__(nome, idade)

self.raca = raca

# Sobrescrevendo o método da mãe (override)

def fazer_som(self):

return "Au au au!"

# Método exclusivo da classe filha

def abanar_rabo(self):

return f"{self.nome} está abanando o rabo"

def __str__(self):

return f"Cachorro: {self.nome} ({self.raca}), {self.idade} anos"

class Gato(Animal):

"""Gato herda de Animal."""

def __init__(self, nome, idade, cor):

super().__init__(nome, idade)

self.cor = cor

def fazer_som(self):

return "Miau miau!"

def arranhar(self):

return f"{self.nome} está arranhando o sofá"

def __str__(self):

return f"Gato: {self.nome} ({self.cor}), {self.idade} anos"

# Demonstração

print("=== Herança Simples ===\n")

animal = Animal("Bicho", 5)

cachorro = Cachorro("Rex", 3, "Labrador")

gato = Gato("Mimi", 2, "Branco")

print(f"Animal: {animal.fazer_som()}")

print(f"Cachorro: {cachorro.fazer_som()}")

print(f"Gato: {gato.fazer_som()}")

print(f"\n{cachorro.abanar_rabo()}")

print(f"{gato.arranhar()}")

print(f"{cachorro.mover()}") # Método herdado

print(f"\n{animal}")

print(cachorro)

print(gato)

# Verificando tipos

print(f"\nCachorro é Animal? {isinstance(cachorro, Animal)}")

print(f"Animal é Cachorro? {isinstance(animal, Cachorro)}")

print(f"Cachorro é subclasse de Animal? {issubclass(Cachorro, Animal)}")

# Exemplo com métodos da mãe ainda disponíveis

class Passaro(Animal):

def __init__(self, nome, idade, envergadura):

super().__init__(nome, idade)

self.envergadura = envergadura

# Não sobrescreve fazer_som, usa o da mãe

def voar(self):

return f"{self.nome} está voando com envergadura de {self.envergadura}cm"

passaro = Passaro("Piu", 1, 25)

print(f"\nPássaro: {passaro.fazer_som()}") # Usa método da mãe

print(passaro.voar())

A classe filha herda tudo que não foi sobrescrito. super() é essencial para inicializar corretamente a mãe.

Herança múltipla: combinando comportamentos

Herança múltipla permite uma classe herdar de várias mães. Use class Filha(Mae1, Mae2): para declarar. Python usa o MRO (Method Resolution Order) para resolver conflitos. Quando usar herança múltipla? Em mixins e interfaces. Por exemplo, combinando comportamentos como “Voador” e “Nadador”. A voz passiva é aplicada: “as classes são pesquisadas em ordem específica”. Exemplo de herança múltipla:

# Classes base (mixins)
class Voador:
    """Mixin para seres que voam."""
    
    def __init__(self, altitude_maxima=100):
        self.altitude_maxima = altitude_maxima
    
    def voar(self):
        return f"Voando até {self.altitude_maxima} metros"
    
    def planar(self):
        return "Planando suavemente"

class Nadador:
    """Mixin para seres que nadam."""
    
    def __init__(self, profundidade_maxima=50):
        self.profundidade_maxima = profundidade_maxima
    
    def nadar(self):
        return f"Nadando até {self.profundidade_maxima} metros"
    
    def mergulhar(self):
        return "Mergulhando profundamente"

class Corredor:
    """Mixin para seres que correm."""
    
    def __init__(self, velocidade_maxima=30):
        self.velocidade_maxima = velocidade_maxima
    
    def correr(self):
        return f"Correndo a {self.velocidade_maxima} km/h"
    
    def acelerar(self):
        return "Acelerando rapidamente"

# Classe que combina múltiplas habilidades
class Pato(Voador, Nadador, Corredor):
    """Pato herda de Voador, Nadador e Corredor."""
    
    def __init__(self, nome, altitude=100, profundidade=50, velocidade=20):
        # Inicializa todos os mixins
        Voador.__init__(self, altitude)
        Nadador.__init__(self, profundidade)
        Corredor.__init__(self, velocidade)
        self.nome = nome
    
    def fazer_som(self):
        return "Quack quack!"
    
    def __str__(self):
        return f"Pato: {self.nome}"

# Demonstração
print("\n=== Herança Múltipla ===\n")

pato = Pato("Donald", altitude=80, profundidade=30, velocidade=15)

print(f"{pato}")
print(f"{pato.fazer_som()}")
print(f"{pato.voar()}")
print(f"{pato.planar()}")
print(f"{pato.nadar()}")
print(f"{pato.mergulhar()}")
print(f"{pato.correr()}")
print(f"{pato.acelerar()}")

# Exemplo de mixins em sistemas de arquivos
class Serializable:
    """Mixin para serialização."""
    
    def to_dict(self):
        return {k: v for k, v in self.__dict__.items()}
    
    def to_json(self):
        import json
        return json.dumps(self.to_dict())

class Loggable:
    """Mixin para logging."""
    
    def log(self, mensagem):
        print(f"[LOG] {self.__class__.__name__}: {mensagem}")

class Personagem(Serializable, Loggable):
    """Personagem com habilidades de serialização e log."""
    
    def __init__(self, nome, nivel):
        self.nome = nome
        self.nivel = nivel
    
    def subir_nivel(self):
        self.nivel += 1
        self.log(f"Subiu para nível {self.nivel}")

print("\n=== Mixins em Ação ===")
personagem = Personagem("Aragorn", 10)
personagem.subir_nivel()
print(f"Personagem em JSON: {personagem.to_json()}")

# Demonstração do MRO (Method Resolution Order)
print(f"\nMRO do Pato: {[c.__name__ for c in Pato.__mro__]}")

100

101

102

103

# Classes base (mixins)

class Voador:

"""Mixin para seres que voam."""

def __init__(self, altitude_maxima=100):

self.altitude_maxima = altitude_maxima

def voar(self):

return f"Voando até {self.altitude_maxima} metros"

def planar(self):

return "Planando suavemente"

class Nadador:

"""Mixin para seres que nadam."""

def __init__(self, profundidade_maxima=50):

self.profundidade_maxima = profundidade_maxima

def nadar(self):

return f"Nadando até {self.profundidade_maxima} metros"

def mergulhar(self):

return "Mergulhando profundamente"

class Corredor:

"""Mixin para seres que correm."""

def __init__(self, velocidade_maxima=30):

self.velocidade_maxima = velocidade_maxima

def correr(self):

return f"Correndo a {self.velocidade_maxima} km/h"

def acelerar(self):

return "Acelerando rapidamente"

# Classe que combina múltiplas habilidades

class Pato(Voador, Nadador, Corredor):

"""Pato herda de Voador, Nadador e Corredor."""

def __init__(self, nome, altitude=100, profundidade=50, velocidade=20):

# Inicializa todos os mixins

Voador.__init__(self, altitude)

Nadador.__init__(self, profundidade)

Corredor.__init__(self, velocidade)

self.nome = nome

def fazer_som(self):

return "Quack quack!"

def __str__(self):

return f"Pato: {self.nome}"

# Demonstração

print("\n=== Herança Múltipla ===\n")

pato = Pato("Donald", altitude=80, profundidade=30, velocidade=15)

print(f"{pato}")

print(f"{pato.fazer_som()}")

print(f"{pato.voar()}")

print(f"{pato.planar()}")

print(f"{pato.nadar()}")

print(f"{pato.mergulhar()}")

print(f"{pato.correr()}")

print(f"{pato.acelerar()}")

# Exemplo de mixins em sistemas de arquivos

class Serializable:

"""Mixin para serialização."""

def to_dict(self):

return {k: v for k, v in self.__dict__.items()}

def to_json(self):

import json

return json.dumps(self.to_dict())

class Loggable:

"""Mixin para logging."""

def log(self, mensagem):

print(f"[LOG] {self.__class__.__name__}: {mensagem}")

class Personagem(Serializable, Loggable):

"""Personagem com habilidades de serialização e log."""

def __init__(self, nome, nivel):

self.nome = nome

self.nivel = nivel

def subir_nivel(self):

self.nivel += 1

self.log(f"Subiu para nível {self.nivel}")

print("\n=== Mixins em Ação ===")

personagem = Personagem("Aragorn", 10)

personagem.subir_nivel()

print(f"Personagem em JSON: {personagem.to_json()}")

# Demonstração do MRO (Method Resolution Order)

print(f"\nMRO do Pato: {[c.__name__ for c in Pato.__mro__]}")

Herança múltipla é poderosa, mas use com moderação. Mixins são classes pequenas que adicionam comportamentos específicos.

Sobrescrita e super() em herança múltipla

super() funciona de forma especial em herança múltipla. Ele segue o MRO para chamar o próximo método na hierarquia. Isso permite que todos os pais sejam inicializados corretamente. Quando usar super()? Em praticamente todos os construtores. Também em métodos que querem estender (não substituir) o comportamento. A voz passiva é aplicada: “as chamadas são delegadas ao próximo na MRO”. Exemplo de super() em herança múltipla:

# Demonstração do fluxo de super()
class A:
    def __init__(self):
        print("Inicializando A")
        self.valor_a = "A"
    
    def metodo(self):
        print("Método de A")
        return "A"

class B:
    def __init__(self):
        print("Inicializando B")
        self.valor_b = "B"
    
    def metodo(self):
        print("Método de B")
        return "B"

class C(A, B):
    def __init__(self):
        print("Iniciando C")
        super().__init__()  # Chama o próximo no MRO (A)
        # A já inicializou, agora precisamos inicializar B manualmente?
        # Na verdade, A não chama B. Por isso, usamos super() em todas.
        print("C inicializado")
    
    def metodo(self):
        print("Início do método de C")
        resultado = super().metodo()  # Chama A.metodo
        print(f"Resultado de super(): {resultado}")
        return "C modificado"

# Classe bem comportada (todos usam super)
class BomA:
    def __init__(self):
        print("BomA iniciando")
        super().__init__()
        self.valor_a = "BomA"
    
    def metodo(self):
        print("BomA.metodo")
        return super().metodo() if hasattr(super(), 'metodo') else "A"

class BomB:
    def __init__(self):
        print("BomB iniciando")
        super().__init__()
        self.valor_b = "BomB"
    
    def metodo(self):
        print("BomB.metodo")
        return super().metodo() if hasattr(super(), 'metodo') else "B"

class BomC(BomA, BomB):
    def __init__(self):
        print("BomC iniciando")
        super().__init__()
        print("BomC finalizado")
    
    def metodo(self):
        print("BomC.metodo")
        return super().metodo()

print("=== Comportamento sem super() adequada ===")
c = C()
print(c.metodo())

print("\n=== Comportamento com super() adequada ===")
bom_c = BomC()
print(bom_c.metodo())
print(f"Valores: {bom_c.valor_a}, {bom_c.valor_b}")

# Exemplo prático: logger com timestamp
class TimestampMixin:
    """Adiciona timestamp às mensagens."""
    
    def log(self, mensagem):
        from datetime import datetime
        timestamp = datetime.now().strftime("%H:%M:%S")
        return super().log(f"[{timestamp}] {mensagem}") if hasattr(super(), 'log') else print(f"[{timestamp}] {mensagem}")

class FileLogger:
    """Logger que escreve em arquivo."""
    
    def __init__(self, arquivo="log.txt"):
        self.arquivo = arquivo
    
    def log(self, mensagem):
        with open(self.arquivo, "a") as f:
            f.write(f"{mensagem}\n")
        return mensagem

class ConsoleLogger:
    """Logger que escreve no console."""
    
    def log(self, mensagem):
        print(f"CONSOLE: {mensagem}")
        return mensagem

# Combinando mixins
class TimestampFileLogger(TimestampMixin, FileLogger):
    pass

class TimestampConsoleLogger(TimestampMixin, ConsoleLogger):
    pass

print("\n=== Logger com Timestamp ===")
logger = TimestampFileLogger("meu_log.txt")
logger.log("Mensagem de teste")

logger2 = TimestampConsoleLogger()
logger2.log("Mensagem no console")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

# Demonstração do fluxo de super()

class A:

def __init__(self):

print("Inicializando A")

self.valor_a = "A"

def metodo(self):

print("Método de A")

return "A"

class B:

def __init__(self):

print("Inicializando B")

self.valor_b = "B"

def metodo(self):

print("Método de B")

return "B"

class C(A, B):

def __init__(self):

print("Iniciando C")

super().__init__() # Chama o próximo no MRO (A)

# A já inicializou, agora precisamos inicializar B manualmente?

# Na verdade, A não chama B. Por isso, usamos super() em todas.

print("C inicializado")

def metodo(self):

print("Início do método de C")

resultado = super().metodo() # Chama A.metodo

print(f"Resultado de super(): {resultado}")

return "C modificado"

# Classe bem comportada (todos usam super)

class BomA:

def __init__(self):

print("BomA iniciando")

super().__init__()

self.valor_a = "BomA"

def metodo(self):

print("BomA.metodo")

return super().metodo() if hasattr(super(), 'metodo') else "A"

class BomB:

def __init__(self):

print("BomB iniciando")

super().__init__()

self.valor_b = "BomB"

def metodo(self):

print("BomB.metodo")

return super().metodo() if hasattr(super(), 'metodo') else "B"

class BomC(BomA, BomB):

def __init__(self):

print("BomC iniciando")

super().__init__()

print("BomC finalizado")

def metodo(self):

print("BomC.metodo")

return super().metodo()

print("=== Comportamento sem super() adequada ===")

c = C()

print(c.metodo())

print("\n=== Comportamento com super() adequada ===")

bom_c = BomC()

print(bom_c.metodo())

print(f"Valores: {bom_c.valor_a}, {bom_c.valor_b}")

# Exemplo prático: logger com timestamp

class TimestampMixin:

"""Adiciona timestamp às mensagens."""

def log(self, mensagem):

from datetime import datetime

timestamp = datetime.now().strftime("%H:%M:%S")

return super().log(f"[{timestamp}] {mensagem}") if hasattr(super(), 'log') else print(f"[{timestamp}] {mensagem}")

class FileLogger:

"""Logger que escreve em arquivo."""

def __init__(self, arquivo="log.txt"):

self.arquivo = arquivo

def log(self, mensagem):

with open(self.arquivo, "a") as f:

f.write(f"{mensagem}\n")

return mensagem

class ConsoleLogger:

"""Logger que escreve no console."""

def log(self, mensagem):

print(f"CONSOLE: {mensagem}")

return mensagem

# Combinando mixins

class TimestampFileLogger(TimestampMixin, FileLogger):

pass

class TimestampConsoleLogger(TimestampMixin, ConsoleLogger):

pass

print("\n=== Logger com Timestamp ===")

logger = TimestampFileLogger("meu_log.txt")

logger.log("Mensagem de teste")

logger2 = TimestampConsoleLogger()

logger2.log("Mensagem no console")

A fórmula do MRO para herança múltipla: $\text{MRO}(C(B_1, B_2, …, B_n)) = [C] + \text{merge}(\text{MRO}(B_1), …, \text{MRO}(B_n), [B_1, …, B_n])$ Herança é uma ferramenta poderosa quando usada com sabedoria. Prefira composição sobre herança em casos duvidosos. Use herança para relações “é um” genuínas. Seu código será mais limpo e manutenível.