一、類的繼承順序
只要繼承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
四、佇列和堆疊、自定義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: 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個']
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/282524.html
標籤：其他
上一篇：jdbc操作blob型別的資料
下一篇：資料庫事務