Python Academy · Aula

Polimorfismo e tipagem pato

Escreva código polimórfico que funcione com qualquer objeto compatível.

Polimorfismo e tipagem pato é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

Introdução

O polimorfismo permite que objetos diferentes respondam à mesma interface. Tipagem pato significa: se ele se comporta como um pato, então é um pato.

O que é polimorfismo?

Polimorfismo significa “muitas formas”. O mesmo nome de método funciona de maneiras diferentes em objetos diferentes. O Python adota esse conceito amplamente.

class Cat:
    def speak(self): return 'Meow'
class Dog:
    def speak(self): return 'Woof'
for animal in [Cat(), Dog()]:
    print(animal.speak())

Tipagem pato

O Python não exige uma hierarquia de classes para o polimorfismo. Se um objeto tiver o método correto, ele funcionará. Não há necessidade de interfaces.

class Duck:
    def quack(self): return 'Quack'
class Person:
    def quack(self): return 'I am quacking like a duck'
def make_it_quack(duck):
    print(duck.quack())
make_it_quack(Duck())
make_it_quack(Person())

Funções polimórficas

len() funciona com strings, listas, dicionários e tuplas — tudo porque eles implementam __len__. Esse é um polimorfismo integrado.

for obj in ['hello', [1,2,3], {'a':1}]:
    print(type(obj).__name__, len(obj))

Sobrecarga de operadores

+ funciona com inteiros, números de ponto flutuante, strings e listas porque cada tipo implementa __add__ de uma maneira diferente.

print(1 + 2)        # int addition
print('a' + 'b')    # string concat
print([1] + [2])    # list concat

Tipagem pato baseada em protocolo

O protocolo de iteração: qualquer objeto com __iter__ e __next__ funciona em laços for — nenhuma classe-base é necessária.

class Squares:
    def __init__(self, n): self.n,self.i=n,0
    def __iter__(self): return self
    def __next__(self):
        if self.i>=self.n: raise StopIteration
        x=self.i**2; self.i+=1; return x
print(list(Squares(5)))

EAFP vs LBYL

EAFP (é mais fácil pedir perdão do que permissão) usa try/except. LBYL (observe antes de agir) usa if/hasattr. O Python favorece EAFP.

# LBYL:
if hasattr(obj, 'quack'):
    obj.quack()
# EAFP (Pythonic):
try:
    'hello'.quack()
except AttributeError:
    print('no quack')

isinstance() para despacho seguro

Quando você precisa de um comportamento específico para cada tipo, isinstance() é mais organizado do que capturar AttributeError.

def process(data):
    if isinstance(data, str):
        return data.upper()
    elif isinstance(data, list):
        return [x*2 for x in data]
print(process('hi'))
print(process([1,2,3]))

Classes-base abstratas como protocolos

from abc import ABC, abstractmethod define protocolos formais. As subclasses precisam implementar os métodos abstratos.

from abc import ABC, abstractmethod
class Drawable(ABC):
    @abstractmethod
    def draw(self): pass
class Circle(Drawable):
    def draw(self): print('O')
Circle().draw()

typing.Protocol (3.8+)

class MyProtocol(Protocol): define uma subtipagem estrutural sem ABC. Funciona com mypy para verificações estáticas.

from typing import Protocol
class Quackable(Protocol):
    def quack(self) -> str: ...
def make_quack(x: Quackable) -> str:
    return x.quack()
print('protocol demo')

Polimorfismo na prática

Projete APIs que aceitem qualquer objeto com a interface correta. Isso torna seu código extensível sem modificações.

class JSONSerializer:
    def serialize(self, obj): import json; return json.dumps(obj)
class XMLSerializer:
    def serialize(self, obj): return f'<data>{obj}</data>'
def export(data, serializer):
    return serializer.serialize(data)
print(export({'x': 1}, JSONSerializer()))

Verificação rápida

O que significa tipagem pato em Python?

Recapitulação

Polimorfismo: mesma interface, comportamento diferente. Tipagem pato: o comportamento importa, não o tipo. Protocolos definem interfaces informalmente. EAFP (try/except) é idiomático em Python.

Continue

Excelente progresso! Continue para dominar o próximo conceito.

Perguntas Frequentes

A aula “Polimorfismo e tipagem pato” é grátis?

Sim — o texto completo de “Polimorfismo e tipagem pato” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Polimorfismo e tipagem pato”?

Escreva código polimórfico que funcione com qualquer objeto compatível. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Polimorfismo e tipagem pato”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Python Academy