Parse the example code of dynamic modification of Python class

This article mainly introduces relevant information about the dynamically modified instance methods of the Python class. Friends who need it can refer to

The dynamically modified instance methods of the Python class

I believe that many friends will want to modify the already written program behavior code when programming, and the most common way is to use subclasses to rewrite some methods of the parent class that do not meet the needs. For example, take the following example.

class Dog:
  def bark(self):
    print 'Woof!'
 
class Husky(Dog):
  def bark(self)
    print 'Howl!'

We can use the above method to modify the code we wrote ourselves, but how should we modify the third-party code? Of course, we can also write a subclass ourselves and call the instance object of the subclass to implement modifications, but this may introduce a series of other problems. So we have to find a way to replace the original object method with our own method. This is the "patching" method that will be introduced next in this article.

Patch the class

If we want to add or modify object methods, the easiest way is to patch the class. Combined with the above example, if we want to write a new howl method for our own Dog class, we can define a new howl function and add it to our class like the following code:

def newbark(self):
  print 'Wrooof!'
 
def howl(self):
  print 'Howl!'
 
# Replace an existing method
Dog.bark = newbark
 
# Add a new method
Dog.howl = howl

Very simple, right? But there are several issues that require our attention. First of all, the methods in all instances of the modified class will be updated, so the updated methods not only exist in newly created objects, all previously created objects will have the updated methods, unless they are just added rather than overwritten. Drop the original method. Second, the method you modify or add should be bound to the object, so the first parameter of the method should be the object being called (in this case, the class instance self).

Patching Class Instances

Individual objects can also be patched without affecting other instances of the class. But there are still some tricks! Let us first look at the following example.

def herd(self, sheep):
  self.run()
  self.bark()
  self.run()
 
border_collie = Dog()
border_collie.herd = herd

Then we try to call the newly defined method:

border_collie.herd(sheep)
 
TypeError: herd() takes exactly 2 arguments (1 given)
The problem with the previous code is that the herd is not a bound method, just take a look at the following code:
 
print border_collie.herd
 
<function></function>

Error! The reason for the error is that the called object is not passed as the first parameter to the function we wrote. Of course we can pass the parameters ourselves, but it doesn't work in this scenario of replacing class methods. The correct solution to this problem is to use the MethodType function in the type module. We can look at the following sample code:

import types
 
border_collie = Dog()
border_collie.herd = types.MethodType(herd, border_collie)
 
print border_collie.herd
<bound>>
 
border_collie.herd(sheep)</bound>

Now our method has been bound to the instance, and we're done!

Summary

It is very useful to replace or add methods during operation. For example, in unit testing, some functions responsible for communicating with external services need to be replaced. Convenient for testing. This technique is not only very common, but it is also a very important technique to keep the code maintainable before you finally decide to modify it.

The above is the detailed content of Parse the example code of dynamic modification of Python class. For more information, please follow other related articles on the PHP Chinese website!