Python 进阶技巧: 类与继承

1class B(A1,A2,...,An)

1mro(B) = [B] + merge(mro(A1), mro(A2),...,mro(An), [A1,A2,...,An])

1class A(object):pass
2class B(object):pass
3class C(object):pass
4class E(A,B):pass
5class F(B,C):pass
6class G(E,F):pass

1mro(E) = [E] + merge(mro(A), mro(B), [A,B])
2       = [E] + merge([A,O], [B,O], [A,B])
3       = [E,A] + merge([O], [B,O], [B])
4       = [E,A,B] + merge([O], [O])
5       = [E,A,B,O]

 1def c3MRO(cls):
 2    if cls is object:
 3        # 讨论假设顶层基类为object，递归终止
 4        return [object]
 5
 6    # 构造C3-MRO算法的总式，递归开始
 7    mergeList = [c3MRO(baseCls) for baseCls in cls.__bases__]
 8    mergeList.append(list(cls.__bases__))
 9    mro = [cls] + merge(mergeList)
10    return mro
11
12
13def merge(inLists):
14    if not inLists:
15        # 若合并的内容为空，返回空list
16        # 配合下文的排除空list操作，递归终止
17        return []
18
19    # 遍历要合并的mro
20    for mroList in inLists:
21        # 取head
22        head = mroList[0]
23        # 遍历要合并的mro（与外一层相同），检查尾中是否有head
24        ### 此处也遍历了被取head的mro，严格地来说不符合标准算法实现
25        ### 但按照多继承中地基础规则（一个类只能被继承一次），
26        ### head不可能在自己地尾中，无影响，若标准实现，反而增加开销
27        for cmpList in inLists[inLists.index(mroList) + 1:]:
28            if head in cmpList[1:]:
29                break
30        else:
31            # 筛选出好head
32            nextList = []
33            for mergeItem in inLists:
34                if head in mergeItem:
35                    mergeItem.remove(head)
36                if mergeItem:
37                    # 排除空list
38                    nextList.append(mergeItem)
39            # 递归开始
40            return [head] + merge(nextList)
41    else:
42        # 无好head，引发类型错误
43        raise TypeError

 1class A:
 2    def __init__(self):
 3        print('A')
 4class B:
 5    def __init__(self):
 6        print('B')
 7class C(A,B):
 8    def __init__(self):
 9        super(C,self).__init__()
10        print('C')
11class D(B,A):
12    def __init__(self):
13        super(B,self).__init__()
14        print('D')
15print(C.__mro__)
16print(D.__mro__)
17print('initi C:')
18c = C()
19print('initi D:')
20d = D()
21
22# (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
23# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
24# initi C:
25# A
26# C
27# initi D:
28# A
29# D

 1class A:
 2    def __init__(self):
 3        self.n = 2
 4
 5    def add(self, m):
 6        print('self is {0} @A.add'.format(self))
 7        self.n += m
 8
 9
10class B(A):
11    def __init__(self):
12        self.n = 3
13
14    def add(self, m):
15        print('self is {0} @B.add'.format(self))
16        super().add(m)
17        self.n += 3
18
19b = B()
20b.add(2)
21print(b.n)
22
23# self is <__main__.B object at 0x106c49b38> @B.add
24# self is <__main__.B object at 0x106c49b38> @A.add
25# 8

1class A:
2    name = "AAA"
3    def f(self):
4        print("f")
5
6print(A.__dict__)
7
8# {'__module__': '__main__', 'name': 'AAA', 'f': <function A.f at 0x105b340d0>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}

1def f(self):
2    print("f")
3dic = {
4    "name": "AAA",
5    "f": f
6}
7
8A = type('A', (), dic)

 1class Example1(object):
 2    def __new__(cls):
 3        return super(Example1, cls).__new__(cls)
 4
 5
 6class Example2(object):
 7    def __new__(cls):
 8        pass
 9
10
11print('For Example1: %s' % Example1())
12print('For Example2: %s' % Example2())
13
14# For Example1: <__main__.Example1 object at 0x021B36B0>
15# For Example2: None

1class M(type):
2    def __new__(cls, name, bases, dict):
3        return type.__new__(cls, name, bases, dict)
4    
5    def __init__(self, name, bases, dict):
6        return type.__init__(self, name, bases, dict)
7    
8    def __call__(cls, *args, **kwds):
9        return type.__call__(cls, *args, **kwds)

1# 静态方法
2class A(metaclass=M):
3	...
4
5# 动态方法
6A = M('A', (), dic)