day-25-類的繼承順序-父類對子類的約束-多型-佇列和棧

先生 發表於 2021-05-03

一、類的繼承順序

只要繼承object類就是新式類

不繼承object類的都是經典類

 

在python3 中所有的類都繼承object類,都是新式類

在python2 中不繼承object的類都是經典類

繼承object類的就是新式類

 

經典類:在py3中不存在,在py2中不主動繼承object類

 

  • 在py2 中

    • class A:pass ——> 經典類

    • class B(object):pass ——> 新式類

  • 在py3 中

    • class A:pass ——> 新式類

    • class B(object):pass ——> 新式類

在單繼承方面(無論是新式類還是經典類都是一樣的)

用的是深度優先方法

尋找某一個方法的順序是:D-->C-->B-->A

越往父類走,是深度

class A:
    def func(self):pass
class B(A):
    def func(self):pass
class C(B):
    def func(self):pass
class D(C):
    def func(self):pass
d = D()

 

多繼承方面

  • 廣度優先——>在走到一個點,下一個點既可以從深度走,也可以從廣度走的時候,總是先走廣度,在走深度

  • 在經典類中,都是深度優先,總是在一條路走不通之後在換一條路,走過的點不會在走了

  • 在新式類中有 mro() ,可以檢視尋找順序

class A:
    def func(self):
        print('A')
class B(A):
    def func(self):
        print('B')
class C(A):
    def func(self):
        print('C')
class D(B,C):
    def func(self):
        print('D')
        
d = D()
d.func()
print(D.mro())   # 只有在新式類中有,經典類沒有
# 輸出
D
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

 

  • C3演算法:

如果是單繼承:那麼總是按照從子類——>父類的順序來計算查詢順序。

如果是多繼承:需要按照自己本類,父類1的繼承順序,父類2的繼承順序.......

merge的規則(C3):

1、如果一個類出現在從左側到右所有順序的最左側,並且沒有在其他位置出現,那麼先提出來作為繼承順序的中的一個

2、或 一個類出現在從左側到右順序的最左側, 並沒有在其他順序中出現 ,那麼先提出來作為繼承順序的中的一個

3、如果從左到右第一個順序中的第一個類出現在後面且不是第一個,那麼不能提取,順序向後繼續找其他順序中符合上述條件的類

在多繼承中:經典類——>是深度優先

新式類——>是廣度優先,遵循C3演算法,可以用mro()檢視順序

class A: pass
class B(A): pass
class C(A): pass
class D(B): pass
class E(C): pass
class F(D, E): pass
​
​
C3演算法
A(O) = [AO]     ——>A的繼承關係 (O==>object)
B(A) = [BAO]    ——>B的繼承關係
C(A) = [CAO]    ——>C的繼承關係
D(B) = [DBAO]   ——>D的繼承關係
E(C) = [ECAO]   ——>E的繼承關係
F(D,E)  = merge(D(B) + E(C))    ——>F的繼承關係
​
繼承順序  = [F] + [DBAO] + [ECAO]  ——>自己類加上兩個父類的繼承順序
      F  = [DBAO] + [ECAO]      ——>取出左側第一個F(條件右側沒有F)
     FD  = [BAO] + [ECAO]       ——>取出左側第一個D(條件右側沒有D)
    FDB  = [AO] + [ECAO]        ——>左側第一個A,右側有A,跳過取右側第一個E
   FDBE  = [AO] + [CAO]         ——>同上取右側第一個C
  FDBEC  = [AO] + [AO]          ——>兩邊都是相同的取第一個A
 FDBECA  = [O] + [O]            ——>同上在取第一個O
FDBECAO     ——>最終繼承順序

 

二、父類對子類的約束

抽象類:是一個開發的規範,約束它的所有子類必須實現一些和它同名的方法

列如:支付程式。

  • 微信支付 URL連結,告訴你引數什麼格式

    • { ' username ' : ' 使用者名稱 ' , ' money ' : 200 }

  • 支付寶支付 URL連結,告訴你引數什麼格式

    • { ' uname ' : ' 使用者名稱 ' , ' price' : 200 }

方法一:

class Payment:  # 這是個抽象類
    def pay(self, money):
        '''
        只要你見到了專案中有這種類,你要知道你的子類中必須實現和pay同名的方法
        '''
        raise NotImplementedError('請在類中重寫重名pay類方法') # 主動拋異常
class WeChat(Payment):
    def __init__(self, username):
        self.username = username
​
    def pay(self, money):  # pay方法名字不能改變
        dic = {'username': self.username, 'money': money}
        '''
        呼叫微信支付 url連線 把dic傳過去
        '''
        print(f'{self.username}通過微信充值了{money}')
​
class Alipay(Payment):
    def __init__(self, username):
        self.username = username
​
    def pay1(self, money):
        dic = {'uname': self.username, 'price': money}
        ''''
        呼叫支付寶支付 url連線 把dic傳過去
        '''
        print(f'{self.username}通過支付寶充值了{money}')
​
# 歸一化設計:同事或使用者使用此類時,直接呼叫pay函式傳參,不用自己建立物件
def pay(username, money, kind):
    if kind == 'WeChat':
        obj = WeChat(username)
    elif kind == 'Alipay':
        obj = Alipay(username)
    obj.pay(money)
​
pay('小楊', 200, 'WeChat')
​
# 當支付寶的pay方法名字發生改變時
pay('小楊', 200, 'Alipay')
​
# 輸出
小楊通過微信充值了200
報錯:NotImplementedError: 請在類中重寫重名pay類方法

 

方法二:實現抽象類的另一種方式,約束力強,依賴abc模組

from abc import ABCMeta, abstractmethod
​
class Payment(metaclass=ABCMeta):  # 這是個抽象類
    @abstractmethod
    def pay(self, money):
        passclass WeChat(Payment):
    def __init__(self, username):
        self.username = username
​
    def pay(self, money):  # pay方法名字不能改變
        dic = {'username': self.username, 'money': money}
        '''
        呼叫微信支付 url連線 把dic傳過去
        '''
        print(f'{self.username}通過微信充值了{money}')
​
class Alipay(Payment):
    def __init__(self, username):
        self.username = username
​
    def pay1(self, money):
        dic = {'uname': self.username, 'price': money}
        ''''
        呼叫支付寶支付 url連線 把dic傳過去
        '''
        print(f'{self.username}通過支付寶充值了{money}')
​
# 當支付寶的pay名字發生變化的時候
Alipay('xiao')      # 這種方法在例項化物件的時候就會報錯提示
# 輸出
TypeError: Can't instantiate abstract class Alipay with abstract method pay

 

三、多型

一個型別表現出來的多種狀態:

  • 同一個物件,多種形態。python預設支援多型

def func(count):        # 這裡的count可以是str、int、list、dict等等....count就是多型的
    print(count)
​
​
func('abc')
func(12345)
func([1, 2, 3, 4])
func({'a': 1, 'b': 2})
# 輸出
abc
12345
[1, 2, 3, 4]
{'a': 1, 'b': 2}

 

而在Java的情況下:

  • 一個引數必須指定型別

  • 所以如果想兩個型別的物件都可以傳,那麼必須讓著兩個繼承自一個父類,在指定型別的時候使用父類來指定

  • 在java或者c#定義變數或者給函式傳值必須定義資料型別,否則就報錯。

def func(int a):
    print('a必須是數學')

 

  • 而類似於python這種弱定義類語言,a可以是任意形態(str,int,object等等)。

def func(a):
    print('a是什麼都可以')

 

python虛擬碼實現Java或C的多型

class F1:
    pass
​
​
class S1(F1):
    
    def show(self):
        print 'S1.show'
​
​
class S2(F1):
    
    def show(self):
        print 'S2.show'
​
​
# 由於在Java或C#中定義函式引數時,必須指定引數的型別
# 為了讓Func函式既可以執行S1物件的show方法,又可以執行S2物件的show方法,所以,定義了一個S1和S2類的父類
# 而實際傳入的引數是:S1物件和S2物件
def Func(F1 obj):
"""Func函式需要接收一個F1型別或者F1子類的型別"""print obj.show()
    
​
s1_obj = S1()
Func(s1_obj)  # 在Func函式中傳入S1類的物件 s1_obj,執行 S1 的show方法,結果:S1.show
​
s2_obj = S2()
Func(s2_obj)  # 在Func函式中傳入Ss類的物件 ss_obj,執行 Ss 的show方法,結果:S2.show

 

鴨子型別

在python中,有一句諺語,你看起來像鴨子,那麼你就是鴨子。

對相同的功能設定了相同的名字,這樣方便開發,這兩個方法就可以互成為鴨子型別。

比如:str、tuple、list 都有index方法,這就是互稱為鴨子型別

class A:
    def f1(self):
        print('in A f1')
    
    def f2(self):
        print('in A f2')
​
​
class B:
    def f1(self):
        print('in A f1')
    
    def f2(self):
        print('in A f2')
        
obj = A()
obj.f1()
obj.f2()
​
obj2 = B()
obj2.f1()
obj2.f2()
# A 和 B兩個類完全沒有耦合性,但是在某種意義上他們卻統一了一個標準。
# 輸出
in A f1
in A f2
in A f1
in A f2

 

四、佇列和棧、自定義Pickle

內建的資料結構:

  • {}:——key-value 通過key找v非常快

  • []:——序列 通過index取值非常快

  • ():——元組

  • {1,}:——集合

  • 'abc':——字串

不是python內建的:

  • Queue 佇列:先進先出 FIFO (FIRST IN FIRST OUT)

    • put:進

    • get:出

  • Stack 棧:後進先出 LIFO (LAST IN FIRST OUT)

    • put:進

    • get:出

class My_List:
    def __init__(self):
        self.ll = []
​
    def put(self, count):
        self.ll.append(count)
​
​
class Stack(My_List):
    def get(self):
        return self.ll.pop()
​
​
class Queue(My_List):
    def get(self):
        return self.ll.pop(0)
​
​
q = Queue()
​
s = Stack()
​
for a in range(10):
    q.put(a)
    s.put(a)
​
print('佇列放進去的值:', q.ll)
print('第一次取出:   ', q.get())
print('第二次取出:   ', q.get())
print('佇列所剩值:   ', q.ll)
print('------------------------------------')
print('棧放進去的值: ', s.ll)
print('第一次取出:   ', s.get())
print('第二次取出:   ', s.get())
print('棧所剩值:     ', s.ll)
​
# 輸出
佇列放進去的值: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
第一次取出:    0
第二次取出:    1
佇列所剩值:    [2, 3, 4, 5, 6, 7, 8, 9]
------------------------------------
棧放進去的值:  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
第一次取出:    9
第二次取出:    8
棧所剩值:     [0, 1, 2, 3, 4, 5, 6, 7]

 

自定義Pickle,藉助pickle模組來完成簡化的dump和load

  • pickle dump

    • 開啟檔案

    • 把資料dump到檔案裡

  • pickle load

    • 開啟檔案

    • 讀資料

物件 = Mypickle('檔案路徑')

物件.load() 能拿到這個檔案中所有的物件

物件.dump(要寫入檔案的物件)

import pickle
​
​
class Mypickle:
    def __init__(self, path):
        self.path_ = path
​
    def myload(self):
        with open(self.path_, mode='rb') as f1:
            while True:
                try:
                    # 讓讀取到的資料變成迭代器
                    yield pickle.load(f1)
                except EOFError:
                    breakdef mydump(self, count):
        with open(self.path_, mode='ab') as f2:
            pickle.dump(count, f2)
​
# 需要放入檔案的資料
ll = [f'第{a}個' for a in range(3)]
​
# 例項化一個物件
obj = Mypickle(r'my_obj')
obj.mydump(ll)      # 寫入檔案
obj.myload()        # 讀取檔案的資料
# 可以用__next__一條一條的讀,也可以for迴圈讀
a = obj.myload().__next__()
print(a)
print('------------------------')
# for迴圈讀取迭代器內的資料
for a in obj.myload():  
    print(a)
    
# 輸出
['第0個', '第1個', '第2個']
------------------------
['第0個', '第1個', '第2個']
['第0個', '第1個', '第2個']
['第0個', '第1個', '第2個']