Understanding Python’s Duck Typing and Monkey Patching with Real Code

1. Duck Typing

Duck typing means that an object's suitability is determined by the presence of required methods and attributes rather than its explicit type.

Python is dynamically typed, so there is no strict type checking. If an object implements the same interface as a duck, it can be used wherever a duck is expected.

# Duck class
class Duck:
    def __init__(self, name):
        self.name = name
    def swim(self):
        print("A duck named " + self.name + " is swimming...")
    def call(self):
        print("gay...gay...gay...")

# Goose class (has same methods as Duck)
class Goose:
    def __init__(self, name):
        self.name = name
    def swim(self):
        print("A goose named " + self.name + " is swimming...")
    def call(self):
        print("goo...goo...goo...")

# Function that expects a Duck‑like object
def duckshow(duck):
    duck.swim()
    duck.call()

yaya = Duck("yaya")
ee = Goose("ee")
duckshow(yaya)
duckshow(ee)

2. Monkey Patching

Monkey patching refers to modifying or extending a class or module from outside its original definition, which can be useful but may break encapsulation.

# Define a Dog class
class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def sleep(self):
        print("Zzz...Zzz..Zzz...")

# Add new methods to Dog from outside
def speak(self):
    print("I think myself a hero and very handsome!")

Dog.speak = speak
Dog.home = "Earth"

snoopy = Dog("snoopy", 3)
snoopy.sleep()
snoopy.speak()
print(snoopy.home)

Monkey patching can also be applied to library classes, such as adding a concise memory‑display method to pandas DataFrames.

import numpy as np
import pandas as pd

df = pd.DataFrame(np.random.randint(1, 10, size=(5,5)),
                  columns=list("abcde"))

def memory(self):
    mem = self.__sizeof__()
    if mem < 1024:
        return f"{mem} B"
    elif mem < 1024*1024:
        return f"{mem/1024:.0f} KB"
    elif mem < 1024**3:
        return f"{mem/1024**2:.0f} MB"
    else:
        return f"{mem/1024**3:.0f} GB"

pd.DataFrame.memory = memory
print(df.memory())

These examples illustrate how Python’s duck typing and monkey patching enable flexible, runtime behavior modifications.