Python：如何“合并”两个类

Question

我想将一些属性和方法添加到各种类中。我必须添加的方法和属性是相同的，但不是分配它们的类，所以我想构造一个类，为参数中给定的类分配新的方法和属性。我尝试了这个，但它没有用：（我知道尝试为自己分配一些东西是一种非常错误的方法，它只是为了展示我想做什么）

 class A:
    def __init__(self):
        self.a = 'a'

    def getattA(self):
        return self.a

class B:
    def __init__(self, parent) :
        self = parent

        # This is working :
        print self.getattA()

    def getattB(self):
        return self.getattA()

insta = A()
instb = B(insta)

# This is not working :
print instb.getattB()

结果是：

 a
Traceback (most recent call last):
  File "D:\Documents and settings\Bureau\merge.py", line 22, in <module>
    print instb.getattB()
  File "D:\Documents and settings\Bureau\merge.py", line 16, in getattB
    return self.getattA()
AttributeError: B instance has no attribute 'getattA'

我希望在调用 instb.gettattB() 时得到 ‘a’

要恢复，我想从 A 类继承 B 类，在 B 类的参数中给出 A 类，因为我的 B 类将是各种类的子类，而不总是 A。

原文由 user1062526 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

最佳答案在评论中，它对我很有用，所以我决定在答案中展示它（感谢 sr2222）：在 Python 中动态声明继承的方法是 type() 内置函数。对于我的例子：

 class A(object) :
    def __init__(self, args):
        self.a = 'a'
        self.args = args

    def getattA(self):
        return self.a, self.args

class B(object) :
    b = 'b'
    def __init__(self, args) :
        self.b_init = args

    def getattB(self):
        return self.b

C = type('C', (A,B), dict(c='c'))

instc = C('args')

print 'attributes :', instc.a,  instc.args, instc.b, instc.c
print 'methodes :', instc.getattA(), instc.getattB()

print instc.b_init

代码返回：

 attributes : a args b c
methodes : ('a', 'args') b
Traceback (most recent call last):
  File "D:\Documents and settings\Bureau\merge2.py", line 24, in <module>
    print instc.b_init
AttributeError: 'C' object has no attribute 'b_init'

我的类 C inerhite 类 A 和类 B 的属性和方法，我们添加了 c 属性。随着 C 的实例化 (instc = C(‘args’)) A 的 init 是调用而不是 B。

对我来说非常有用，因为我必须在不同的类上添加一些属性和方法（相同）。

原文由 user1062526 发布，翻译遵循 CC BY-SA 3.0 许可协议

Answer 2

我在调用不同的构造函数时遇到了麻烦，使用 super 在这种情况下不一定有意义，我选择手动继承并调用当前对象上的每个构造函数：

 class Foo(object):
    def __init__(self, foonum):
        super(Foo, self).__init__()
        self.foonum = foonum

class Bar(object):
    def __init__(self, barnum):
        super(Bar, self).__init__()
        self.barnum = barnum

class DiamondProblem(Foo, Bar):
    # Arg order don't matter, since we call the `__init__`'s ourself.
    def __init__(self, barnum, mynum, foonum):
        Foo.__init__(self, foonum)
        Bar.__init__(self, barnum)

        self.mynum = mynum

原文由 ThorSummoner 发布，翻译遵循 CC BY-SA 3.0 许可协议