Python：替换modu类中的函数

Question

我试图替换类中定义的函数，以便在不更改实际代码的情况下修改其函数（如内部工作）。 我从来没有这样做过，因此，有一些问题，而更换它。 更改代码将使我访问python库中的包，这不是一个很好的选择。

例如，如果模块名为testMOD

class testMOD(object):
      def testFunc(self, variable):
          var = variable
          self.something = var + 12

然后导入testMOD，定义一个类（mytest=testMOD（）），访问类testFunc中定义的函数，并将其更改为已定义的函数。

例如

from somemodule import testMOD
mytest = testMOD()

def alternativeFunc(self, variable):
    var = variable
    self.something = var + 1.2

#problem here
mytest.testFunc = alternativeFunc

如您所见，如果我只是手动覆盖（？）类中具有我定义的函数的函数将无法正常工作。 它没有给出任何语法错误，但是，问题是被替换的函数认为“self”是该函数的另一个变量，并说它需要“variable”变量的另一个参数（我想这不是一个好名字）。

我想做的是使替换函数与被替换函数完全相同，但是需要额外的代码或一些小的修改。然而，“自我”在课堂上并没有发挥应有的作用。 是否有方法正确实现已定义函数以替换导入类的函数？

Answer 1

您可以按如下方法使用猴子贴片：

class TestMOD(object):

    def testFunc(self, variable):
        var = variable
        self.something = var + 12
        print(f'original {self.something}')


def alternativeFunc(self, variable):
    var = variable
    self.something = var + 1.2
    print(f'alternative {self.something}')


if __name__ == '__main__':

    test_original = TestMOD()
    test_original.testFunc(12)

    TestMOD.testFunc = alternativeFunc

    test_alternate = TestMOD()
    test_alternate.testFunc(12)

输出：

original 24
alternative 13.2

Answer 2

我建议4种解决方案，从最坏到最好（IMHO），但这当然也取决于您的具体限制：

1. 替换实例方法（1）：我使用函数是Python中的描述符这一事实，以便可以使用AlternativeFunc上的__get__方法将其作为实例mytest的方法获取，并覆盖实例mytest的testFunc方法（而不覆盖类方法）：

   class testMOD(object):
       def testFunc(self, variable):
           var = variable
           self.something = var + 12
           print('Original:', self.something)
   
   def alternativeFunc1(self, variable):
       var = variable
       self.something = var + 1.2
       print('Alternative1:', self.something)
   
   mytest1 = testMOD()
   mytest1.testFunc(10)   # Original: 22
   
   mytest1.testFunc = alternativeFunc1.__get__(mytest1, testMOD)
   mytest1.testFunc(10)   # Alternative1: 11.2
   mytestX = testMOD()
   mytestX.testFunc(10)   # Original: 22
   

2. 替换实例方法（2）：这次，我使用的types.MethodType比第一个解决方案可读性更强：

   import types
   
   class testMOD(object):
       def testFunc(self, variable):
           var = variable
           self.something = var + 12
           print('Original:', self.something)
   
   def alternativeFunc1(self, variable):
       var = variable
       self.something = var + 1.2
       print('Alternative1:', self.something)
   
   mytest1 = testMOD()
   mytest1.testFunc(10)   # Original: 22
   
   funcType = types.MethodType
   mytest1.testFunc = funcType(alternativeFunc1, mytest1)
   mytest1.testFunc(10)   # Alternative1: 11.2
   mytestX = testMOD()
   mytestX.testFunc(10)   # Original: 22
   

3. 执行类方法的猴子修补。与第一个方法不同，它更改类的任何实例的行为：

   class testMOD(object):
       def testFunc(self, variable):
           var = variable
           self.something = var + 12
           print('Original:', self.something)
   
   def alternativeFunc2(self, variable):
       var = variable
       self.something = var + 1.2
       print('Alternative2:', self.something)
   
   mytest2 = testMOD()
   mytest2.testFunc(10)   # Original: 22
   
   testMOD.testFunc = alternativeFunc2
   mytest2.testFunc(10)   # Alternative2: 11.2
   mytestX = testMOD()
   mytestX.testFunc(10)   # Alternative2: 11.2
   

4. 创建从testMOD继承的类以重写方法：

   class testMODNew(testMOD):
        def testFunc(self, variable):
            var = variable
            self.something = var + 1.2
            print('Alternative3:', self.something)
   
   mytest3 = testMODNew()
   mytest3.testFunc(10) # Alternative3: 11.2
   

Answer 3

检查python中的类继承，以创建自己的自定义类：

from somemodule import TestMOD

class YourCustomClass(TestMOD):

    # change the function
    def test_func(self, variable):
        #
        #

your_class = YourCustomClass()
your_class.test_func(x)