Python 如何从父类扩展列表？

我有以下代码。父类有一个项目列表，子类需要添加到该列表中

父对象的每个实例都需要这个列表，每个子对象都需要这个列表+额外的值

class Parent(object):
    a_list = ['parent_item1', 'parent_item2', ]

    def print_list(self):
        print(self.a_list)


class Child1(Parent):
    def __init__(self, *args, **kwargs):
        super(Child1, self).__init__(*args, **kwargs)
        self.a_list += ['child1_item']


class Child2(Parent):
    def __init__(self, *args, **kwargs):
        super(Child2, self).__init__(*args, **kwargs)
        self.a_list += ['child2_item']


parent = Parent()
child1 = Child1()
child2 = Child2()

parent.print_list()
    # >> ['parent_item1', 'parent_item2', 'child1_item', 'child2_item']
child1.print_list()
    # >> ['parent_item1', 'parent_item2', 'child1_item', 'child2_item']
child2.print_list()
    # >> ['parent_item1', 'parent_item2', 'child1_item', 'child2_item']

如何得到以下结果

['parent_item1', 'parent_item2', ]
['parent_item1', 'parent_item2', 'child1_item', ]
['parent_item1', 'parent_item2', 'child2_item', ]

---

list+=other_list

在适当的位置扩展列表。使用返回新列表的

+

运算符：

class Parent(object):
    a_list = ['parent_item1', 'parent_item2', ]
    def print_list(self):
        print(self.a_list)

class Child1(Parent):
    def __init__(self, *args, **kwargs):
        super(Child1, self).__init__(*args, **kwargs)
        self.a_list = self.a_list + ['child1_item']  # <-------

class Child2(Parent):
    def __init__(self, *args, **kwargs):
        super(Child2, self).__init__(*args, **kwargs)
        self.a_list = self.a_list + ['child2_item']  # <-------


parent = Parent()
child1 = Child1()
child2 = Child2()
parent.print_list()
child1.print_list()
child2.print_list()

---

或者，您可以制作父类列表的副本：

...
self.a_list = self.a_list[:]
self.a_list += ['child1_item']

---

您想为

父级

创建一个构造函数。问题是它们都共享在声明

Parent

时创建的相同列表。相反，您希望：

class Parent(object):
    def __init__(self):
        self.a_list = ['parent_item1', 'parent_item2', ]
    def print_list(self):
        print(self.a_list)

---

这样，每当你构建一个父项时，你都会创建一个全新的列表，其中包含

['Parent\u item1'，'Parent\u item2'，]

我解决了这个问题，解决方案非常简单明了。不需要super或init（）

---

您可以使用元类作为类属性获取更新的列表，而不是在每个使用元类的类中编写相同的代码。我不确定如果没有元类，同样的东西是否可以，如果可以，请让我知道

class A(type):                                                
    foo = ['a']
                                                              
    def __new__(self, name, classes, dct):                    
        foo = dct.get('foo')
        if foo:                                               
            dct['foo'] = self.foo + foo                       
        return type.__new__(self, name, classes, dct)                                    
                                                              
                                                              
class B(metaclass=A):                                         
    foo = ['b']      

A.foo 
# >> ['a']
B.foo 
# >> ['a', 'b']
                                     

---

美好的不过，我不同意

super

不是“简单干净”的说法。

super

方法被设计用来代替按名称显式引用父类。这样，如果更改当前类的继承树，

super

会自动解决任何引用问题。

class Parent(object):
    a_list = ['parent_item1', 'parent_item2', ]

    def print_list(self):
        print(self.a_list)


class Child1(Parent):
    a_list = Parent.a_list + ['child1_item', ]


class Child2(Parent):
    a_list = Parent.a_list + ['child2_item', ]


parent = Parent()
child1 = Child1()
child2 = Child2()

parent.print_list()
    # >> ['parent_item1', 'parent_item2', ]
child1.print_list()
    # >> ['parent_item1', 'parent_item2', 'child1_item', ]
child2.print_list()
    # >> ['parent_item1', 'parent_item2', 'child2_item']

class A(type):                                                
    foo = ['a']
                                                              
    def __new__(self, name, classes, dct):                    
        foo = dct.get('foo')
        if foo:                                               
            dct['foo'] = self.foo + foo                       
        return type.__new__(self, name, classes, dct)                                    
                                                              
                                                              
class B(metaclass=A):                                         
    foo = ['b']      

A.foo 
# >> ['a']
B.foo 
# >> ['a', 'b']