继承
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| class Parent1:
pass
class Parent2:
pass
class Sub1(Parent1): # 单继承
pass
class Sub2(Parent1,Parent2): # 多继承
pass
# 查看继承关系
print(Sub1.__bases__)
print(Sub2.__bases__)
'''
(<class '__main__.Parent1'>,)
(<class '__main__.Parent1'>, <class '__main__.Parent2'>)
'''
|
再看英雄类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
class Hero:
def __init__(self,name,life_value,aggresivity):
self.name = name
self.life_value = life_value
self.aggresivity = aggresivity
def attack(self,enemy):
enemy.life_value -= self.aggresivity
class AX(Hero):
pass
ax = AX('斧王',30,40)
print(ax.__dict__) # {'name': '斧王', 'life_value': 30, 'aggresivity': 40}
|
属性查找顺序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| class Hero:
x = 1
y = 3
def __init__(self,name,life_value,aggresivity):
self.name = name
self.life_value = life_value
self.aggresivity = aggresivity
def attack(self,enemy):
enemy.life_value -= self.aggresivity
class AX(Hero):
pass
class Sevn(Hexo):
y = 4
pass
ax = AX('斧王',30,40)
ax.x # 1 自己本身没有去父类查找 如果父类没有报错
sevn = Sevn('斯温',50,60)
sevn.y # 4 子类有就不去父级查找
|
高深的属性查找，看你晕不晕
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| class Foo:
def f1(self):
print('from Foo.f1')
def f2(self):
print('from Foo.f2')
class Bar(Foo):
def f2(self):
print('from Bar.f2')
b = Bar()
b.f2() # from Bar.f2
------------------------------------------------------------------------
再看
------------------------------------------------------------------------
class Foo:
def f1(self):
print('from Foo.f1')
def f2(self):
print('from Foo.f2')
self.f1()
class Bar(Foo):
def f1(self):
print('from Bar.f1')
b = Bar()
b.f2()
'''
from Foo.f2
from Bar.f1 为啥是这个？不是就近吗？ 要看self是谁 self一直是b
'''
|
派生
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| class Hero:
def __init__(self,name,life_value,aggresivity):
self.name = name
self.life_value = life_value
self.aggresivity = aggresivity
def attack(self,enemy):
enemy.life_value -= self.aggresivity
class AX(Hero):
camp = '斧子'
def attack(self,enemy):
print('反刺螺旋')
pass
class Sevn(Hexo):
camp = '真男人'
def attack(self,enemy):
print('锤子')
pass
|
继承实现原理
- 子类会先于父类被检查
- 多个父类会根据它们在列表中的顺序被检查
- 如果对下一个类存在两个合法的选择,选择第一个父类
1
2
| class Foo(a1,a2,a3,a4....an):
pass
|
- 仅在python2中有 新式类和经典类
- python3中没有经典类 统一新式类
什么是新式类？
继承object的类，以及它的子类都叫 新式类
什么是经典类？
没有继承object的类，以及它的子类都称之为经典类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| # 经典类:没有继承object的类，以及它的子类都称之为经典类
# py2
class Foo:
pass
class Bar(Foo):
pass
# py2 继承object的类，以及它的子类都叫 新式类
class Foo(object):
pass
class Bar(Foo):
pass
# py3中 统一是新式类 (默认继承object)
class Foo:
pass
|
属性查找之——MRO列表
属性查找方式有
1
2
3
| 当类是经典类时：在要查找的属性不存在时，会按照深度优先的方式查找下去
当类是新式类时：在要查找的属性不存在时，会按照广度优先的方式查找下去
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| class A(object):
def test(self):
print('from A')
class B(A):
def test(self):
print('from B')
class C(A):
def test(self):
print('from C')
class D(B):
def test(self):
print('from D')
class E(C):
def test(self):
print('from E')
class F(D,E):
# def test(self):
# print('from F')
pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性
#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类
|
新式类的内置mro方法(广度优先)
经典类没有提供属性深度优先的查找方法