Duck Typing and Polymorphism

What is Polymorphism and Duck Typing?

Polymorphism comes from the Greek words for "many shapes." In programming, it means that a single interface (like a function or a method call) can work with objects of different types, and each object will respond in its own specific way.

Python implements polymorphism through a concept called duck typing. The name comes from the saying:

"If it walks like a duck and it quacks like a duck, then it must be a duck."

In Python terms, this means we don't care about an object's specific class or type. We only care about what it can do—that is, what methods and attributes it has. If a function needs an object that can .fly() and .swim(), it will work with any object that provides those methods, regardless of whether it's a Duck, a Swan, or a remote-controlled Drone.

To see a practical demonstration, let's watch the first part of this excellent tutorial from Corey Schafer.

As the video shows, the Pythonic way is not to ask "Is this object a Duck?" but rather to assume it can do what we need. This leads to more flexible and less restrictive code.

For someone with your Computer Science background, it's useful to contrast this with statically typed languages (like Java or C#). In those languages, type compatibility is checked at compile-time. Python, being a dynamically typed language, performs these checks at run-time, which is what makes duck typing possible. The emphasis is on the object's behavior, not its declared type.

Handling Potential Errors: EAFP

You might be thinking, "What happens if I pass an object that can't quack?" This is a valid concern. Just trying to call a method on an object that doesn't have it will raise an AttributeError.

The non-Pythonic way to handle this is called "Look Before You Leap" (LBYL). You would explicitly check if the object has the method before calling it:

# LBYL: Look Before You Leap (less Pythonic)
if hasattr(thing, 'quack'):
    thing.quack()

The preferred Pythonic style is "Easier to Ask for Forgiveness than Permission" (EAFP). This means you go ahead and try the operation, and if it fails, you catch the exception and handle it.

# EAFP: Easier to Ask Forgiveness than Permission (more Pythonic)
try:
    thing.quack()
except AttributeError:
    print("This object can't quack.")

Let's continue with Corey Schafer's video, where he explains this principle perfectly.

EAFP is generally favored in Python because it's more optimistic and often more readable, especially when you need to perform several operations. It avoids cluttering your code with checks and focuses on the "happy path" first.

def process_data(items):
    results = []
    for item in items:
        try:
            # First, try to call the .to_json() method
            results.append(item.to_json())
        except AttributeError:
            # If it fails, ask for forgiveness and use str()
            results.append(str(item))
    return results

# Example Usage:
class User:
    def __init__(self, name):
        self.name = name
    def to_json(self):
        return f'{{"name": "{self.name}"}}'

class Product:
    def __init__(self, product_id):
        self.product_id = product_id
    def __str__(self):
        return f"Product ID: {self.product_id}"

data_list = [User("Alice"), Product(123), User("Bob")]
processed = process_data(data_list)
print(processed)
# Expected Output: ['{"name": "Alice"}', 'Product ID: 123', '{"name": "Bob"}']

Duck Typing and Python's "Protocols"

One of the most powerful aspects of duck typing is how it integrates custom classes with Python's built-in functions. How does Python's len() function know the length of a string, a list, and a dictionary? It uses duck typing!

When you call len(my_object), Python looks for a special method on that object called __len__. If it finds it, it calls it. This informal requirement—having a __len__ method to work with len()—is called a protocol.

By implementing these special "dunder" (double-underscore) methods, you can make your own objects compatible with Python's syntax and functions, making them feel like native types.

A Practical Application: From Math to Machine Learning

Duck typing is especially powerful in numerical and scientific computing. You can write an algorithm for one type of number (e.g., a standard float), and thanks to duck typing, it can often work on entirely different data structures, like NumPy arrays, without any modification.

The following resource illustrates this with the Newton-Raphson method for finding roots of an equation. The code is written to work with simple numbers but is then applied to NumPy arrays of complex numbers to generate a fractal, and it works perfectly. This is a direct consequence of duck typing and is highly relevant to your goal of working with ML, where NumPy is a cornerstone.

Hands-on Practice: The Media Player

Now it's time to apply these concepts yourself. This exercise will challenge you to build a small system that uses polymorphism both through traditional inheritance and through pure duck typing.

Conclusion

In this lesson, you've explored polymorphism, one of the pillars of OOP, and learned about Python's powerful and flexible implementation of it: duck typing.

Key Takeaways:

• Polymorphism allows different objects to respond to the same method call in their own unique way.
• Duck Typing is Python's approach: it focuses on an object's behavior (what methods it has) rather than its explicit type.
• The EAFP principle ("Easier to Ask for Forgiveness than Permission") is the standard way to handle potential errors when using duck typing, favoring try...except blocks over explicit checks.
• By implementing special protocols (like __len__ and __iter__), you can make your custom objects integrate seamlessly with Python's built-in functions.

Preview of the Next Lesson:
Duck typing is incredibly flexible, but sometimes you need to be more explicit about what methods a class is expected to implement. In our next lesson, we will explore Abstract Base Classes (ABCs). ABCs act as a formal blueprint or contract, allowing you to define an interface that other classes must adhere to, combining some of the formality of static typing with the flexibility of Python.