Monkey Patching in Python Explained with Coding Examples

Explaining monkey patching in Python with simple examples so that everyone can understand. In this tutorial, I will mention its use-case where you can use it in your project or program.

What is Monkey Patching?

This question also has been asked in the many Python job interviews.

Monkey patching is a dynamic technique in Python by which you can modify the behavior of an existing class or module.

To change the behavior of a class or module, you don’t need to change the code inside the class or method.

Let’s see how you can do that.

I’m taking two coding examples to change the behavior of the class and module.

Example: Monkey Patching Python Class

Python program to change the behavior of class dynamically:

class monkey:
    def monkeyFunc(self):
        print("my function")
        
def patchFunc():
    print("patching on monkey")
    

#normal class method call
objMonkey= monkey()
objMonkey.monkeyFunc()

#calling class method after monkey patch
objMonkey.monkeyFunc=patchFunc
objMonkey.monkeyFunc()

Output:

my function
patching on monkey

In the above program, we have created an instance objMonkey of class monkey.

We are assigning a new method name (patchFunc) to the existing class method name (monkeyFunc). The linking of a new method to the existing class method name happens at runtime. So the behavior of the class monkey is changed dynamically.

In the above class, you are changing the behavior of the class method defined in the same program file.

Now let’s take another example of a monkey patching Python module.

Example: Monkey Patching Python Module

Write your own modules called animals.

class monkey:
    def monkeyFunc(self):
        print("my function")

Save this file as animals.py.
Now import this file as a Python module in your another Python program.

import animals

def patchFunc():
    print("patching on monkey")

#normal class method call
objMonkey= animals.monkey()
objMonkey.monkeyFunc()
 
#calling class method after monkey patch
objMonkey.monkeyFunc=patchFunc
objMonkey.monkeyFunc()

Output:

my function
patching on monkey

We are getting the same output. This time we have changed the behavior of the method defined inside the module animals without changing a single line of code inside the animals.py.

In this example, I tried the monkey patching my own module. Similarly, you can try it on existing standard modules.

[Use-Case] What’s the use of monkey patching?

Let’s take an example.

Suppose you are importing the standard module. Modules have different methods.

As per your requirement, you want the method inside the module to work differently. It’s not easy to go to the method defined inside the standard module and change it.

The simplest way of doing the same things is by the monkey patching technique.

How does it work?

• You write your own method.
• Assign this method name to the method name defined inside the module.
• Now every time when you call the method defined inside the module, it calls your own method.

You changed the behavior of the method defined in the module.

Conclusion

This is all about monkey patching in Python- a technique to change the behavior of a class or module.

There is also another technique called decorators in Python to change the behavior of code without changing the actual code dynamically.