6-2面向對象的組合和繼承以及多繼承

一 組合概念

一個類的對象做爲另一個類對象的屬性
第一個例子：

 2 class Weapon:
 3     def prick(self, obj):  # 這是該裝備的主動技能,扎死對方
 4         obj.life_value -= 500  # 假設攻擊力是500
 5 
 6 class Person:  # 定義一我的類
 7     role = 'person'  # 人的角色屬性都是人
 8 
 9     def __init__(self, name):
10         self.name = name  # 每個角色都有本身的暱稱;
11         self.weapon = Weapon()  # 給角色綁定一個武器;
12         
13 egg = Person('egon')
14 egg.weapon.prick() 
15 #egg組合了一個武器的對象，能夠直接egg.weapon來使用組合類中的全部方法

第二個例子計算圓環的面積

 1 from math import pi
 2 class Circle:
 3     def __init__(self,r):
 4         self.r = r
 5     def area(self):
 6         return pi * self.r ** 2 #求園的面積
 7     def perimeter(self):
 8         return self.r *pi * 2  #求園的周長
 9 
10 class Ring:
11     def __init__(self,outside_r,inside_r):
12         self.out_circle = Circle(outside_r)
13         self.in_circle = Circle(inside_r)
14     def area(self):
15         return self.out_circle.area() - self.in_circle.area() #外環面積-內環面積
16     def perimeter(self):
17         return self.out_circle.perimeter() + self.in_circle.perimeter()
18 
19 r = Ring(10,5)   #外環的半徑和內環的半徑
20 print(r.area())
21 print(r.perimeter())

 二 繼承

繼承是一種建立新類的方式，在python中，新建的類能夠繼承一個或多個父類，父類又可稱爲基類或超類，新建的類稱爲派生類或子類
例子： 人狗大戰

 1 class Animal: #父類
 2     def __init__(self,name,dps,hp):
 3         self.name=name
 4         self.dps=dps
 5         self.hp=hp
 6     def eat(self):
 7         print('%s吃藥,回血了'%(self.name))
 8 class Person(Animal):#子類
 9     def __init__(self,name,dps,hp,sex):
10         super().__init__(name,dps,hp)   #第二中寫法  Animal.__init__(self,name,dps,hp)
11 
12         self.sex=sex
13     def attack(self,dog):
14         dog.hp -= self.dps
15         print('%s打了%s,%s掉了%s點血，%s還剩%s點血'%(self.name,dog.name,dog.name,self.dps,dog.name,dog.hp))
16 
17 class Dog(Animal):#子類
18     def __init__(self,name,dps,hp,kind):
19         super().__init__(name,dps,hp)
20         self.kind=kind
21     def bite(self,person):
22         person.hp -= self.dps
23         print('%s咬了%s,%s掉了%s點血，%s還剩%s點血' % (self.name, person.name, person.name, self.dps, person.name, person.hp))
24 alex=Person('alex',5,250,'男')
25 ha2=Dog('小黑',200,2000,'藏獒')
26 print(alex.__dict__)
27 print(ha2.__dict__)
28 alex.attack(ha2)
29 ha2.bite(alex)
30 ha2.eat()

例子2

class Foo:
    def __init__(self):
        self.func()
    def func(self):
        print('in Foo')

class Son(Foo):

    def func(self):
        print('in Son')
Son() 

#打印結果是in son

實例化了一個對象，找本身方法裏面的self，而後再去執行父類裏面的self也就是son裏面是self，而後又去調用func,因此打印in son

 三多繼承

# python兩種類
    # 經典類 py3已經滅絕了 在python2裏還存在，在py2中只要程序員不主動繼承object，這個類就是經典類   —— 深度優先
    # 新式類 python3全部的類都
鑽石繼承

 1 class A:
 2     def f(self):
 3         print('in A')
 4 
 5 class B(A):
 6     def f(self):
 7         print('in B')
 8         super().f()
 9 
10 class C(A):
11     pass
12     def f(self):
13         print('in C')
14         super().f()
15 
16 class D(B,C):
17     def f(self):
18         print('in D')
19         super().f()
20 
21 d = D()
22 d.f()
23 print(D.mro()) #能夠查看繼承的順序
打印結果

in D
in B
in C
in A
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

#super和找父類這件事是兩回事
# 在單繼承中 super就是找父類
# 在多級承中 super的軌跡 是根據整個模型的起始點而展開的一個廣度優先順序 遵循mro規則

例子2

 1 class A:
 2     def f(self):
 3         print('in A')
 4 
 5 class B(A):
 6     pass
 7     # def f(self):
 8     #     print('in B')
 9 
10 class C(A):
11     pass
12     # def f(self):
13     #     print('in C')
14 
15 
16 class D(B,C):
17     pass
18     # def f(self):
19     #     print('in D')
20 
21 class E(C):
22     pass
23     # def f(self):
24     #     print('in B')
25 
26 class F(D,E):
27     pass
28     # def f(self):
29     #     print('in C')
30 
31 # d = D()
32 # d.f()
33 
34 print(F.mro())