DEV Community

Karishma Shukla
Karishma Shukla

Posted on

Monkeying Around with Python: A Guide to Monkey Patching

Image description

What is Monkey Patching in Python?

Imagine modifying a car's engine while it's running. Monkey patching works similarly, allowing you to dynamically alter or extend a class or module's behavior at runtime. It involves changing or adding methods or attributes to existing modules or classes.

Extending a Class

class Cat:
  def meow(self):
    return "Meowww!"

# Monkey patch to extend functionality
def ragdoll_meow(self):
  return "Miaowww!"

original_meow = Cat.meow
Cat.meow = ragdoll_meow

ragdoll = Cat()
print(ragdoll.meow())  # Output: Miaowww!

Enter fullscreen mode Exit fullscreen mode

Here, we replaced the meow() method with a breed-specific one for Ragdolls. Remember, this only affects instances created after patching.

When to use Monkey Patching?

While alternatives like Subclassing, Decorators, Dependency Injection, and Wrapper Classes offer structured ways to modify or extend functionality, there are situations where monkey patching becomes a preferred choice:

  • Fixing third-party bugs: Patch the problematic function with your fix without modifying the original library.
  • Testing and mocking: Isolate specific components by patching their behavior, creating controlled testing environments.
  • Experimentation: Try out different functionalities without permanent code changes.
  • Debugging: Temporarily replace problematic code to pinpoint the issue's source.

Real World Use Cases

1. Fixing a Library Bug
Imagine a library function you rely on has a minor bug. Instead of waiting for a fix, you can monkey patch it with your temporary solution:

# Original buggy function
def calculate_area(length, width):
  return length * width  # Missing multiplication by 2

# Monkey patch the bug
def fixed_calculate_area(length, width):
  return length * width * 2

original_area = calculate_area
calculate_area = fixed_calculate_area

print(calculate_area(5, 3))  # Output: 30 (correctly calculated)
Enter fullscreen mode Exit fullscreen mode

2. Mocking for Testing
Mocking external dependencies during testing helps isolate your code and ensures its functionality even without external systems running. Here's how you might mock a network call:

# Original function fetching data
def get_data_from_api():
  # Makes an actual API call

# Monkey patch to return mock data
def mock_get_data_from_api():
  return {"data": "mocked"}

original_data_func = get_data_from_api
get_data_from_api = mock_get_data_from_api
Enter fullscreen mode Exit fullscreen mode

2.1 Using Python's patch()
The unittest.mock module has patch() that allows you to temporarily replace a target with a mock object.

from unittest.mock import patch

def test_function(mock_function):
    # Your test logic here
Enter fullscreen mode Exit fullscreen mode

Read more about it here.

3. Logging

import logging

# Define custom log methods
def log_info(self, message):
    self.log(logging.INFO, message)

def log_fail(self, message):
    self.log(logging.FAIL, message)

# Monkey patching the Logger class = log_info = log_fail

logger = logging.getLogger("app_logger")"This is an INFO message")"This is a FAIL message")
Enter fullscreen mode Exit fullscreen mode

Problems to Watch Out For

While monkey patching is powerful, it comes with some problems.

  • Debugging complexity: Altered code can make debugging trickier, as the original behavior is hidden.
  • Unintended consequences: Changes might affect unforeseen parts of your application.
  • Version control challenges: Tracking and managing monkey-patched code separately becomes necessary.


Monkey patching offers flexibility at runtime in Python development. Remember, even monkeys need bananas in moderation. Patch wisely only if required. Keep your code sane! 🐒

Top comments (4)

patrickcodes profile image

I learnt something new. 👏

karishmashukla profile image
Karishma Shukla

Glad to know :)

ranudar profile image
Christian Epple

Great article, thanks a lot.
Small question though: would length * width not be correct usually, for example with rectangles?

Your example could work with the circumference of a circle:
circumference = radius * Pi (wrong)

circumference = 2 * radius * Pi (correct)

Did I miss something?
Best regards!

ninjaprogrammer profile image

Great stuff as usual Karishma.