Py003-01-02继承

继承

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方法(广度优先)

1
F.mro() # 查看属性查找的顺序

经典类没有提供属性深度优先的查找方法