面向對象-繼承與派生

1.繼承

1.1繼承概念

繼承指的是類與類之間的關系，是一種什么“是”什么的關系，繼承的功能之一就是用來解決代碼重用問題。
繼承是一種創建新類的方式，在Python中，新建的類可以繼承一個或多個父類，父類可以成為基類或超類，新建的類成為派生類或子類

1.2python中類的繼承分類：單繼承和多繼承

class ParentClass1: #定義父類
    pass

class ParentClass2: #定義父類
    pass

class SubClass1(ParentClass1): #單繼承，基類是ParentClass1，派生類是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多繼承，用逗號分隔開多個繼承的類
    pass

1.3查看繼承

"__base__只查看從左到右繼承的第一個父類
__bases__查看所有繼承的父類"
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
class ParentClass1: #定義父類
    pass

class ParentClass2: #定義父類
    pass

class SubClass1(ParentClass1): #單繼承，基類是ParentClass1，派生類是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多繼承，用逗號分隔開多個繼承的類
    pass
print(SubClass1.__base__)
print(SubClass2.__base__)
print(SubClass1.__bases__)
print(SubClass2.__bases__)

E:\PythonProject\python-test\venvP3\Scripts\python.exe E:/PythonProject/python-test/BasicGrammer/test.py
<class '__main__.ParentClass1'>
<class '__main__.ParentClass1'>
(<class '__main__.ParentClass1'>,)
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

Process finished with exit code 0

1.4經典類與新式類

1.只有在Python2中才有新式類和經典類，Python3中全部都是新式類
2.在Python2中，如果沒有顯式的繼承object類，那該類和其子類都是經典類
3.在Python2中，如果顯式的繼承object類，那該類和其子類都是新式類
4.在Python3中，無論是否繼承object，都默認繼承object，即Python3中所有類都是新式類
5.在Python3中，如果沒有指定基類，會默認繼承object類，object是所有Python類的基類
print(ParentClass1.__bases__)
print(ParentClass2.__bases__)
E:\PythonProject\python-test\venvP3\Scripts\python.exe E:/PythonProject/python-test/BasicGrammer/test.py
(<class 'object'>,)
(<class 'object'>,)

Process finished with exit code 0

2.抽象與繼承

抽象：抽取類似的部分，主要用于劃分類別

繼承：基于抽象的結果，通過編程語言去實現它，所以需要先對事物或邏輯進行抽象，之后通過繼承的方式表達出抽象的結構

3.繼承與重用

在開發中，如果類A與類B有很多相同的代碼，就可以通過繼承來實現，提高代碼的重用性
可以讓B繼承A，B會‘遺傳’A的所有屬性（包含數據屬性和函數屬性）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
class Hero:
    def __init__(self,nickname,aggressivity,life_value):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value

    def attack(self,enemy):
        enemy.life_value-=self.aggressivity
class Garen(Hero):
    pass

class Riven(Hero):
    pass

g1=Garen('草叢倫',100,300)
r1=Riven('銳雯雯',57,200)

print(g1.life_value) #結果:300
r1.attack(g1)
print(g1.life_value) #結果:243

E:\PythonProject\python-test\venvP3\Scripts\python.exe E:/PythonProject/python-test/BasicGrammer/test.py
300
243

Process finished with exit code 0
"用已經有的類新建一個新的類，這樣就可以重用已經有的軟件中的部分代碼，大大節省編程工作量，這就是軟件重用，不僅可以重用自己的類，還可以繼承別人寫的類，也可繼承標準庫。"

4.屬性查找與self深入理解

不管是類中的數據屬性還是函數屬性，都是先在自己的類中查找，沒有，再到父類中查找

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
class Foo:
    def f1(self):
        print('Foo.f1')

    def f2(self):
        print('Foo.f2')
        self.f1()

class Bar(Foo):
    def f1(self):
        print('Bar.f1')

b=Bar()
#f2()在Bar類中沒有，就去父類Foo中找，父類中的f2又調用self.f1，同樣先去自己的類中找，找到了，就返回。
b.f2()

E:\PythonProject\python-test\venvP3\Scripts\python.exe E:/PythonProject/python-test/BasicGrammer/test.py
Foo.f2
Bar.f1

Process finished with exit code 0

5.派生

子類也可以添加自己的新屬性或重新定義父類中含有的數據屬性和函數屬性，子類中新定義的屬性對父類中的屬性是沒有影響的，但一旦重新定義的自己的屬性與父類中的屬性重名，調用新的屬性就以自己的為準了

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
class Hero:
    def __init__(self,nickname,aggressivity,life_value):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value

    def attack(self,enemy):
        enemy.life_value-=self.aggressivity
class Garen(Hero):
    pass

class Riven(Hero):
    camp='Noxus'
    def attack(self,enemy): #在自己這里定義新的attack,不再使用父類的attack,且不會影響父類
        print('from riven')
    def fly(self): #在自己這里定義新的
        print('%s is flying' %self.nickname)

g1=Garen('草叢倫',100,300)
r1=Riven('銳雯雯',57,200)
r1.attack(g1)

E:\PythonProject\python-test\venvP3\Scripts\python.exe E:/PythonProject/python-test/BasicGrammer/test.py
from riven

Process finished with exit code 0

在子類中，新建了與父類中重名的函數屬性，在編輯函數內功能的時候，有可能需要重用父類中的同名的那個函數，此時調用父類中同名函數的方法:類名.func()，此時就與調用普通函數相同了，因此self也要為其傳值

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
class Hero:
    def __init__(self,nickname,aggressivity,life_value):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value

    def attack(self,enemy):
        enemy.life_value-=self.aggressivity
class Garen(Hero):
    pass

class Riven(Hero):
    camp='Noxus'
    def __init__(self,nickname,aggressivity,life_value,skin):
        Hero.__init__(self,nickname,aggressivity,life_value) #調用父類功能
        self.skin=skin #新屬性
    def attack(self,enemy): #在自己這里定義新的attack,不再使用父類的attack,且不會影響父類
        Hero.attack(self,enemy) #調用功能
        print('from riven')
    def fly(self): #在自己這里定義新的
        print('%s is flying' %self.nickname)

r1=Riven('銳雯雯',57,200,'比基尼')
r1.fly()
print(r1.skin)

E:\PythonProject\python-test\venvP3\Scripts\python.exe E:/PythonProject/python-test/BasicGrammer/test.py
銳雯雯 is flying
比基尼

Process finished with exit code 0

6.深度優先與廣度優先

6.1MRO列表介紹

上面我們一直在說，對于數據屬性和函數屬性的查找，
首先找對象自身的定義空間，即對象.__dict__的結果，
如果沒有，去自己的類中找，
自己類中沒有，再去父類中找。
但是當繼承比較復雜，有多個父類，父類還有父類，這種情況下是怎樣的一個查找順序呢？
python有一個方法解析順序表（MRO），這個MRO列表就是一個屬性的查找順序列表，找到了相關的屬性就停止查找，否則就一直按照這個順序找到最后，找不到，就報錯了
>>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, 
<class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
MRO列表遵循三條準則：
1.子類優先于父類被檢查
2.多個父類會根據他們在列表中的順序去檢查
3.如果下一個類中存在兩個合法的選擇，選擇第一個父類

6.2新式類與經典類

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
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中才分新式類與經典類

E:\PythonProject\python-test\venvP3\Scripts\python.exe E:/PythonProject/python-test/BasicGrammer/test.py
from D
(<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

Process finished with exit code 0

"當C不繼承A了，新式類與經典類的順序就相同了"
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
class A(object):
    def test(self):
        print('from A')

class B(A):
    def test(self):
        print('from B')

class C:
    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__) #只有新式才有這個屬性可以查看線性列表，經典類沒有這個屬性
E:\PythonProject\python-test\venvP3\Scripts\python.exe E:/PythonProject/python-test/BasicGrammer/test.py
from D
(<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.E'>, <class '__main__.C'>, <class 'object'>)

Process finished with exit code 0

7.子類中調用父類的方法

7.1方式一：指名道姓，即父類名.方法名

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
class Vehicle:  # 定義交通工具類
    Country = 'China'

    def __init__(self, name, speed, load, power):
        self.name = name
        self.speed = speed
        self.load = load
        self.power = power

    def run(self):
        print('開動啦...')

class Subway(Vehicle):  # 地鐵
    def __init__(self, name, speed, load, power, line):
        Vehicle.__init__(self, name, speed, load, power)# 指名道姓方式，調用父類中同名的方法
        self.line = line

    def run(self):
        print('地鐵%s號線歡迎您' % self.line)
        Vehicle.run(self)# 指名道姓方式，調用父類中同名的方法

line13 = Subway('中國地鐵', '180m/s', '1000人/箱', '電', 13)
line13.run()

E:\PythonProject\python-test\venvP3\Scripts\python.exe E:/PythonProject/python-test/BasicGrammer/test.py
地鐵13號線歡迎您
開動啦...

Process finished with exit code 0

7.2super()方式

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
class Vehicle:  # 定義交通工具類
    Country = 'China'

    def __init__(self, name, speed, load, power):
        self.name = name
        self.speed = speed
        self.load = load
        self.power = power

    def run(self):
        print('開動啦...')

class Subway(Vehicle):  # 地鐵
    def __init__(self, name, speed, load, power, line):
        # super(Subway,self) # Python2的寫法  在python3中super()等同于super(Subway,self)
        super().__init__(name, speed, load, power)
        self.line = line

    def run(self):
        print('地鐵%s號線歡迎您' % self.line)
        #super(Subway, self).run()# Python2的寫法
        super().run() #Python3中，可以不在super()中寫類名和self

class Mobike(Vehicle):  # 摩拜單車
    pass

line13 = Subway('中國地鐵', '180m/s', '1000人/箱', '電', 13)
line13.run()

E:\PythonProject\python-test\venvP3\Scripts\python.exe E:/PythonProject/python-test/BasicGrammer/test.py
地鐵13號線歡迎您
開動啦...

Process finished with exit code 0

7.3兩種方式的區別

"方式一與屬性查找的mro順序沒有關系，直接指定了調用哪個類中的方法
方式二是會按照mro列表中的順序，向后查找相應的屬性"
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
# "A沒有繼承B,但是A內super會基于C.mro()繼續往后找"
class A:
    def test(self):
        super().test()
class B:
    def test(self):
        print('from B')
class C(A,B):
    pass

c=C()
c.test() #打印結果:from B
print(C.mro())

E:\PythonProject\python-test\venvP3\Scripts\python.exe E:/PythonProject/python-test/BasicGrammer/test.py
from B
[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]

Process finished with exit code 0