O que é polimorfismo?

Em Python, len("hello") devolve 5, len([4, 8, 15]) devolve 3 e len({"a": 1}) devolve 1. É um único nome de função usado com três tipos, e cada tipo conta do seu jeito: uma string conta caracteres, uma lista conta itens, um dicionário conta chaves. A palavra vem do grego: poly, muitos, e morph, forma. Uma chamada, muitas formas de comportamento.

Como o polimorfismo funciona

O código chama um método pelo nome, como shape.area(). Quando essa linha executa, a linguagem olha o objeto real e encontra area na própria classe do objeto. Essa busca se chama despacho dinâmico (dynamic dispatch), e é ela que permite que uma única linha faça um trabalho diferente para objetos diferentes:

import math

class Shape:
    def area(self):
        raise NotImplementedError

class Circle(Shape):
    def __init__(self, r):
        self.r = r
    def area(self):
        return math.pi * self.r ** 2

class Square(Shape):
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

shapes = [Circle(1), Square(3), Circle(2)]
for shape in shapes:
    # One line of code, a different area() for each type
    print(type(shape).__name__, round(shape.area(), 2))

Circle 3.14
Square 9
Circle 12.57

O Python encontra o método procurando primeiro na classe do objeto e depois nas classes pai, em uma ordem fixa chamada ordem de resolução de métodos (MRO). Se Square não tivesse o próprio area(), a busca chegaria a Shape.area() e lançaria NotImplementedError, um sinal de que toda subclasse precisa fornecer o seu.

O loop nunca verifica que tipo de forma ele tem. Para acrescentar um triângulo, você escreve uma classe Triangle com o próprio area(), e o loop funciona sem mudanças. Sem polimorfismo, o loop precisaria de um ramo if isinstance(...) para cada forma, editado toda vez que surgisse uma nova.

Tipos de polimorfismo

Quando as pessoas dizem "polimorfismo" em programação orientada a objetos sem mais detalhes, quase sempre querem dizer a primeira linha: polimorfismo de subtipo por meio de sobrescrita.

O Python tem os três, do seu jeito. A sobrescrita funciona como no exemplo das formas. Operadores como + são polimorfismo ad hoc. Funções como max() e sorted() são paramétricas no espírito: aceitam uma lista de números, strings ou datas, desde que os itens possam ser comparados, e anotações de tipo como list[int] ou um TypeVar podem deixar isso explícito.

Polimorfismo em tempo de compilação e em tempo de execução em Java

O Java tem os dois tipos, e perguntas de entrevista costumam pedir a diferença:

class Animal { String sound() { return "..."; } }
class Dog extends Animal {
    @Override String sound() { return "Woof"; }
}

Animal pet = new Dog();
pet.sound();          // "Woof": chosen at run time from the object

int add(int a, int b)          { return a + b; }
double add(double a, double b) { return a + b; }
add(2, 3);            // int version, chosen by the compiler
add(2.5, 1.0);        // double version

A variável pet tem o tipo Animal, mas é a versão de Dog que executa, porque a escolha depende do objeto, não da variável. Os dois métodos add são sobrecarga: o compilador escolhe um pelos tipos dos argumentos antes de o programa executar. As interfaces dão o mesmo comportamento em tempo de execução sem compartilhar código: qualquer classe que implementa Comparable pode ser ordenada por Collections.sort. O C++ funciona do mesmo jeito, com uma diferença: um método só tem despacho em tempo de execução se for declarado virtual. Veja polimorfismo em Java, sobrecarga de métodos e funções virtuais em C++.

Polimorfismo em Python: duck typing e operadores

O Python não exige uma classe pai em comum. Se um objeto tem o método que o código chama, funciona: "se anda como um pato e grasna como um pato, é um pato". Os operadores também são polimórficos. Escrever a + b chama a.__add__(b), então as suas próprias classes podem suportar +, len() e print():

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __add__(self, other):          # called for v1 + v2
        return Vector(self.x + other.x, self.y + other.y)
    def __len__(self):                 # called for len(v)
        return 2
    def __repr__(self):                # called by print()
        return f"Vector({self.x}, {self.y})"

print(1 + 2, "ab" + "cd", [1] + [2])   # built-in types
print(Vector(1, 2) + Vector(10, 20))    # your own type
print(len("hello"), len([1, 2, 3]), len(Vector(0, 0)))

3 abcd [1, 2]
Vector(11, 22)
5 3 2

A herança é uma forma de obter polimorfismo, não um requisito. Vector não herda de nada especial, mas len() e + o tratam como um tipo nativo. A documentação de herança em Python mostra o caminho das subclasses.

Erros comuns

Esperar que o Python faça sobrecarga pela assinatura. Um segundo def com o mesmo nome substitui o primeiro em silêncio:

def greet(name):
    return "Hi " + name

def greet(first, last):          # replaces the first greet
    return "Hi " + first + " " + last

print(greet("Ana", "Silva"))
print(greet("Ana"))

Hi Ana Silva
Traceback (most recent call last):
  ...
TypeError: greet() missing 1 required positional argument: 'last'

Use um argumento padrão no lugar: def greet(first, last="").

Esquecer o virtual em C++. Sem ele, chamar um método por um ponteiro para a classe base executa a versão da base, mesmo quando o objeto é de uma subclasse.

Sobrescritas que mudam o significado. Se area() em uma subclasse devolve o perímetro, todo código que confia em area() quebra. Uma sobrescrita precisa cumprir a promessa que o pai fez; essa regra é conhecida como princípio da substituição de Liskov.

Verificações de tipo por toda parte. Uma cadeia de ramos if type(x) == ... costuma ser sinal de que cada tipo deveria ter o próprio método.

Próximos passos

O polimorfismo trabalha junto com o encapsulamento, que protege os dados de cada objeto, e com a abstração, que define a interface comum que os tipos implementam. Pratique a sobrescrita na documentação de classes em Python, ou experimente o curso de Java, onde sobrecarga e sobrescrita aparecem lado a lado.