Python Monkey Patching Tutorial – Modify Code at Runtime with Examples

Python Monkey Patching

Python is a highly dynamic language. One of its powerful (and sometimes risky) features is Monkey Patching.

Monkey patching allows you to:

• Modify classes at runtime
• Change methods dynamically
• Replace module behavior
• Fix or extend existing code without editing source

It is widely used in debugging, testing, and framework customization.

---

What is Monkey Patching?

Monkey patching means:

Dynamically modifying or extending code at runtime without changing the original source code.

---

Why is it Called Monkey Patching?

The term “monkey patching” comes from the idea of a “guerrilla patch” or “magic modification” that changes behavior at runtime.

---

1. Basic Monkey Patching Example

Original Class

class Dog:
    def speak(self):
        return "Bark"

---

Monkey Patch Method

def new_speak(self):
    return "Meow (patched)"

Dog.speak = new_speak

---

Testing It

d = Dog()
print(d.speak())

---

Output

Meow (patched)

---

2. Patching Functions

def greet():
    return "Hello"

---

Monkey Patch

def new_greet():
    return "Hi (patched)"

greet = new_greet

print(greet())

---

Output

Hi (patched)

---

3. Monkey Patching at Module Level

import math

math.sqrt = lambda x: "patched sqrt"

---

Test

print(math.sqrt(16))

---

Output

patched sqrt

---

4. Using Monkey Patching for Bug Fixes

class API:
    def get_data(self):
        return None

---

Fix Without Editing Source

def fixed_get_data(self):
    return {"status": "fixed data"}

API.get_data = fixed_get_data

---

5. Monkey Patching in Testing

class Service:
    def fetch(self):
        return "real data"

---

Patch in Test

def fake_fetch(self):
    return "mock data"

Service.fetch = fake_fetch

---

Result

mock data

---

6. Monkey Patching Instance Methods

class User:
    def name(self):
        return "John"

---

Patch Only One Instance

u = User()

u.name = lambda: "Patched User"

print(u.name())

---

7. Monkey Patching with functools.wraps (Safer Approach)

from functools import wraps

def patched(func):
    @wraps(func)
    def wrapper():
        return "patched version"
    return wrapper

---

8. Restoring Original Function

Always store original before patching.

original_sqrt = math.sqrt

math.sqrt = lambda x: x * 2

math.sqrt = original_sqrt

---

9. Real-World Use Cases

Monkey patching is used in:

• Debugging production issues
• Fixing third-party libraries
• Testing and mocking
• Hotfix deployment
• Framework customization

---

10. Risks of Monkey Patching

Although powerful, it can be dangerous.

Problems:

• Hard to debug
• Breaks original behavior
• Conflicts with other patches
• Unpredictable runtime behavior

---

11. Best Practices

✔ Store Original Methods

Always keep a backup.

---

✔ Use Only When Necessary

Prefer proper inheritance or design patterns.

---

✔ Limit Scope

Avoid global patching when possible.

---

✔ Document Changes

Clearly mention what is patched.

---

12. Monkey Patching vs Inheritance

Feature	Monkey Patching	Inheritance
Changes code at runtime	Yes	No
Safer	No	Yes
Flexible	Very high	Moderate
Maintainability	Low	High

---

13. Monkey Patching vs Decorators

Feature	Monkey Patching	Decorators
Runtime modification	Yes	Yes
Code safety	Low	High
Readability	Low	High

---

Summary

Monkey patching is a powerful Python feature that allows runtime modification of classes, functions, and modules. It is useful for testing, debugging, and quick fixes but should be used carefully due to its risks.

---

Conclusion

Python monkey patching demonstrates the flexibility of the language by allowing dynamic behavior changes at runtime. While it is a powerful tool for developers, it should be used responsibly to avoid unpredictable behavior and maintain code stability.