python：多重继承和基类中的 __add__()

Question

我有一个基类，我想在其中处理 __add__() 并希望在 __add__ing 两个子类实例时支持 - 也就是说，两个子类的方法都在结果实例。

import copy

class Base(dict):
    def __init__(self, **data):
        self.update(data)

    def __add__(self, other):
        result = copy.deepcopy(self)
        result.update(other)
        # how do I now join the methods?
        return result

class A(Base):
    def a(self):
        print "test a"

class B(Base):
    def b(self):
        print "test b"


if __name__ == '__main__':
    a = A(a=1, b=2)
    b = B(c=1)
    c = a + b
    c.b() # should work
    c.a() # should work

编辑：更具体地说：我有一个类Hosts，它包含一个dict(host01=.., host02=..) （因此是 dict 的子类） - 这提供了一些基本方法，例如 run_ssh_commmand_on_all_hosts()

现在我有一个子类 HostsLoadbalancer ，它包含一些特殊方法，例如 drain()，并且我有一个 HostsNagios 类，它包含一些特定于 nagios 的方法。

然后我正在做的事情是这样的：

nagios_hosts = nagios.gethosts()
lb_hosts = loadbalancer.gethosts()
hosts = nagios_hosts + lb_hosts
hosts.run_ssh_command_on_all_hosts('uname')
hosts.drain() # method of HostsLoadbalancer - drains just the loadbalancer-hosts
hosts.acknoledge_downtime() # method of NagiosHosts - does this just for the nagios hosts, is overlapping

这个问题的最佳解决方案是什么？

我想我可以以某种方式“复制所有方法” - 像这样： 对于 dir 中的 x（其他）： setattr(self, x, getattr(other, x))

我走在正确的轨道上吗？或者我应该使用抽象基类？

Answer 1

一般来说，这是一个坏主意。您正在尝试将方法注入到类型中。话虽如此，您当然可以在 python 中执行此操作，但您必须意识到每次执行此操作时都希望创建一个新类型。这是一个示例：

import copy

class Base(dict):
    global_class_cache = {}

    def __init__(self, **data):
        self.local_data = data

    def __add__(self, other):
        new_instance = self._new_type((type(self), type(other)))()
        new_instance.update(copy.deepcopy(self).__dict__)
        new_instance.update(copy.deepcopy(other).__dict__)
        return new_instance

    def _new_type(self, parents):
        parents = tuple(parents)
        if parents not in Base.global_class_cache:
            name = '_'.join(cls.__name__ for cls in parents)
            Base.global_class_cache[parents] = type(name, parents, {})
        return Base.global_class_cache[parents]

class A(Base):
    def a(self):
        print "test a"

class B(Base):
    def b(self):
        print "test b"


if __name__ == '__main__':
    a = A(a=1, b=2)
    b = B(c=1)
    c = a + b
    c.b() # should work
    c.a() # should work
    print c.__class__.__name__

更新
我已经更新了示例以删除手动移动方法——我们在这里使用 mixin。

Answer 2

如果没有更多信息，很难回答你的问题。如果 Base 应该是所有类的公共接口，那么您可以使用简单继承来实现公共行为，同时保留子类的方法。例如，假设您需要一个基类，其中所有对象都具有 say_hola() 方法，但子类除了 say_hola() 之外还可以具有任意其他方法

class Base(object):
   def say_hola(self):
     print "hola"

class C1(Base):
   def add(self, a, b):
      return a+b

class C2(Base):
   def say_bonjour(self):
      return 'bon jour'

： C1 和 C2 的所有实例除了其特定方法之外还有 say_hola() 。

更通用的模式是创建一个 Mixin。来自维基百科：

在面向对象编程中
语言中， mixin 是一个类
提供一定的功能
由子类继承，而不是
用于实例化（
该类的对象的生成）。
从 mixin 继承不是一种形式
的专业化，而是
收集功能的手段。一个
类可以继承其大部分或全部
来自一个或多个 mixins 的功能
通过多重继承。