插件是否应该添加新的实例方法猴子补丁或子类/混合并替换父类？

举一个简单的例子，以一个类为例Polynomial

class Polynomial(object):
     def __init__(self, coefficients):
         self.coefficients = coefficients

对于以下形式的多项式p(x) = a_0 + a_1*x + a_2*x^2 + ... + a_n*x^n列表在哪里coefficients = (a_0, a_1, ..., a_n)存储这些系数。

一个插件模块horner然后可以提供一个函数horner.evaluate_polynomial(p, x)评估一个Polynomial实例p按价值x，即返回值p(x)。但不是以这种方式调用函数，而是调用p.evaluate(x)（或者更直观地p(x) via __call__ http://docs.python.org/2/reference/datamodel.html#emulating-callable-objects） 会更好。但应该怎么做呢？

a) 猴子补丁，即

Polynomial.evaluate = horner.evaluate_polynomial
# or Polynomial.__call__ = horner.evaluate_polynomial

b) 子类化和替换类，即

orgPolynomial = Polynomial
class EvaluatablePolynomial(Polynomial):
    def evaluate(self, x):
        return horner.evaluate_polynomial(self, x)
Polynomial = EvaluatablePolynomial

c) 混合+替换，即

orgPolynomial = Polynomial
class Evaluatable(object):
    def evaluate(self, x):
        return horner.evaluate_polynomial(self, x)
class EvaluatablePolynomial(Polynomial, Evaluatable):
    pass
Polynomial = EvaluatablePolynomial

果然，猴子补丁是最短的（特别是因为我没有包含任何检查）hasattr(Polynomial, 'evaluate')，但类似地，子类应该调用super()那么...），但它是最 Pythonic 的吗？或者还有其他更好的选择吗？

特别是考虑多个插件提供相同功能的可能性，例如zeros要么使用numpy或者自制的二分法，当然只应该使用一个实现插件，哪种选择可能不太容易出错？

将函数直接修补到原始类而不是替换它的一个可能也是最重要的属性是，在加载插件之前对原始类的引用/实例现在也将具有新属性。在给定的示例中，这很可能是所需的行为，因此应该使用。

然而，在其他情况下，猴子补丁可能会以与其原始实现不兼容的方式修改现有方法的行为，并且修改后的类的先前实例应使用原始实现。诚然，这种情况不仅罕见，而且设计很糟糕，但您应该记住这种可能性。由于某些复杂的原因，代码甚至可能依赖于absence添加猴子补丁的方法，尽管这里似乎很难想出一个非人工的例子。

总之，除了少数例外，将方法猴子修补到原始类中（最好使用hasattr(...)修补之前检查）应该是首选方式。

edit我当前的做法：创建一个子类（用于更简单的代码完成和修补），然后使用以下内容patch(patching_class, unpatched_class) method:

import logging
from types import FunctionType, MethodType


logger = logging.getLogger(__name__)
applied_patches = []


class PatchingError(Exception):
    pass


def patch(subcls, cls):
    if not subcls in applied_patches:
        logger.info("Monkeypatching %s methods into %s", subcls, cls)
        for methodname in subcls.__dict__:
            if methodname.startswith('_'):
                logger.debug('Skipping methodname %s', methodname)
                continue
            # TODO treat modified init
            elif hasattr(cls, methodname):
                raise PatchingError(
                    "%s alrady has methodname %s, cannot overwrite!",
                    cls, methodname)
            else:
                method = getattr(subcls, methodname)
                logger.debug("Adding %s %s", type(method), methodname)
                method = get_raw_method(methodname, method)
                setattr(cls, methodname, method)
        applied_patches.append(subcls)


def get_raw_method(methodname, method):
    # The following wouldn't be necessary in Python3...
    # http://stackoverflow.com/q/18701102/321973
    if type(method) == FunctionType:
        logger.debug("Making %s static", methodname)
        method = staticmethod(method)
    else:
        assert type(method) == MethodType
        logger.debug("Un-bounding %s", methodname)
        method = method.__func__
    return method

悬而未决的问题是各个子类的模块是否应该直接调用patch导入时或应手动完成。我也在考虑为这样的修补子类编写一个装饰器或元类......