在Python中, 继承是指子类对父类资源的使用权

1 继承-属性与方法的使用权限

1.1 测试属性与方法分别如下

公有属性/方法

受保护属性/方法

私有属性/方法

class Animal:
a = 1 # 公有属性
_b = 2 # 受保护属性
__c = 3 # 私有属性
#公有方法
def t1(self):
print("t1")
# 受保护方法
def _t2(self):
print("t2")
# 私有方法
def __t3(self):
print("t3")
# 内置方法
def __init__(self):
print("init, Animal")
class Person(Animal):
# 在实例对象(子类)内对以上属性及方法的访问权限
def test(self):
print(id(self.a)) # 打印地址的目的是为了证明子类对父类属性继承是`可以使用`，而非`拥有副本`
print(self.a)
print(self._b)
# print(self.__c) # 不能访问私有属性
self.t1()
self._t2()
# self.__t3() # 不能访问私有方法
self.__init__()
p = Person()
p.test()
print(id(Animal.a))
p.test()
>>>> 打印结果
init, Animal
4502964848
1
2
t1
t2
init, Animal
4502964848
4502964848
1
2
t1
t2
init, Animal

除私有的属性和私有的方法, 其他属性和方法子类基本都能继承(具有使用权)

2 继承-通过子类给父类属性进行赋值时，默认是指给之类增加一个与父类同名的属性

class Father:
age = 10
class Son(Father):
pass
print(Son.age) # 访问父类属性
Son.age = 9 # 给子类增加与父类同名属性
print(Son.age)
print(Father.age)
print(Son.__dict__)
print(Father.__dict__)
>>>>打印结果
10
9
10
{'__module__': '__main__', '__doc__': None, 'age': 9}
{'__module__': '__main__', 'age': 10, '__dict__': , '__weakref__': , '__doc__': None}

3 继承的3种形态


继承的3种形态

4 几种形态应该遵循的标准原则

4.1 单继承

遵循"从下到上的原则"

自己身上没有这个资源， 就到父类里面去找，父类里面没有再往上找

4.2 无重叠的多继承

遵循"单调原则"

按照继承的先后顺序，优先调用左侧继承链上的资源

4.3 有重叠的多继承

遵循"从下到上的原则"

简单理解就是：

A继承B继承C

B重写了C类的方法, 那么A优先使用B类的方法

4 查看类的资源查找顺序方法

通过inspect模块进行

目的：假如继承链中多个父类重写的资源，要学会查找哪些类的重写资源会被优先调用

# 导入资源查看模块 inspect
import inspect
class D(object):
pass
class B(D):
pass
class C(D):
pass
class A(B, C):
pass
# 方法一
print(inspect.getmro(A))
# 方法二
print(A.__mro__)
# 方法三
print(A.mro())
>>>>打印结果
(, , , , )
(, , , , )
[, , , , ]

TODO：《 针对于几种标准原则的方案演化》

不同 Python 版本 MRO 原则

菱形继承链问题

5 资源覆盖(MRO 优先级高的优先调用)

5.1 原理

基于MRO的资源检索链

优先级高的类具有一个与优先级低的类一样的一个资源(属性或方法)

会先选择优先级高的资源 ，而摒弃优先级低的资源(造成"覆盖"的假象)

class D(object):
age = "d"
pass
class C(D):
age = "c"
def test(self):
print("c")
pass
class B(D):
# age = "b"
def test(self):
print("b")
pass
class A(B, C):
pass
a = A()
a.test()
print(A.mro())
print(A.age)
print(A().test())
>>>>打印结果
b
[, , , , ]
c
b
None
5.2 调用优先级高资源时，self 与 cls 的变化
结论：谁调用，就是谁
class D(object):
pass
class C(D):
def test(self):
print(self)
pass
class B(D):
def test(self):
print(self)
@classmethod
def test2(cls):
print(cls)
pass
class A(B, C):
pass
A.test2()
a = A()
a.test()
>>>>打印结果

6 在低优先级类的方法中，通过"super"调用高优先级类的方法

Python3.x
class B:
a = 1
def __init__(self):
self.b = 2
self.xxx = "123"
def t1(self):
print("t1")
@classmethod
def t2(cls):
print(cls)
print("t2")
@staticmethod
def t3():
print("t3")
class A(B):
c = 3
def __init__(self):
super().__init__()
self.e = "666"
def tt1(self):
print("tt1")
@classmethod
def tt2(cls):
super().t2()
print("tt2")
@staticmethod
def tt3():
print("tt3")
pass
a = A()
print(a.__dict__)
print("-" * 20)
A.tt2()
>>>>打印结果
{'b': 2, 'xxx': '123', 'e': '666'}
--------------------
t2
tt2
Python2.2+
class B:
a = 1
def __init__(self):
self.b = 2
self.xxx = "123"
def t1(self):
print("t1")
@classmethod
def t2(cls):
print(cls)
print("t2")
@staticmethod
def t3():
print("t3")
class A(B):
c = 3
def __init__(self):
super(A, self).__init__()
self.e = "666"
def tt1(self):
print("tt1")
@classmethod
def tt2(cls):
super(A, cls).t2()
print("tt2")
@staticmethod
def tt3():
print("tt3")
pass
a = A()
print(a.__dict__)
print("-" * 20)
A.tt2()
>>>>打印结果
{'b': 2, 'xxx': '123', 'e': '666'}
--------------------
t2
tt2

注意

super 和父类(超类)没有实质性的关联

仅仅是沿着MRO链条, 找到下一级节点

保证调用形式的统一

要是类名调用, 全是类名调用

要是super调用, 全是super调用

(混合使用容易出现死循环)