Polymorphism in Python Explained — Types, Examples and Real-World Patterns

# Three completely unrelated classes — no shared base class
class HtmlWidget:
    def __init__(self, content):
        self.content = content

    def render(self):
        # Returns an HTML string representation
        return f"<div>{self.content}</div>"


class PdfSection:
    def __init__(self, text):
        self.text = text

    def render(self):
        # Returns a simulated PDF text block
        return f"[PDF BLOCK] {self.text}"


class ConsoleMessage:
    def __init__(self, message):
        self.message = message

    def render(self):
        # Returns a plain terminal string
        return f">>> {self.message}"


def display_all(renderable_items):
    """
    This function doesn't know or care what TYPE each item is.
    It only requires that each item has a .render() method.
    That's duck typing — the contract is the method, not the class.
    """
    for item in renderable_items:
        print(item.render())  # Calls whichever .render() belongs to this object


# Mix completely different types in the same list — Python handles it gracefully
page_components = [
    HtmlWidget("Welcome to TheCodeForge"),
    PdfSection("Chapter 1: Polymorphism"),
    ConsoleMessage("Build complete — 0 errors"),
]

display_all(page_components)

from abc import ABC, abstractmethod
import datetime


class Notification(ABC):
    """
    Abstract base class — defines the CONTRACT every notification must honour.
    You cannot instantiate this directly; it's a blueprint only.
    """

    def __init__(self, recipient, message):
        self.recipient = recipient
        self.message = message
        self.timestamp = datetime.datetime.now().strftime("%H:%M:%S")

    @abstractmethod
    def send(self):
        """
        Every subclass MUST implement this method.
        The @abstractmethod decorator enforces the contract at class creation time.
        """
        pass

    def log(self):
        # Shared behaviour — all notifications log themselves the same way
        # Subclasses inherit this without overriding it
        print(f"[{self.timestamp}] Notification queued for {self.recipient}")


class EmailNotification(Notification):
    def __init__(self, recipient, message, subject):
        super().__init__(recipient, message)  # Reuse parent's __init__ logic
        self.subject = subject

    def send(self):
        # Overrides the abstract send() with email-specific behaviour
        self.log()  # Calls the shared parent method
        print(f"  EMAIL to {self.recipient}")
        print(f"  Subject: {self.subject}")
        print(f"  Body: {self.message}")


class SmsNotification(Notification):
    def send(self):
        # Completely different implementation — same method name, different behaviour
        self.log()
        print(f"  SMS to {self.recipient}: {self.message[:160]}")  # SMS character limit


class SlackNotification(Notification):
    def __init__(self, recipient, message, channel):
        super().__init__(recipient, message)
        self.channel = channel

    def send(self):
        self.log()
        print(f"  SLACK -> #{self.channel} @{self.recipient}: {self.message}")


def dispatch_notifications(notifications):
    """
    This function is completely decoupled from the specific notification types.
    Add a new channel (PushNotification, WhatsApp...) and this function
    needs ZERO changes — that's polymorphism delivering real value.
    """
    for notification in notifications:
        notification.send()  # Python resolves the correct .send() at runtime
        print()  # Blank line for readability


# Build a mixed list of notification types
notification_queue = [
    EmailNotification("alice@example.com", "Your order has shipped!", "Order Update"),
    SmsNotification("+447911123456", "Your OTP is 847291. Valid for 5 minutes."),
    SlackNotification("deployment-bot", "Production deploy successful v2.4.1", "engineering"),
]

dispatch_notifications(notification_queue)

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def __repr__(self):
        # Called when Python needs a developer-friendly string representation
        # e.g. inside a list, or in the REPL
        return f"Product('{self.name}', £{self.price:.2f})"


class ShoppingCart:
    def __init__(self, owner):
        self.owner = owner
        self.items = []  # Stores Product objects

    def add(self, product):
        self.items.append(product)
        return self  # Enables method chaining: cart.add(a).add(b)

    def __len__(self):
        # len(cart) now works naturally — returns number of items
        return len(self.items)

    def __contains__(self, product_name):
        # 'in' operator: 'Headphones' in cart
        return any(item.name == product_name for item in self.items)

    def __add__(self, other_cart):
        """
        Merge two carts with the + operator.
        Returns a brand-new cart — doesn't mutate either original.
        Follows the principle of least surprise: x + y shouldn't change x.
        """
        merged = ShoppingCart(f"{self.owner} & {other_cart.owner}")
        merged.items = self.items + other_cart.items  # Combine item lists
        return merged

    def __gt__(self, other_cart):
        # cart_a > cart_b compares total value — feels natural
        return self.total() > other_cart.total()

    def __str__(self):
        # str(cart) or print(cart) gives a human-readable summary
        item_lines = "\n".join(f"  - {item.name}: £{item.price:.2f}" for item in self.items)
        return f"Cart ({self.owner}):\n{item_lines}\n  TOTAL: £{self.total():.2f}"

    def total(self):
        return sum(item.price for item in self.items)


# --- Putting it all together ---

alice_cart = ShoppingCart("Alice")
alice_cart.add(Product("Keyboard", 79.99)).add(Product("Mouse", 29.99))

bob_cart = ShoppingCart("Bob")
bob_cart.add(Product("Headphones", 149.99)).add(Product("USB Hub", 24.99))

# __len__ in action
print(f"Alice has {len(alice_cart)} items in her cart")

# __contains__ in action
print(f"'Mouse' in Alice's cart: {'Mouse' in alice_cart}")
print(f"'Headphones' in Alice's cart: {'Headphones' in alice_cart}")

# __gt__ comparison
print(f"Bob's cart is more expensive: {bob_cart > alice_cart}")

# __add__ to merge carts
combined_cart = alice_cart + bob_cart
print(f"\nMerged cart has {len(combined_cart)} items")

# __str__ for a clean printout
print(f"\n{combined_cart}")