📘 Polymorphism: Duck Typing

🎯 Introduction

Welcome to the wonderful world of duck typing in Python! 🦆 Have you ever heard the phrase “If it walks like a duck and quacks like a duck, it’s a duck”? That’s exactly what we’re exploring today!

Duck typing is one of Python’s superpowers that makes it incredibly flexible and fun to work with. Instead of checking what type something is, Python cares about what it can do. This tutorial will transform how you think about objects and make your code more Pythonic!

By the end, you’ll be writing flexible, elegant code that adapts to different situations like a chameleon! 🦎 Let’s dive in! 🏊‍♂️

📚 Understanding Duck Typing

🤔 What is Duck Typing?

Duck typing is like having a universal remote 📱 - you don’t care what brand your TV is, as long as it responds to the “power” button! In Python, we don’t check if an object is a specific type; we just try to use it and see if it works.

In Python terms, duck typing means:

• ✨ Objects are defined by what they can do, not what they are
• 🚀 No need for explicit type declarations or inheritance
• 🛡️ Focus on behavior rather than identity

💡 Why Use Duck Typing?

Here’s why Python developers love duck typing:

1. Flexibility 🤸‍♀️: Write code that works with any object that has the right methods
2. Simplicity 🎯: No complex inheritance hierarchies needed
3. Pythonic Code 🐍: Follows Python’s philosophy of simplicity
4. Rapid Development ⚡: Less boilerplate, more functionality

Real-world example: Imagine building a payment system 💳. With duck typing, any object that has a process_payment() method can be used, whether it’s a CreditCard, PayPal, or CryptoCurrency object!

🔧 Basic Syntax and Usage

📝 Simple Example

Let’s start with a friendly example:

# 🦆 Classic duck typing example
class Duck:
    def quack(self):
        return "Quack quack! 🦆"
    
    def swim(self):
        return "Swimming in the pond 🏊‍♂️"

class Person:
    def quack(self):
        return "I'm imitating a duck! 🗣️"
    
    def swim(self):
        return "Swimming in the pool 🏊‍♀️"

# 🎯 Function that uses duck typing
def make_it_quack(thing):
    # We don't check the type - just call the method!
    print(thing.quack())
    print(thing.swim())

# 🎮 Let's use it!
donald = Duck()
sarah = Person()

print("Donald the Duck:")
make_it_quack(donald)

print("\nSarah the Person:")
make_it_quack(sarah)

💡 Explanation: Notice how make_it_quack() doesn’t care if it receives a Duck or Person - it just needs something that can quack and swim!

🎯 Common Patterns

Here are patterns you’ll use daily:

# 🏗️ Pattern 1: File-like objects
def save_data(file_like_object, data):
    # Any object with write() method works!
    file_like_object.write(data)

# Works with files 📄
with open("data.txt", "w") as f:
    save_data(f, "Hello!")

# Works with StringIO too! 🎨
from io import StringIO
buffer = StringIO()
save_data(buffer, "Hello!")

# 🎨 Pattern 2: Iterator protocol
class Counter:
    def __init__(self, max_count):
        self.max_count = max_count
        self.count = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.count < self.max_count:
            self.count += 1
            return f"Count: {self.count} 🔢"
        raise StopIteration

# 🔄 Works in for loops!
for item in Counter(3):
    print(item)

💡 Practical Examples

🛒 Example 1: E-Commerce Payment System

Let’s build something real:

# 💳 Different payment methods
class CreditCard:
    def __init__(self, number):
        self.number = number
    
    def process_payment(self, amount):
        return f"Processing ${amount} via Credit Card 💳"
    
    def get_fee(self, amount):
        return amount * 0.03  # 3% fee

class PayPal:
    def __init__(self, email):
        self.email = email
    
    def process_payment(self, amount):
        return f"Processing ${amount} via PayPal 📧"
    
    def get_fee(self, amount):
        return amount * 0.025  # 2.5% fee

class CryptoPay:
    def __init__(self, wallet):
        self.wallet = wallet
    
    def process_payment(self, amount):
        return f"Processing ${amount} via Crypto 🪙"
    
    def get_fee(self, amount):
        return 1.0  # Flat $1 fee

# 🛒 Payment processor using duck typing
class PaymentProcessor:
    def __init__(self):
        self.transactions = []
    
    def process(self, payment_method, amount):
        # Duck typing in action! 🦆
        fee = payment_method.get_fee(amount)
        total = amount + fee
        
        result = payment_method.process_payment(amount)
        
        self.transactions.append({
            "amount": amount,
            "fee": fee,
            "total": total,
            "status": result
        })
        
        print(f"✅ {result}")
        print(f"   Fee: ${fee:.2f}")
        print(f"   Total: ${total:.2f}")
        
        return total

# 🎮 Let's use it!
processor = PaymentProcessor()

# Process different payment types
cc = CreditCard("1234-5678-9012-3456")
pp = PayPal("[email protected]")
crypto = CryptoPay("0x1234...abcd")

processor.process(cc, 100)
processor.process(pp, 100)
processor.process(crypto, 100)

🎯 Try it yourself: Add a new payment method like ApplePay or GiftCard!

🎮 Example 2: Game Character System

Let’s make it fun:

# 🦸‍♂️ Different character types
class Warrior:
    def __init__(self, name):
        self.name = name
        self.health = 100
        self.emoji = "⚔️"
    
    def attack(self):
        return f"{self.emoji} {self.name} swings sword for 20 damage!"
    
    def defend(self):
        return f"{self.emoji} {self.name} raises shield!"
    
    def special_move(self):
        return f"{self.emoji} {self.name} performs BERSERKER RAGE! 💪"

class Mage:
    def __init__(self, name):
        self.name = name
        self.health = 70
        self.emoji = "🧙‍♂️"
    
    def attack(self):
        return f"{self.emoji} {self.name} casts fireball for 25 damage! 🔥"
    
    def defend(self):
        return f"{self.emoji} {self.name} creates magic barrier! ✨"
    
    def special_move(self):
        return f"{self.emoji} {self.name} summons METEOR STORM! ☄️"

class Archer:
    def __init__(self, name):
        self.name = name
        self.health = 85
        self.emoji = "🏹"
    
    def attack(self):
        return f"{self.emoji} {self.name} shoots arrow for 18 damage!"
    
    def defend(self):
        return f"{self.emoji} {self.name} dodges swiftly!"
    
    def special_move(self):
        return f"{self.emoji} {self.name} unleashes ARROW RAIN! 🎯"

# 🎮 Battle system using duck typing
class BattleArena:
    def __init__(self):
        self.round = 0
    
    def battle_round(self, character1, character2):
        self.round += 1
        print(f"\n⚔️ ROUND {self.round} ⚔️")
        
        # Duck typing - we don't check character types!
        print(character1.attack())
        print(character2.defend())
        
        print(character2.attack())
        print(character1.defend())
        
        # Special moves!
        if self.round % 3 == 0:
            print("\n🌟 SPECIAL MOVES! 🌟")
            print(character1.special_move())
            print(character2.special_move())

# 🎯 Create characters and battle!
arena = BattleArena()
conan = Warrior("Conan")
gandalf = Mage("Gandalf")
legolas = Archer("Legolas")

# Any character can battle any other!
arena.battle_round(conan, gandalf)
arena.battle_round(gandalf, legolas)
arena.battle_round(legolas, conan)

🚀 Advanced Concepts

🧙‍♂️ Protocol Classes (Python 3.8+)

When you’re ready to level up, use Protocol for type hints with duck typing:

from typing import Protocol

# 🎯 Define what a "Drawable" should have
class Drawable(Protocol):
    def draw(self) -> str:
        ...
    
    def get_color(self) -> str:
        ...

# 🎨 Different drawable objects
class Circle:
    def __init__(self, radius, color):
        self.radius = radius
        self.color = color
    
    def draw(self) -> str:
        return f"Drawing circle ⭕ with radius {self.radius}"
    
    def get_color(self) -> str:
        return self.color

class Square:
    def __init__(self, size, color):
        self.size = size
        self.color = color
    
    def draw(self) -> str:
        return f"Drawing square ⬜ with size {self.size}"
    
    def get_color(self) -> str:
        return self.color

# 🖼️ Function with type hints
def render_shape(shape: Drawable) -> None:
    print(f"{shape.draw()} in {shape.get_color()}")

# 🎮 Works with type checking!
circle = Circle(5, "red 🔴")
square = Square(10, "blue 🔵")

render_shape(circle)
render_shape(square)

🏗️ Abstract Base Classes with Duck Typing

For the brave developers:

from abc import ABC, abstractmethod

# 🚀 Mix ABC with duck typing flexibility
class DataProcessor(ABC):
    @abstractmethod
    def process(self, data):
        pass
    
    def run_pipeline(self, data):
        # Common logic for all processors
        print(f"🔄 Starting pipeline...")
        result = self.process(data)
        print(f"✅ Pipeline complete!")
        return result

# 📊 Different processors
class JSONProcessor:
    def process(self, data):
        return f"Processing JSON: {data} 📋"

class XMLProcessor:
    def process(self, data):
        return f"Processing XML: {data} 📄"

# 🎯 Duck typing function
def process_data(processor, data):
    # Works with any object that has process() method!
    return processor.process(data)

# Use both approaches
json_proc = JSONProcessor()
xml_proc = XMLProcessor()

print(process_data(json_proc, {"key": "value"}))
print(process_data(xml_proc, "<data>value</data>"))

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: AttributeError at Runtime

# ❌ Wrong way - assuming methods exist
def risky_function(obj):
    return obj.non_existent_method()  # 💥 AttributeError!

# ✅ Correct way - check first!
def safe_function(obj):
    if hasattr(obj, 'non_existent_method'):
        return obj.non_existent_method()
    else:
        print("⚠️ Method not found!")
        return None

# ✅ Even better - use try/except
def safer_function(obj):
    try:
        return obj.non_existent_method()
    except AttributeError:
        print("⚠️ Method not available!")
        return None

🤯 Pitfall 2: Too Much Duck Typing

# ❌ Dangerous - no hints about expected behavior
def process_anything(thing):
    thing.start()
    thing.process()
    thing.cleanup()
    thing.report()
    # What does 'thing' need? 😰

# ✅ Better - document expectations
def process_job(job):
    """Process a job that has start(), process(), cleanup(), and report() methods.
    
    Args:
        job: Any object with required methods
    """
    job.start()
    job.process()
    job.cleanup()
    job.report()

# ✅ Best - use Protocol for type hints
from typing import Protocol

class Job(Protocol):
    def start(self) -> None: ...
    def process(self) -> None: ...
    def cleanup(self) -> None: ...
    def report(self) -> str: ...

def process_typed_job(job: Job) -> None:
    job.start()
    job.process()
    job.cleanup()
    print(job.report())

🛠️ Best Practices

1. 🎯 Use EAFP: “Easier to Ask for Forgiveness than Permission” - try/except instead of hasattr
2. 📝 Document Interfaces: Clearly state what methods your functions expect
3. 🛡️ Handle AttributeError: Always be prepared for missing methods
4. 🎨 Use Protocols: For type hints while keeping flexibility
5. ✨ Keep It Simple: Don’t overcomplicate - duck typing should make code cleaner!

🧪 Hands-On Exercise

🎯 Challenge: Build a Notification System

Create a flexible notification system using duck typing:

📋 Requirements:

• ✅ Support multiple notification channels (Email, SMS, Push, Slack)
• 🏷️ Each channel should have send() and format_message() methods
• 👤 Track delivery status for each notification
• 📅 Support scheduling notifications
• 🎨 Each notification type needs an emoji!

🚀 Bonus Points:

• Add retry logic for failed notifications
• Implement priority levels
• Create a notification queue

💡 Solution

from datetime import datetime
import time

# 📧 Different notification channels
class EmailNotifier:
    def __init__(self):
        self.emoji = "📧"
        self.channel = "Email"
    
    def format_message(self, message, recipient):
        return f"To: {recipient}\nSubject: Notification\n\n{message}"
    
    def send(self, message, recipient):
        formatted = self.format_message(message, recipient)
        print(f"{self.emoji} Sending email to {recipient}")
        # Simulate sending
        time.sleep(0.1)
        return {"status": "sent", "channel": self.channel, "timestamp": datetime.now()}

class SMSNotifier:
    def __init__(self):
        self.emoji = "📱"
        self.channel = "SMS"
    
    def format_message(self, message, recipient):
        # SMS has character limit
        return f"{message[:160]}"
    
    def send(self, message, recipient):
        formatted = self.format_message(message, recipient)
        print(f"{self.emoji} Sending SMS to {recipient}")
        time.sleep(0.05)
        return {"status": "sent", "channel": self.channel, "timestamp": datetime.now()}

class PushNotifier:
    def __init__(self):
        self.emoji = "🔔"
        self.channel = "Push"
    
    def format_message(self, message, recipient):
        return {"title": "New Notification", "body": message, "user": recipient}
    
    def send(self, message, recipient):
        formatted = self.format_message(message, recipient)
        print(f"{self.emoji} Sending push notification to {recipient}")
        time.sleep(0.02)
        return {"status": "sent", "channel": self.channel, "timestamp": datetime.now()}

class SlackNotifier:
    def __init__(self):
        self.emoji = "💬"
        self.channel = "Slack"
    
    def format_message(self, message, recipient):
        return f"@{recipient}: {message}"
    
    def send(self, message, recipient):
        formatted = self.format_message(message, recipient)
        print(f"{self.emoji} Sending Slack message to {recipient}")
        time.sleep(0.03)
        return {"status": "sent", "channel": self.channel, "timestamp": datetime.now()}

# 🚀 Notification manager using duck typing
class NotificationManager:
    def __init__(self):
        self.history = []
        self.channels = {}
    
    def add_channel(self, name, notifier):
        # Duck typing - we just need send() and format_message()
        self.channels[name] = notifier
        print(f"✅ Added {name} channel {notifier.emoji}")
    
    def send_notification(self, channel_name, message, recipient, priority="normal"):
        if channel_name not in self.channels:
            print(f"❌ Channel {channel_name} not found!")
            return
        
        notifier = self.channels[channel_name]
        
        # Priority handling
        if priority == "high":
            message = f"🚨 URGENT: {message}"
        
        try:
            # Duck typing in action!
            result = notifier.send(message, recipient)
            result["priority"] = priority
            self.history.append(result)
            print(f"✅ Notification sent successfully!")
            return result
        except Exception as e:
            print(f"❌ Failed to send notification: {e}")
            # Retry logic
            print(f"🔄 Retrying...")
            try:
                result = notifier.send(message, recipient)
                result["retry"] = True
                self.history.append(result)
                return result
            except:
                print(f"❌ Retry failed!")
                return None
    
    def broadcast(self, message, recipients, priority="normal"):
        print(f"\n📢 Broadcasting to {len(recipients)} recipients...")
        results = []
        
        for recipient in recipients:
            # Try all channels for each recipient
            for channel_name, notifier in self.channels.items():
                result = self.send_notification(channel_name, message, recipient, priority)
                if result:
                    results.append(result)
                    break  # One successful channel is enough
        
        return results
    
    def get_stats(self):
        print("\n📊 Notification Stats:")
        print(f"  📨 Total sent: {len(self.history)}")
        
        # Count by channel
        channel_counts = {}
        for record in self.history:
            channel = record.get("channel", "Unknown")
            channel_counts[channel] = channel_counts.get(channel, 0) + 1
        
        for channel, count in channel_counts.items():
            print(f"  {self.channels.get(channel, {}).emoji if channel in self.channels else '❓'} {channel}: {count}")

# 🎮 Test the system!
manager = NotificationManager()

# Add notification channels
manager.add_channel("email", EmailNotifier())
manager.add_channel("sms", SMSNotifier())
manager.add_channel("push", PushNotifier())
manager.add_channel("slack", SlackNotifier())

# Send individual notifications
manager.send_notification("email", "Welcome to our service!", "[email protected]")
manager.send_notification("sms", "Your code is 123456", "+1234567890")
manager.send_notification("push", "You have a new message!", "user123", priority="high")

# Broadcast to multiple users
users = ["alice", "bob", "charlie"]
manager.broadcast("System maintenance at 10 PM", users, priority="high")

# Show statistics
manager.get_stats()

🎓 Key Takeaways

You’ve learned so much! Here’s what you can now do:

• ✅ Understand duck typing and why Python loves it 🦆
• ✅ Write flexible code that works with any compatible object 💪
• ✅ Apply EAFP principle for Pythonic error handling 🎯
• ✅ Use Protocols for type hints while keeping flexibility 🛡️
• ✅ Build adaptable systems that embrace Python’s dynamic nature! 🚀

Remember: In Python, it’s not about what an object IS, it’s about what it CAN DO! 🤝

🤝 Next Steps

Congratulations! 🎉 You’ve mastered duck typing in Python!

Here’s what to do next:

1. 💻 Practice with the notification system exercise
2. 🏗️ Refactor existing code to use duck typing where appropriate
3. 📚 Move on to our next tutorial: Abstract Base Classes
4. 🌟 Share your duck typing examples with the community!

Remember: Duck typing is what makes Python flexible and fun. Embrace it, and your code will thank you! 🚀

Happy coding! 🎉🚀✨