Python，重写函数以进行优化的最佳方法

Question

不知道如何最好地描述这个问题，但我只是想优化一些东西，因为我执行了这 100 次。所以我试图尽可能地消除逻辑。因此，为简单起见，让我们在下面使用一个简单的类：

class Steps():
   def __init__(self, descending, value):
      self.descending = descending
      self.value = value

   def step(self):
      if self.descending:
         self.value -= 1
      else:
         self.value += 1

   def other_funcs1(self):
      pass

   def other_funcs2(self):
      pass

a = Steps(descending=True, value=0)
b = Steps(descending=False, value=0)

a.step() # say this is done 100 million times
b.step() # say this is done 100 million times

由于我们一开始就已经知道它是降序还是升序，所以似乎没有必要在该 step() 中包含逻辑“if self.descending”，尤其是当我们调用它数百万次时。

一种更好的方法是继承一个基类，例如：

class Steps():
   def __init__(self, value):
      self.value = value

   def other_funcs1(self):
      pass

   def other_funcs2(self):
      pass

class StepsInc(Steps):
   def __init__(self, value):
      Steps.__init__(self, value)
   
   def step(self):
      self.value += 1

class StepsDec(Steps):
   def __init__(self, value):
      Steps.__init__(self, value)
   
   def step(self):
      self.value -= 1

a = StepsDec(value=0)
b = StepsInc(value=0)

a.step() # say this is done 100 million times
b.step() # say this is done 100 million times

以上应该更优化，因为我们不再做不必要的'if'语句。但是如果我有多个函数，取决于不同的参数，我该怎么做呢？因此，除了“降序”之外，我还有其他可以具有不同功能的参数。我不想有太多的课，而且看起来很乱。

我想到的一个解决方案不是继承，我可以做这样的事情，但不确定这是否是 pythonic：

class Steps():
       def __init__(self, descending, value):
          self.descending = descending
          self.value = value
          self.step = self.stepDec if self.descending else self.stepInc # can have multiple of this for different functions and parameters
          # more potential example
          #self.func = self.func1 if self.new_param else self.func2

       def stepInc(self):
          self.value += 1

       def stepDec(self):
          self.value -= 1

       def other_funcs1(self):
          pass

       def other_funcs2(self):
          pass

    
    
    a = Steps(descending=True, value=0)
    b = Steps(descending=False, value=0)
    
    a.step() # say this is done 100 million times
    b.step() # say this is done 100 million times

所以这个看起来比另一个继承基类的类更干净。而且我可以拥有许多基于不同参数的其他功能。所以有两个问题：1）这是pythonic吗？，如果不是更好的方法2）我怎样才能覆盖像“_ repr _”这样的默认函数？

所以对于第二个问题，假设 print(a) 我想打印“我正在下降”，而 print(b) 我想打印“我正在上升”。我知道这没有多大意义，但只是想知道如何覆盖这些。我绝对可以使用继承类示例来做到这一点，其中每个示例都有自己的“_ repr _”函数。但是有没有办法用我最新的例子来做到这一点？因为这看起来更干净，尤其是根据不同的参数有更多的功能。

希望这个问题很清楚。感谢您的帮助

Answer 1

嗯，有一种很好的方法可以解决您的问题。解决方案只是通过在构造函数中注入一个方法来动态地向一个对象添加一个方法。因为，解决方案很简单，所以我只是提供代码：

# note: in this approach the method only exists with object instance
#       the method has nothing to do with class

# note this import

import types

def desc(self):
    self.value -= 1

def inc(self):
    self.value += 1

class Steps():
    def __init__(self, func, descending, value):
        # add func as a method
        # where the method name is step
        self.step = types.MethodType(func, self)
        # nothing changes here
        self.descending = descending
        self.value = value

a = Steps(desc, True, 0)
b = Steps(inc, False, 0)

a.step();
print("value of a: {}".format(a.value));

b.step();
print("value of b: {}".format(b.value));

输出是：

value of a: -1
value of b: 1

现在，您可能会惊讶地听到：我不会向任何人推荐它

让我解释一下原因：

1. 首先，如果您以这种方式创建大量对象，则需要将大量方法与这些对象关联。您可能会浪费大量内存。
2. 对象实例与不属于类的方法绑定。这可能会给正在阅读您的代码的人造成混淆。
3. 如果您遵循紧密的 oop 编码风格，那么您只是将这些函数留在开放中，或者可能只是封装在一个类中，但这并不是解决此问题的行之有效的方法。

我知道，性能是您非常关心的问题，但我仍然建议您查看strategy pattern。当您了解这几节课会给您带来多大的灵活性时，再上几节课不会伤害您。并且每个知道该模式的人都会一眼就能理解您的代码。

现在，我已经说了很多。但是，我想提的最后一件事，如果你真的对performance 非常感兴趣，你可以write an extension 或switch to a compiled(faster) language。