day-25-類的繼承順序-父類對子類的約束-多態-隊列和棧
只要繼承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): pass 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名字發生變化的時候 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
內置的數據結構：
-
{}：——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: break def 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個']
