Polimorfismo na prática

Uma lista de tipos diferentes

Você já viu cada filha sobrescrever falar do seu jeito. O ganho fica evidente quando junta objetos de tipos diferentes numa mesma coleção. Imagine uma lista com um cachorro, um gato e uma vaca. Todos são animais, todos entendem falar, mas cada um responde diferente. Com um laço simples, você pede a todos que falem, e o Python escolhe a versão certa para cada um. O seu código não pergunta quem é quem; ele confia que todo item da lista sabe falar. Essa é a cara do polimorfismo no dia a dia.

class Animal:
    def __init__(self, nome):
        self.nome = nome
    def falar(self):
        return f"{self.nome} faz um som."

class Cachorro(Animal):
    def falar(self):
        return f"{self.nome} faz au au!"

class Gato(Animal):
    def falar(self):
        return f"{self.nome} faz miau!"

class Vaca(Animal):
    def falar(self):
        return f"{self.nome} faz muuu!"

bicharada = [Cachorro("Rex"), Gato("Felix"), Vaca("Mimosa")]
for bicho in bicharada:
    print(bicho.falar())
# Rex faz au au!
# Felix faz miau!
# Mimosa faz muuu!

Um laço, três tipos, três comportamentos: o polimorfismo em ação.

Olhe o laço: ele tem uma linha útil, bicho.falar(). Não há nenhum if perguntando o tipo, nenhuma verificação. Ainda assim, cada bicho fala do seu jeito, porque cada classe sobrescreveu falar. É o Python, na hora da chamada, que resolve qual versão usar, seguindo aquela busca da filha para a base. Compare com o que seria preciso sem polimorfismo, e a diferença de clareza fica gritante.

O que evitamos: a cadeia de if

Sem polimorfismo, a mesma tarefa vira uma cadeia de condições que checa o tipo de cada objeto e decide o som. Funciona, mas envelhece mal. Cada novo animal exige mais um ramo no if, e essa lógica costuma se espalhar por vários pontos do programa, todos precisando ser atualizados juntos. Esquecer um deles cria bugs silenciosos. O trecho abaixo mostra o caminho ruim, só para contraste; ele faz o mesmo que o laço anterior, com muito mais atrito.

def som_ruim(bicho):
    # anti-exemplo: checa o tipo na unha
    if isinstance(bicho, Cachorro):
        return f"{bicho.nome} faz au au!"
    elif isinstance(bicho, Gato):
        return f"{bicho.nome} faz miau!"
    elif isinstance(bicho, Vaca):
        return f"{bicho.nome} faz muuu!"
    return f"{bicho.nome} faz um som."

# Cada animal novo exige mais um elif aqui, e em todo lugar parecido.

O anti-exemplo: cadeia de if por tipo, que cresce a cada animal novo.

Extensível quase de graça

A prova real do polimorfismo é adicionar um tipo novo e ver o que muda no código que já existia. Com o laço polimórfico, a resposta é: nada muda. Você cria a classe Pato, sobrescreve falar e a coloca na lista. O laço que percorre a bicharada continua idêntico e já sabe fazer o pato falar, porque ele só chama falar e confia. É o oposto da cadeia de if, onde cada tipo novo obrigaria a caçar e alterar todos os pontos que decidem o som.

class Pato(Animal):
    def falar(self):
        return f"{self.nome} faz quá quá!"

bicharada = [Cachorro("Rex"), Gato("Felix"), Pato("Donald")]
for bicho in bicharada:
    print(bicho.falar())
# Rex faz au au!
# Felix faz miau!
# Donald faz quá quá!  (o laço não mudou nada)

O tipo novo Pato entra na lista e o laço já o trata, sem uma linha alterada.