Оператор за прехващане на метаклас

Малко черна магия ви позволява да постигнете целта си:

operators = ["add", "mul"]

class OperatorHackiness(object):
  """
  Use this base class if you want your object
  to intercept __add__, __iadd__, __radd__, __mul__ etc.
  using __getattr__.
  __getattr__ will called at most _once_ during the
  lifetime of the object, as the result is cached!
  """

  def __init__(self):
    # create a instance-local base class which we can
    # manipulate to our needs
    self.__class__ = self.meta = type('tmp', (self.__class__,), {})


# add operator methods dynamically, because we are damn lazy.
# This loop is however only called once in the whole program
# (when the module is loaded)
def create_operator(name):
  def dynamic_operator(self, *args):
    # call getattr to allow interception
    # by user
    func = self.__getattr__(name)
    # save the result in the temporary
    # base class to avoid calling getattr twice
    setattr(self.meta, name, func)
    # use provided function to calculate result
    return func(self, *args)
  return dynamic_operator

for op in operators:
  for name in ["__%s__" % op, "__r%s__" % op, "__i%s__" % op]:
    setattr(OperatorHackiness, name, create_operator(name))


# Example user class
class Test(OperatorHackiness):
  def __init__(self, x):
    super(Test, self).__init__()
    self.x = x

  def __getattr__(self, attr):
    print "__getattr__(%s)" % attr
    if attr == "__add__":
      return lambda a, b: a.x + b.x
    elif attr == "__iadd__":
      def iadd(self, other):
        self.x += other.x
        return self
      return iadd
    elif attr == "__mul__":
      return lambda a, b: a.x * b.x
    else:
      raise AttributeError

## Some test code:

a = Test(3)
b = Test(4)

# let's test addition
print(a + b) # this first call to __add__ will trigger
            # a __getattr__ call
print(a + b) # this second call will not!

# same for multiplication
print(a * b)
print(a * b)

# inplace addition (getattr is also only called once)
a += b
a += b
print(a.x) # yay!

Изход

__getattr__(__add__)
7
7
__getattr__(__mul__)
12
12
__getattr__(__iadd__)
11

Сега можете да използвате втория си примерен код буквално, като наследите от моя базов клас OperatorHackiness. Получавате дори допълнително предимство: __getattr__ ще бъде извикан само веднъж за екземпляр и оператор и няма включен допълнителен слой рекурсия за кеширането. По този начин заобикаляме проблема с извикванията на метод, които са бавни в сравнение с търсенето на метод (както Пол Ханкин забеляза правилно).

ЗАБЕЛЕЖКА: Цикълът за добавяне на методите на оператора се изпълнява само веднъж в цялата ви програма, така че подготовката отнема постоянни разходи в диапазона от милисекунди.

Въпросът е, че Python търси __xxx__ методи в класа на обекта, а не в самия обект -- и ако не бъде намерен, не се връща към __getattr__ или __getattribute__.

Единственият начин да прихванете такива обаждания е да имате метод, който вече е там. Това може да бъде функция за заглушаване, както в отговора на Niklas Baumstark, или може да бъде пълноценна заместваща функция; така или иначе, обаче, трябва вече да има нещо или няма да можете да прихванете такива повиквания.

Ако четете внимателно, ще забележите, че вашето изискване за обвързване на крайния метод към екземпляра не е възможно решение - можете да го направите, но Python никога няма да го извика, тъй като Python разглежда класа на екземпляр, а не екземплярът, за __xxx__ методи. Решението на Niklas Baumstark за създаване на уникален временен клас за всеки екземпляр е възможно най-близо до това изискване.

Изглежда, че правите нещата твърде сложни. Можете да дефинирате миксин клас и да наследите от него. Това е едновременно по-просто от използването на метакласове и ще работи по-бързо от използването на __getattr__.

class OperatorMixin(object):
    def __add__(self, other):
        return func(self, other)
    def __radd__(self, other):
        return rfunc(self, other)
    ... other operators defined too

Тогава всеки клас, който искате да имате тези оператори, наследете от OperatorMixin.

class Expression(OperatorMixin):
    ... the regular methods for your class

Генерирането на операторните методи, когато са необходими, не е добра идея: __getattr__ е бавно в сравнение с редовното търсене на метод и тъй като методите се съхраняват веднъж (в класа mixin), не спестява почти нищо.