Python:替换模块类中的函数

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'是函数的另一个变量,并且说它需要另一个参数用于'变量'变量(我想这不是一个好名字).

我想要做的是使替换功能与被替换的功能完全相同,但需要额外的代码或一些小修改.但是,"自我"几乎不起作用,因为它应该在课堂上.是否有办法正确实现定义的函数来替换导入类的函数？

Answer 1

我建议4种解决方案,从最差到最好(恕我直言),但当然这也取决于你的具体限制:

1. 替换实例方法(1):我使用的函数是Python中的描述符,因此我可以使用该__get__方法AlternativeFunc将其作为实例mytest的testFunc方法并覆盖实例的方法mytest(不覆盖类方法) :

   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 2

您可以按如下方式修补此方法:

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