4.面向對象:封裝,多態

2019 年 10 月 3 日
筆記

前言：

python面向對象的三大特性：繼承，封裝，多態。

1. 封裝: 把很多數據封裝到⼀個對象中. 把固定功能的程式碼封裝到⼀個程式碼塊, 函數, 對象, 打包成模組. 這都屬於封裝的思想. 具體的情況具體分析. 比如. 你寫了⼀個很⽜B的函數. 那這個也可以被稱為封裝. 在⾯向對象思想中. 是把⼀些看似⽆關緊要的內容組合到⼀起統⼀進⾏存儲和使⽤. 這就是封裝.

2. 繼承: ⼦類可以⾃動擁有⽗類中除了私有屬性外的其他所有內容. 說⽩了, ⼉⼦可以隨便⽤爹的東⻄. 但是朋友們, ⼀定要認清楚⼀個事情. 必須先有爹, 後有⼉⼦. 順序不能亂, 在python中實現繼承非常簡單. 在聲明類的時候, 在類名後⾯添加⼀個⼩括弧,就可以完成繼承關係. 那麼什麼情況可以使⽤繼承呢? 單純的從程式碼層⾯上來看. 兩個類具有相同的功能或者特徵的時候. 可以采⽤繼承的形式. 提取⼀個⽗類, 這個⽗類中編寫著兩個類相同的部分. 然後兩個類分別取繼承這個類就可以了. 這樣寫的好處是我們可以避免寫很多重複的功能和程式碼. 如果從語義中去分析的話. 會簡單很多. 如果語境中出現了x是⼀種y. 這時, y是⼀種泛化的概念. x比y更加具體. 那這時x就是y的⼦類. 比如. 貓是⼀種動物. 貓繼承動物. 動物能動. 貓也能動. 這時貓在創建的時候就有了動物的"動"這個屬性. 再比如, ⽩骨精是⼀個妖怪. 妖怪天⽣就有⼀個比較不好的功能叫"吃⼈", ⽩骨精⼀出⽣就知道如何"吃⼈". 此時⽩骨精繼承妖精.

3. 多態: 同⼀個對象, 多種形態. 這個在python中其實是很不容易說明⽩的. 因為我們⼀直在⽤. 只是沒有具體的說. 比如. 我們創建⼀個變數a = 10 , 我們知道此時a是整數類型. 但是我們可以通過程式讓a = "alex", 這時, a⼜變成了字元串類型. 這是我們都知道的. 但是, 我要告訴你的是. 這個就是多態性. 同⼀個變數a可以是多種形態。

一封裝

封裝，顧名思義就是將內容封裝到某個地方，以後再去調用被封裝在某處的內容。

所以，在使用面向對象的封裝特性時，需要：

將內容封裝到某處
從某處調用被封裝的內容

第一步：將內容封裝到某處

self 是一個形式參數，當執行 obj1 = Foo(‘wupeiqi’, 18 ) 時，self 等於 obj1

當執行 obj2 = Foo(‘alex’, 78 ) 時，self 等於 obj2

所以，內容其實被封裝到了對象 obj1 和 obj2 中，每個對象中都有 name 和 age 屬性，在記憶體里類似於下圖來保存。

第二步：從某處調用被封裝的內容

調用被封裝的內容時，有兩種情況：

通過對象直接調用
通過self間接調用

1、通過對象直接調用被封裝的內容

上圖展示了對象 obj1 和 obj2 在記憶體中保存的方式，根據保存格式可以如此調用被封裝的內容：對象.屬性名

class Foo:        def __init__(self, name, age):          self.name = name          self.age = age    obj1 = Foo('wupeiqi', 18)  print obj1.name    # 直接調用obj1對象的name屬性  print obj1.age     # 直接調用obj1對象的age屬性    obj2 = Foo('alex', 73)  print obj2.name    # 直接調用obj2對象的name屬性  print obj2.age     # 直接調用obj2對象的age屬性

2、通過self間接調用被封裝的內容

執行類中的方法時，需要通過self間接調用被封裝的內容

class Foo:        def __init__(self, name, age):          self.name = name          self.age = age        def detail(self):          print self.name          print self.age    obj1 = Foo('wupeiqi', 18)  obj1.detail()  # Python默認會將obj1傳給self參數，即：obj1.detail(obj1)，所以，此時方法內部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18    obj2 = Foo('alex', 73)  obj2.detail()  # Python默認會將obj2傳給self參數，即：obj1.detail(obj2)，所以，此時方法內部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

綜上所述，對於面向對象的封裝來說，其實就是使用構造方法將內容封裝到對象中，然後通過對象直接或者self間接獲取被封裝的內容。

二多態

多態，同一個對象，多種形態。python默認支援多態。

# 在java或者c#定義變數或者給函數傳值必須定義數據類型，否則就報錯。    def func(int a):      print('a必須是數字')    # 而類似於python這種弱定義類語言,a可以是任意形態（str,int,object等等）。  def func(a):      print('a是什麼都可以')    # 再比如：  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偽程式碼實現Java或C  # 的多態

多態舉例

python中有一句諺語說的好，你看起來像鴨子，那麼你就是鴨子。  對於程式碼上的解釋其實很簡答：  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兩個類完全沒有耦合性，但是在某種意義上他們卻統一了一個標準。  # 對相同的功能設定了相同的名字，這樣方便開發，這兩個方法就可以互成為鴨子類型。    # 這樣的例子比比皆是：str  tuple list 都有 index方法，這就是統一了規範。  # str bytes 等等 這就是互稱為鴨子類型。

三類的約束

⾸先, 你要清楚. 約束是對類的約束.

用一個例子說話：

公司讓小明給他們的網站完善一個支付功能，小明寫了兩個類，如下：

class QQpay:      def pay(self,money):          print('使用qq支付%s元' % money)    class Alipay:      def pay(self,money):          print('使用阿里支付%s元' % money)    a = Alipay()  a.pay(100)    b = QQpay()  b.pay(200)

但是上面這樣寫不太放方便，也不合理，老大說讓他整改，統一一下付款的方式，小明開始加班整理：

class QQpay:      def pay(self,money):          print('使用qq支付%s元' % money)    class Alipay:      def pay(self,money):          print('使用阿里支付%s元' % money)    def pay(obj,money):  # 這個函數就是統一支付規則，這個叫做： 歸一化設計。      obj.pay(money)    a = Alipay()  b = QQpay()    pay(a,100)  pay(b,200)

寫了半年的介面，小明終於接了大項目了，結果公司沒品位，招了一個野生的程式設計師春哥接替小明的工作，老大給春哥安排了任務，讓他寫一個微信支付的功能：

class QQpay:      def pay(self,money):          print('使用qq支付%s元' % money)    class Alipay:      def pay(self,money):          print('使用阿里支付%s元' % money)    class Wechatpay:  # 野生程式設計師一般不會看別人怎麼寫，自己才是最好，結果......      def fuqian(self,money):          print('使用微信支付%s元' % money)    def pay(obj,money):      obj.pay(money)    a = Alipay()  b = QQpay()    pay(a,100)  pay(b,200)    c = Wechatpay()  c.fuqian(300)

結果春哥，受懲罰了，限期整改，那麼春哥，發奮圖強，看了太白教你學python的相關資料，重新梳理的程式碼：

class Payment: 　　""" 此類什麼都不做，就是制定一個標準，誰繼承我，必須定義我裡面的方法。   """      def pay(self,money):pass    class QQpay(Payment):      def pay(self,money):          print('使用qq支付%s元' % money)    class Alipay(Payment):      def pay(self,money):          print('使用阿里支付%s元' % money)    class Wechatpay(Payment):      def fuqian(self,money):          print('使用微信支付%s元' % money)      def pay(obj,money):      obj.pay(money)    a = Alipay()  b = QQpay()    pay(a,100)  pay(b,200)    c = Wechatpay()  c.fuqian(300)

但是，這樣還會有問題，如果再來野生程式設計師，他不看其他的支付方式，也不知道為什麼繼承的類中要定義一個沒有意義的方法，所以他會是會我行我素：

class Payment:  　　""" 此類什麼都不做，就是制定一個標準，誰繼承我，必須定義我裡面的方法。     """      def pay(self,money):pass    class QQpay(Payment):      def pay(self,money):          print('使用qq支付%s元' % money)    class Alipay(Payment):      def pay(self,money):          print('使用阿里支付%s元' % money)    class Wechatpay(Payment):      def fuqian(self,money):          print('使用微信支付%s元' % money)      def pay(obj,money):      obj.pay(money)    a = Alipay()  b = QQpay()    pay(a,100)  pay(b,200)    c = Wechatpay()  c.fuqian(300)

所以此時我們要用到對類的約束，對類的約束有兩種：

1. 提取⽗類. 然後在⽗類中定義好⽅法. 在這個⽅法中什麼都不⽤⼲. 就拋⼀個異常就可以了. 這樣所有的⼦類都必須重寫這個⽅法. 否則. 訪問的時候就會報錯.

2. 使⽤元類來描述⽗類. 在元類中給出⼀個抽象⽅法. 這樣⼦類就不得不給出抽象⽅法的具體實現. 也可以起到約束的效果.

先用第一種方式解決：

class Payment:      """      此類什麼都不做，就是制定一個標準，誰繼承我，必須定義我裡面的方法。      """      def pay(self,money):          raise Exception("你沒有實現pay方法")    class QQpay(Payment):      def pay(self,money):          print('使用qq支付%s元' % money)    class Alipay(Payment):      def pay(self,money):          print('使用阿里支付%s元' % money)    class Wechatpay(Payment):      def fuqian(self,money):          print('使用微信支付%s元' % money)      def pay(obj,money):      obj.pay(money)    a = Alipay()  b = QQpay()  c = Wechatpay()  pay(a,100)  pay(b,200)  pay(c,300)

第二種方式：引入抽象類的概念處理。

from abc import ABCMeta,abstractmethod  class Payment(metaclass=ABCMeta):    # 抽象類 介面類  規範和約束  metaclass指定的是一個元類      @abstractmethod      def pay(self):pass  # 抽象方法    class Alipay(Payment):      def pay(self,money):          print('使用支付寶支付了%s元'%money)    class QQpay(Payment):      def pay(self,money):          print('使用qq支付了%s元'%money)    class Wechatpay(Payment):      # def pay(self,money):      #     print('使用微信支付了%s元'%money)      def recharge(self):pass    def pay(a,money):      a.pay(money)    a = Alipay()  a.pay(100)  pay(a,100)    # 歸一化設計：不管是哪一個類的對象，都調用同一個函數去完成相似的功能  q = QQpay()  q.pay(100)  pay(q,100)  w = Wechatpay()  pay(w,100)   # 到用的時候才會報錯        # 抽象類和介面類做的事情 ：建立規範  # 制定一個類的metaclass是ABCMeta，  # 那麼這個類就變成了一個抽象類(介面類)  # 這個類的主要功能就是建立一個規範

總結: 約束. 其實就是⽗類對⼦類進⾏約束. ⼦類必須要寫xxx⽅法. 在python中約束的⽅式和⽅法有兩種:

1. 使⽤抽象類和抽象⽅法, 由於該⽅案來源是java和c#. 所以使⽤頻率還是很少的

2. 使⽤⼈為拋出異常的⽅案. 並且盡量拋出的是NotImplementError. 這樣比較專業, ⽽且錯誤比較明確.(推薦)

四. super()深入了解

super是嚴格按照類的繼承順序執行！！！

class A:      def f1(self):          print('in A f1')        def f2(self):          print('in A f2')      class Foo(A):      def f1(self):          super().f2()          print('in A Foo')      obj = Foo()  obj.f1()

super可以下一個類的其他方法

class A:      def f1(self):          print('in A')    class Foo(A):      def f1(self):          super().f1()          print('in Foo')    class Bar(A):      def f1(self):          print('in Bar')    class Info(Foo,Bar):      def f1(self):          super().f1()          print('in Info f1')    obj = Info()  obj.f1()    '''  in Bar  in Foo  in Info f1  '''  print(Info.mro())  # [<class '__main__.Info'>, <class '__main__.Foo'>, <class '__main__.Bar'>, <class '__main__.A'>, <class 'object'>]

super()嚴格按照類的mro順序執行

class A:      def f1(self):          print('in A')    class Foo(A):      def f1(self):          super().f1()          print('in Foo')    class Bar(A):      def f1(self):          print('in Bar')    class Info(Foo,Bar):      def f1(self):          super(Foo,self).f1()          print('in Info f1')    obj = Info()  obj.f1()