Duck Typing

Parte da seção Object Oriented Programming do Journey de Python da Coddy — lição 24 de 64.

Duck typing foca no que um objeto pode fazer, não no que ele é. Se um objeto tem os métodos que você precisa, você pode usá-lo - independentemente do seu tipo de classe.

Aqui estão duas classes não relacionadas com os mesmos métodos:

class Duck:
    def swim(self):
        return "Duck swimming"
    
    def quack(self):
        return "Quack!"

class Person:
    def swim(self):
        return "Person swimming"
    
    def quack(self):
        return "Person imitating a duck: Quack!"

Observe que Duck e Person não herdam da mesma classe pai, mas ambos possuem os métodos swim() e quack().

Crie uma função que funcione com qualquer objeto "tipo pato":

def make_it_swim_and_quack(duck_like_object):
    print(duck_like_object.swim())
    print(duck_like_object.quack())

Esta função não se importa com o tipo do objeto - ela apenas se importa que o objeto tenha os métodos necessários.

Use a função com ambas as classes:

make_it_swim_and_quack(Duck())
make_it_swim_and_quack(Person())

Saída:

Duck swimming
Quack!
Person swimming
Person imitating a duck: Quack!

Adicione outra classe "tipo pato":

class Robot:
    def swim(self):
        return "Robot swimming with propellers"
    
    def quack(self):
        return "Robot sound: BEEP BEEP!"

make_it_swim_and_quack(Robot())

Saída:

Robot swimming with propellers
Robot sound: BEEP BEEP!

Ponto-chave: Duck typing permite polimorfismo sem herança. Se um objeto possui os métodos de que você precisa, você pode usá-lo. Isso torna o código Python flexível e segue o princípio "é mais fácil pedir perdão do que permissão".

Desafio

Médio

Neste desafio, você implementará um sistema demonstrando duck typing com diferentes objetos do tipo arquivo:

textfile.py: Implemente a classe TextFile com os métodos read() e write(data)
database.py: Implemente a classe Database com assinaturas de método correspondentes
networkresource.py: Implemente a classe NetworkResource com assinaturas de método correspondentes
driver.py - Implemente casos de teste que verificarão se sua implementação funciona corretamente

Cada arquivo contém comentários TODO detalhados orientando sua implementação.

Folha de consulta

Duck typing foca no que um objeto pode fazer, não no que ele é. Se um objeto possui os métodos que você precisa, você pode usá-lo independentemente do seu tipo de classe.

Exemplo de duck typing com classes não relacionadas que compartilham os mesmos métodos:

class Duck:
    def swim(self):
        return "Duck swimming"
    
    def quack(self):
        return "Quack!"

class Person:
    def swim(self):
        return "Person swimming"
    
    def quack(self):
        return "Person imitating a duck: Quack!"

Crie uma função que funcione com qualquer objeto "tipo pato" (duck-like):

def make_it_swim_and_quack(duck_like_object):
    print(duck_like_object.swim())
    print(duck_like_object.quack())

# Works with any object that has swim() and quack() methods
make_it_swim_and_quack(Duck())
make_it_swim_and_quack(Person())

Duck typing permite polimorfismo sem herança - se um objeto tem os métodos que você precisa, você pode usá-lo. Isso torna o código Python flexível e segue o princípio "é mais fácil pedir perdão do que permissão".

Experimente você mesmo

# TODO: Importar a classe TextFile de textfile.py
# TODO: Importar a classe Database de database.py
# TODO: Importar a classe NetworkResource de networkresource.py

def process_data(data_source, data):
    # TODO: Chamar o método read() em data_source e imprimir o resultado
    # TODO: Chamar o método write(data) em data_source e imprimir o resultado
    pass


# Test with different data sources - DO NOT MODIFY THIS TEST CODE
text_file = TextFile()
database = Database()
network = NetworkResource()

print("Processing text file:")
process_data(text_file, "Hello, world!")

print("\
Processing database:")
process_data(database, "User record")

print("\
Processing network resource:")
process_data(network, "GET request")