2. 程式人生 > 其它 >第十一章 (補充)面向物件繼承

第十一章 (補充)面向物件繼承

阿新 • • 發佈：2021-12-07
目錄

繼承

繼承簡介

  1. 繼承是一種建立新類的方式，新建的類可稱為子類或派生類，父類可稱為基類或超類
  2. python支援多繼承，新建的類可以支援一個或多個父類
'''單繼承和多繼承簡單定義'''
class Parent1:
    pass
class Parent2:
    pass
class Sub1(Parent1): #單繼承
    pass
print(Sub1.__bases__)  # 檢視自己的父類---->(<class '__main__.Parent1'>,)
 
class Sub2(Parent1,Parent2): # 多繼承
    pass
print(Sub2.__bases__)    # 檢視自己的父類---->(<class '__main__.Parent1'>, <class '__main__.Parent2'>)

經典類與新式類

在py2中有經典類和新式類的區別：

  • 新式類：繼承了object類的子類，以及該子類的子類，子子類
  • 經典類：沒有繼承object類的子類，以及該子類的子類，子子類
'''py2中'''
class Foo:
    pass     # 經典類
class Bar(object):
    pass     # 新式類

注意：在py3中沒有繼承任何類，預設繼承object類，所以python3中都是新式類

'''py3中'''
class Foo():
    pass
print(Foo.__bases__) # --->(<class 'object'>,),預設繼承object類
 
class Sub(Foo):
    pass
 
print(Sub.__bases__) # ---->(<class '__main__.Foo'>,)

類繼承解決了什麼問題

  • 類解決物件與物件之間程式碼冗餘的問題,子類可以遺傳父類的屬性
  • 繼承解決的是類與類之間程式碼冗餘的問題
  • object類豐富了程式碼的功能

示例如下：

'''學生選課系統和老師打分功能'''
# 學生類
class Student():
    def __init__(self,name,age,gender,course = None):
        self.name = name
        self.age = age
        self.gender = gender
        self.course = course
    # 定義一個選課的方法
    def choose_course(self,course):
        if self.course is None:
            self.course = []
        self.course.append(course)
        print(f"Student choice class --->{self.course}")
 
# 教師類
class Teacher():
    def __init__(self,name,age,gender,level):
        self.name = name
        self.age = age
        self.gender = gender
        self.level = level
    # 定義一個打分方法
    def make_score(self,stu_obj,score):
        stu_obj.score = score
        print(f'Teacher{self.name} make {stu_obj.score} to {stu_obj.name}! ')
    
'''有很多冗餘的程式碼，優化一下，定義一個人的類整合一下重複的程式碼'''
# 人類
class Human():
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
 
 
# 學生類
class Student(Human):
    def __init__(self, name, age, gender, score=None, course=None):
        Human.__init__(self, name, age, gender)
        self.score = score
        self.course = course
 
    # 定義一個選課的方法
    def choose_course(self, course):
        if self.course is None:
            self.course = []
        self.course.append(course)
        print(f"Student choice class --->{self.course}")
 
 
# 教師類
class Teacher(Human):
    def __init__(self, name, age, gender, level):
        Human.__init__(self, name, age, gender)
        self.level = level
 
    # 定義一個打分方法
    def make_score(self, stu_obj, score):
        stu_obj.score = score
        print(f'Teacher{self.name} make {stu_obj.score}marks to {stu_obj.name}! ')
 
 
# 學生類例項化
stu = Student('HammerZe', 18, 'male')
stu.choose_course('python')
 
# 教師類例項化
teacher = Teacher('li', 18, 'male', 10)
teacher.make_score(stu, 90)
 
Student choice class --->['python']
Teacherli make 90marks to HammerZe!

多繼承的優缺點

  • 優點：子類可以同時遺傳多個父類的屬性，最大限度的重用程式碼
  • 缺點：違反人的思維習慣，一個人有兩個爹，程式碼的可讀性會變差，不建議使用多繼承，如果不可避免多個父類的繼承，應該使用Mixins機制
  • 繼承表達的是一種“是”什麼關係

Mixins機制

  • 多繼承的正確開啟方式：mixins機制
  • mixins機制核心：就是在多繼承背景下儘可能底提升多繼承的可讀性
  • 讓多繼承滿足人的思維習慣--->什麼“是”什麼
class Vehicle:
    pass
class FlyableMixin:   # 規範多繼承
    def fly(self):
        pass
# 民航飛機
class CiviAircraft(FlyableMixin,Vehicle)
	pass
#直升機
class Helicopter(FlyableMixin,Vehicle)
	pass
class Car(Vehicle)
	pass 
 
'''表達是的關係，放在繼承的末尾，特們都是交通工具'''
 
'''eg：飛機有飛的功能，是交通工具'''
 
如果有多個功能就必須寫多個Mixin類！

繼承的查詢順序

  • 物件>子類>父類>父父類
  • 單繼承背景下屬性查詢

示例如下：

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')
 
 
obj = Bar()
obj.f2()
# 結果
Foo.f2
Bar.f1
 
'''查詢順序：
1.obj先從obj名稱空間找，再從Bar名稱空間中找，沒有f2去他爹(Foo)中找
2.執行Foo中得f2，遇到self.f1()此時self是obj，是Bar的物件
3.執行Bar中的f1
'''
 
 
# 區別下:父類不想讓子類的方法覆蓋，可以私有化
class Foo:
    def __f1(self):  # _Foo__f1()
        print('Foo.f1')
 
    def f2(self):
        #
        print('Foo.f2')
        self.__f1()  # _Foo__f1()
 
 
class Bar(Foo):
    def __f1(self):  # # _Bar__f1()
        print('Bar.f1')
 
obj = Bar()
obj.f2()
 
# 結果
Foo.f2
Foo.f1
'''Foo中f1私有化，所以輸出的是Foo中的f1'''

多繼實現原理

菱形結構

在python中可以繼承多個類，這樣就會引發下面的結構：

  • 當D繼承B和C，B、C分別繼承A就會組成一個菱形的繼承關係，這樣就會涉及到查詢屬性的順序問題，A、B、C、中如果方法重名，輸出的順序是按mro列表輸出的順序繼承

示例如下：

'''py3中'''
 
class A():
    def out_text(self):
        print('from A')
 
class B(A):
    def out_text(self):
        print('from B')
 
class C(A):
    def out_text(self):
        print('from C')
 
class D(B,C):
    pass
 
obj = D()
obj.out_text() # 結果---->from B
''' 可以打印出mro列表檢視順序'''
print(D.mro())
# [<class '__main__.D'>,
# <class '__main__.B'>, 
# <class '__main__.C'>, 
# <class '__main__.A'>,
# <class 'object'>]
 
'''這樣看來查詢順序就顯而易見了，
1、從D中找out_text方法，沒有直接去B
2、B中有out_text方法，直接輸出停止查詢'''
  • mro列表查詢準則：
    1. 子類先查，再查父類
    2. 當繼承多個父類的時候，按mro列表順序被檢查
    3. 如果繼承多個類，被繼承類內具有相同的方法，先輸出mro列表左邊類的方法
  • 注意：mro列表可以寫成__mro__也可以，呼叫mro方法的必須是起始類，obj是D的物件，所以用D.mro()
  • mro列表是通過一個C3線性演算法來實現的

非菱形結構

程式碼實現如下：

'''py3中'''
 
 
class E:
    pass
 
 
class F:
    pass
 
 
class B(E):
    pass
 
 
class C(F):
    pass
 
 
class D:
    def test(self):
        print('from D')
 
 
class A(B, C, D):
    pass
 
 
print(A.mro())
'''
查詢順序如下：
[<class '__main__.A'>, 
<class '__main__.B'>, 
<class '__main__.E'>, 
<class '__main__.C'>, 
<class '__main__.F'>, 
<class '__main__.D'>,
 <class 'object'>]
'''
 
obj = A()
obj.test()  
# 結果為：from D

深度優先和廣度優先

深度優先：

  • 經典類：按深度優先查詢

經典類查詢順序如下：

在py2中，沒有繼承object的類及其子類都是經典類

程式碼實現：

'''py2中'''
class G:
    def test(self):
        print('from G')
class E(G):
    def test(self):
        print('from E')
class F(G):
    def test(self):
        print('from F')
class B(E):
    def test(self):
        print('from B')
class C(F):
    def test(self):
        print('from C')
class D(G):
    def test(self):
        print('from D')
 
class A(B, C, D):
    pass
 
 
obj = A()
obj.test()  # 查詢順序為:obj->A->B->E->G->C->F->D->object
 
# 結果
from B

廣度優先：

  • 新式類：按廣度優先順序查詢

新式類查詢順序如下：

在py3中，預設為新式類

程式碼實現如下：

'''py3中'''
class G:
    def test(self):
        print('from G')
class E(G):
    pass
class F(G):
    pass
class B(E):
    pass
class C(F):
    pass
class D(G):
    def test(self):
        print('from D')
 
class A(B, C, D):
    pass
 
 
obj = A()
obj.test() # 查詢順序為:obj->A->B->E->C->F->D->G->object
 
# 結果
from D

super（）方法

super（）方法的存在就是為了解決多重繼承的問題，在一個父類中使用super（）方法用於呼叫下一個父類的方法

  • super方法
class A:
    def test(self):
        print('from A')
        super().test()
'''用於呼叫下一個父類的方法B.test'''
 
class B:
    def test(self):
        print('from B')
 
 
class C(A, B):
    pass
 
 
c = C()
c.test()
print(C.mro())
# 查詢順序如下
#[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
 
# 結果
from A
from B

抽象類

python的抽象類需要藉助模組實現，抽象類是一個特殊的類，它只能被繼承，不能被例項化

  • 作用：在不同的模組中通過抽象基類來呼叫，可以用最精簡的方式展示出程式碼之間的邏輯關係，讓模組之間的依賴清晰簡單，使得程式碼的可讀性變高。
  • 注意：子類繼承抽象類的時候，必須定義相同方法對抽象類的方法進行覆蓋
import abc
# 抽象類： 抽象類只能被繼承，不能被例項化
class Animal(metaclass=abc.ABCMeta):
 
    @abc.abstractmethod  # 該方法已經是抽象方法了
    def speak(self): pass
 
    @abc.abstractmethod
    def login(self):pass
 
class People(Animal):
    def speak(self):
        print('嗷嗷嗷')
 
    def login(self):
        pass
 
 
class Pig(Animal):
    def speak(self):
        print('哼哼哼')
 
 
class Dog(Animal):
    def speak(self):
        print('汪汪汪')
 
 
obj = People()
obj.speak()

方法補充：

  1. sel.__class__檢視物件所屬類

  2. 類名/物件名.__dict__檢視類/物件名稱空間

  3. 類名/物件名.__bases__檢視父類

  4. 起始類名.__mro__列印繼承順序，py3從左到右查詢

  5. locals()檢視區域性名稱空間

  6. globals()檢視全域性名稱空間

  7. dirs(str)檢視字串所搭配的內建方法有哪些，檢視內容可換

相關推薦

第十一章 (補充)面向物件繼承

目錄繼承繼承簡介經典類與新式類類繼承解決了什麼問題多繼承的優缺點Mixins機制繼承的查詢順序多繼實現原理菱形結構非菱形結構深度優先和廣度優先深度優先：廣度優先：super（）方法抽象類方法補充：

第十一章 初識面向過程面向物件

目錄面向過程的概念面向物件類的定義和物件的產生給物件定製自己獨有的屬性屬性的查詢順序

《UNIX環境高階程式設計》(APUE) 筆記第十一章 - 執行緒

11 - 執行緒 Github 地址 1. 執行緒概念 典型的 UNIX程式 可以看成只有一個 控制執行緒 ：一個程式在某一時刻只能做一件事情。有了 多個控制執行緒 ，就可以把程式設計成在某一時刻能夠做不止一件事，每個執行緒處理

第十一章-js事件

事件繫結和事件冒泡 題目 編寫一個通用的事件監聽函式 描述事件冒泡的流程 無限下拉圖片列表，如何監聽每個圖片的點選

"C++ Primer" 讀書筆記 第十一章 泛型演算法

　　首先我們注意一下第十章 關聯容器中有哪些需要注意的： 順序容器是通過元素在容器中的位置訪問的，而關聯容器則是通過元素的鍵 (key)進行訪問的

第十一章 vim變數，檔案比對，開啟多個檔案

Vim變數 :setnu#顯示行號:setlist#給每一行的結尾加上製表符:set ic#搜尋忽略大小寫:noh#取消高亮:set nonu#取消顯示行號:set nolist#取消顯示製表符:set noic#取消忽略大小寫​兩個配置檔案~/.vimrc#個人使用者的vi

第十一章：Python高階程式設計-協程和非同步IO

第十一章：Python高階程式設計-協程和非同步IO Python3高階核心技術97講 筆記 目錄

第十一章、一對多

第十一章、一對多 比如一個老師擁有多個學生 按照結果巢狀處理 1 <resultMap id=\"TeacherStudent\" type=\"Teacher\">

《QT Creator快速入門》第十一章（二）：動畫框架和狀態機

一、動畫框架 Qt中的動畫框架可以在幫助中檢視The Animation Framework關鍵字，主要的類如下圖所示，基類QAbstractAnimation中定義了動畫開始、暫停、停止等方法，它也可以接收時間變化的通知，通過整合它可以建立自

《QT Creator快速入門》第十一章（一）：圖形檢視

一、圖形檢視框架結構 圖形檢視框架由場景QGraphicsScene、檢視QGraphicsView、圖形項QGraphicsItem組成，它提供了一套基於圖形項模型檢視程式設計方法。圖形檢視框架可以管理數量龐大的自定義2D圖形項，比如要繪製

第十一章、AQS

一、AQS簡介 　　AQS是AbstractQueuedSynchronizer的簡稱，即抽象佇列同步器，從字面意思上理解:

第十一章 MySQL日誌詳解

一、錯誤日誌 1.錯誤日誌預設是開啟的 2.預設儲存 $datadir 下面，預設的名字是 \'主機名\'.err

第十一章、正則表示式

第十一章、正則表示式 基本概述 由事先定義好的特殊字元以及這些特殊字元組成，組成一個“規則的表示式”，這是表示式用來

第十一章 併發控制：

技術標籤：資料庫 第十一章 併發控制： 學習內容： 併發控制概述封鎖封鎖協議活鎖與死鎖併發排程的可序列性兩段鎖協議封鎖的粒度

Oracle零基礎到精通【PPT】第十一章 控制語句

知識點回顧 理解 PL/SQL 功能和特點 瞭解資料型別及其用法 理解邏輯比較 掌握錯誤處理 [說明]從本章開始學習Oracle程式設計，這在實際專案開發中同樣有廣泛的應用

深入理解計算機系統（第三版）第十一章重要內容摘要

11.1客戶端-伺服器程式設計模型 11.2網路 11.3全球IP因特網 13.3.1 IP地址 11.3.2因特網域名

【ZYNQ Ultrascale+ MPSOC FPGA教程】第十一章 RS232實驗

原創宣告： 本原創教程由芯驛電子科技（上海）有限公司（ALINX）創作，版權歸本公司所有，如需轉載，需授權並註明出處。

第十一章 Caché 變數大全 $PRINCIPAL 變數

技術標籤：Caché 變數大全CachéCacheprincipal系統變數基礎變數 文章目錄 第十一章 Caché 變數大全 $PRINCIPAL 變數

MySql的初學習 -- 第十一章 -- 觸發器

技術標籤：MySql學習觸發器mysql資料庫sql MySql的初學習 -- 第十一章 -- 觸發器 什麼是觸發器觸發器的建立要素建立觸發器

16進位制轉base64_第十一章（第3節）：base64

技術標籤：16進位制轉base64 我們知道在計算機中任何資料都是按位元組儲存的，有的複雜的資料（比如漢字）可能由多個位元組表示，簡單（比如單個英文字元）的由 1 個位元組表示，位元組是記憶體中基本的儲存單位