面向對象初識

一,初始面向對象.

面向過程的程序設計的核心是過程（流水線式思維），過程即解決問題的步驟，面向過程的設計就好比精心設計好一條流水線，考慮周全什么時候處理什么東西。

優點是：極大的降低了寫程序的復雜度，只需要順着要執行的步驟，堆疊代碼即可。

缺點是：一套流水線或者流程就是用來解決一個問題，代碼牽一發而動全身。

應用場景：一旦完成基本很少改變的場景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

 

面向對象的程序設計的核心是對象（上帝式思維），要理解對象為何物，必須把自己當成上帝，上帝眼里世間存在的萬物皆為對象，不存在的也可以創造出來。面向對象的程序設計好比如來設計西游記，如來要解決的問題是把經書傳給東土大唐，如來想了想解決這個問題需要四個人：唐僧，沙和尚，豬八戒，孫悟空，每個人都有各自的特征和技能（這就是對象的概念，特征和技能分別對應對象的屬性和方法），然而這並不好玩，於是如來又安排了一群妖魔鬼怪，為了防止師徒四人在取經路上被搞死，又安排了一群神仙保駕護航，這些都是對象。然后取經開始，師徒四人與妖魔鬼怪神仙互相纏斗着直到最后取得真經。如來根本不會管師徒四人按照什么流程去取。

面向對象的程序設計的

優點是：解決了程序的擴展性。對某一個對象單獨修改，會立刻反映到整個體系中，如對游戲中一個人物參數的特征和技能修改都很容易。

缺點：可控性差，無法向面向過程的程序設計流水線式的可以很精准的預測問題的處理流程與結果，面向對象的程序一旦開始就由對象之間的交互解決問題，即便是上帝也無法預測最終結果。於是我們經常看到一個游戲人某一參數的修改極有可能導致陰霸的技能出現，一刀砍死3個人，這個游戲就失去平衡。

應用場景：需求經常變化的軟件，一般需求的變化都集中在用戶層，互聯網應用，企業內部軟件，游戲等都是面向對象的程序設計大顯身手的好地方。

在python 中面向對象的程序設計並不是全部。

面向對象編程可以使程序的維護和擴展變得更簡單，並且可以大大提高程序開發效率 ，另外，基於面向對象的程序可以使它人更加容易理解你的代碼邏輯，從而使團隊開發變得更從容。

了解一些名詞：類、對象、實例、實例化

類：具有相同特征的一類事物(人、狗、老虎)

對象／實例：具體的某一個事物（隔壁阿花、樓下旺財）

實例化：類——>對象的過程（這在生活中表現的不明顯，我們在后面再慢慢解釋）

1.1 類的相關知識

　　聲明

def functionName(args):
     '函數文檔字符串'
      函數體 


'''
class 類名:
    '類的文檔字符串'
    類體
'''

#我們創建一個類
class Data:
    pass

　　屬性

class Person:   #定義一個人類
    role = 'person'  #人的角色屬性都是人
    def walk(self):  #人都可以走路，也就是有一個走路方法
        print("person is walking...")


print(Person.role)  #查看人的role屬性
print(Person.walk)  #引用人的走路方法，注意，這里不是在調用

　　實例化：類名加括號就是實例化，會自動觸發__init__函數的運行，可以用它來為每個實例定制自己的特征

class Person:   #定義一個人類
    role = 'person'  #人的角色屬性都是人
    def __init__(self,name):
        self.name = name  # 每一個角色都有自己的昵稱;
        
    def walk(self):  #人都可以走路，也就是有一個走路方法
        print("person is walking...")


print(Person.role)  #查看人的role屬性
print(Person.walk)  #引用人的走路方法，注意，這里不是在調用

實例化的過程就是類——>對象的過程

原本我們只有一個Person類，在這個過程中，產生了一個egg對象，有自己具體的名字、攻擊力和生命值。

語法：對象名 = 類名(參數)

　　self

self：在實例化時自動將對象/實例本身傳給__init__的第一個參數，你也可以給他起個別的名字，但是正常人都不會這么做。
因為你瞎改別人就不認識

　　類屬性的補充

一：我們定義的類的屬性到底存到哪里了？有兩種方式查看
dir(類名)：查出的是一個名字列表
類名.__dict__:查出的是一個字典，key為屬性名，value為屬性值

二：特殊的類屬性
類名.__name__# 類的名字(字符串)
類名.__doc__# 類的文檔字符串
類名.__base__# 類的第一個父類(在講繼承時會講)
類名.__bases__# 類所有父類構成的元組(在講繼承時會講)
類名.__dict__# 類的字典屬性
類名.__module__# 類定義所在的模塊
類名.__class__# 實例對應的類(僅新式類中)

1.2對象的相關知識

class 類名:
    def __init__(self,參數1,參數2):
        self.對象的屬性1 = 參數1
        self.對象的屬性2 = 參數2

    def 方法名(self):pass

    def 方法名2(self):pass

對象名 = 類名(1,2)  #對象就是實例，代表一個具體的東西
                  #類名() : 類名+括號就是實例化一個類，相當於調用了__init__方法
                  #括號里傳參數，參數不需要傳self，其他與init中的形參一一對應
                  #結果返回一個對象
對象名.對象的屬性1   #查看對象的屬性，直接用 對象名.屬性名 即可
對象名.方法名()     #調用類中的方法，直接用 對象名.方法名() 即可

練習一：在終端輸出如下信息

小明，10歲，男，上山去砍柴
小明，10歲，男，開車去東北
小明，10歲，男，最愛大保健
老李，90歲，男，上山去砍柴
老李，90歲，男，開車去東北
老李，90歲，男，最愛大保健
老張…

1.3類名稱空間與對象的名稱空間

創建一個類就會創建一個類的名稱空間，用來存儲類中定義的所有名字，這些名字稱為類的屬性

而類有兩種屬性：靜態屬性和動態屬性

• 靜態屬性就是直接在類中定義的變量
• 動態屬性就是定義在類中的方法

其中類的數據屬性是共享給所有對象的

>>>id(egg.role)
4341594072
>>>id(Person.role)
4341594072

而類的動態屬性是綁定到所有對象的

>>>egg.attack
<bound method Person.attack of <__main__.Person object at 0x101285860>>
>>>Person.attack
<function Person.attack at 0x10127abf8> 

創建一個對象/實例就會創建一個對象/實例的名稱空間，存放對象/實例的名字，稱為對象/實例的屬性

在obj.name會先從obj自己的名稱空間里找name，找不到則去類中找，類也找不到就找父類...最后都找不到就拋出異常

二,面向對象的三大特性:繼承,多態,封裝.

2.1繼承.

繼承是一種創建新類的方式，在python中，新建的類可以繼承一個或多個父類，父類又可稱為基類或超類，新建的類稱為派生類或子類

 

python中類的繼承分為：單繼承和多繼承

復制代碼
class ParentClass1: #定義父類
    pass

class ParentClass2: #定義父類
    pass

class SubClass1(ParentClass1): #單繼承，基類是ParentClass1，派生類是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多繼承，用逗號分隔開多個繼承的類
    pass

查看繼承

>>> SubClass1.__bases__ #__base__只查看從左到右繼承的第一個子類，__bases__則是查看所有繼承的父類
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

提示：如果沒有指定基類，python的類會默認繼承object類，object是所有python類的基類，它提供了一些常見方法（如__str__）的實現。

>>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)

繼承的重要性

==========================第一部分
例如

　　貓可以：爬樹、吃、喝、拉、撒

　　狗可以：看門、吃、喝、拉、撒

如果我們要分別為貓和狗創建一個類，那么就需要為 貓 和 狗 實現他們所有的功能，偽代碼如下：
 

#貓和狗有大量相同的內容
class 貓：

    def爬樹(self):
        print '爬樹'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

class 狗：

    def 看門(self):
        print '看門'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something



==========================第二部分
上述代碼不難看出，吃、喝、拉、撒是貓和狗都具有的功能，而我們卻分別的貓和狗的類中編寫了兩次。如果使用 繼承 的思想，如下實現：

　　動物：吃、喝、拉、撒

　　   貓：爬樹（貓繼承動物的功能）

　　   狗：看門（狗繼承動物的功能）

偽代碼如下：
class 動物:

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

# 在類后面括號中寫入另外一個類名，表示當前類繼承另外一個類
class 貓(動物)：

    def爬樹(self):
        print '爬樹'

# 在類后面括號中寫入另外一個類名，表示當前類繼承另外一個類
class 狗(動物)：

     def 看門(self):
        print '看門'




==========================第三部分
#繼承的代碼實現
class Animal:

    def eat(self):
        print("%s 吃 " %self.name)

    def drink(self):
        print ("%s 喝 " %self.name)

    def shit(self):
        print ("%s 拉 " %self.name)

    def pee(self):
        print ("%s 撒 " %self.name)


class Cat(Animal):

    def __init__(self, name):
        self.name = name
        self.breed = '貓'

    def爬樹(self):
        print '爬樹'

class Dog(Animal):

    def __init__(self, name):
        self.name = name
        self.breed='狗'
  
    def 看門(self):
        print '看門'



# ######### 執行 #########

c1 = Cat('小白家的小黑貓')
c1.eat()

c2 = Cat('小黑的小白貓')
c2.drink()

d1 = Dog('胖子家的小瘦狗')
d1.eat()

使用繼承來重用代碼比較好的例子

那么問題又來了，多繼承呢？

• 是否可以繼承多個類
• 如果繼承的多個類每個類中都定了相同的函數，那么那一個會被使用呢？

1、Python的類可以繼承多個類，Java和C#中則只能繼承一個類

2、Python的類如果繼承了多個類，那么其尋找方法的方式有兩種，分別是：深度優先和C3算法。

• 當類是經典類時，多繼承情況下，會按照深度優先方式查找。
• 當類是新式類時，多繼承情況下，會按照C3算法去查詢。

經典類和新式類，從字面上可以看出一個老一個新，新的必然包含了跟多的功能，也是之后推薦的寫法，從寫法上區分的話，如果 當前類或者父類繼承了object類，那么該類便是新式類，否則便是經典類。

 

class D:

    def bar(self):
        print 'D.bar'


class C(D):

    def bar(self):
        print 'C.bar'


class B(D):

    def bar(self):
        print 'B.bar'


class A(B, C):

    def bar(self):
        print 'A.bar'

a = A()
# 執行bar方法時
# 首先去A類中查找，如果A類中沒有，則繼續去B類中找，如果B類中么有，則繼續去D類中找，如果D類中么有，則繼續去C類中找，如果還是未找到，則報錯
# 所以，查找順序：A --> B --> D --> C
# 在上述查找bar方法的過程中，一旦找到，則尋找過程立即中斷，便不會再繼續找了
a.bar()

經典類多繼承

class X:
    pass

class S(X):
    pass

class A(X):
    pass
    
class B(S):
    pass

class C(A):
    pass

class D(B):
    pass
  
class E(C):
    pass
  

class F(D,E,B):
    pass
  
f1 = F()

print(F.mro())
#[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.E'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

經典類：首先去A類中查找，如果A類中沒有，則繼續去B類中找，如果B類中么有，則繼續去D類中找，如果D類中么有，則繼續去C類中找，如果還是未找到，則報錯

新式類：則根據C3算法，具體可以通過類名.mro()方法去查詢他的繼承順序。

注意：在上述查找過程中，一旦找到，則尋找過程立即中斷，便不會再繼續找了

抽象類與接口類

接口類

繼承有兩種用途：

一：繼承基類的方法，並且做出自己的改變或者擴展（代碼重用）  

二：聲明某個子類兼容於某基類，定義一個接口類Interface，接口類中定義了一些接口名（就是函數名）且並未實現接口的功能，子類繼承接口類，並且實現接口中的功能

# 一:這樣不好,我要統一一下支付的規則.

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)

# 二,統一支付的規則 歸一化設計,統一 pay接口
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)

# 四,解決方式
# 定義一個父類,什么都不寫,只是要求繼承我的所有類有一個pay方法,這樣就制定了一個規范,這就叫做接口類,后者抽象類.
class Payment:
    def pay(self):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)

#五,他還是不知道看你這些都繼承了一個類,所以你要制定一個規范,強制他執行.
# 創建一個規范
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，
# 那么這個類就變成了一個抽象類(接口類)
# 這個類的主要功能就是建立一個規范

實踐中，繼承的第一種含義意義並不很大，甚至常常是有害的。因為它使得子類與基類出現強耦合。

繼承的第二種含義非常重要。它又叫“接口繼承”。
接口繼承實質上是要求“做出一個良好的抽象，這個抽象規定了一個兼容接口，使得外部調用者無需關心具體細節，可一視同仁的處理實現了特定接口的所有對象”——這在程序設計上，叫做歸一化。

歸一化使得高層的外部使用者可以不加區分的處理所有接口兼容的對象集合——就好象linux的泛文件概念一樣，所有東西都可以當文件處理，不必關心它是內存、磁盤、網絡還是屏幕（當然，對底層設計者，當然也可以區分出“字符設備”和“塊設備”，然后做出針對性的設計：細致到什么程度，視需求而定）。

依賴倒置原則：
高層模塊不應該依賴低層模塊，二者都應該依賴其抽象；抽象不應該應該依賴細節；細節應該依賴抽象。換言之，要針對接口編程，而不是針對實現編程

在python中根本就沒有一個叫做interface的關鍵字，上面的代碼只是看起來像接口，其實並沒有起到接口的作用，子類完全可以不用去實現接口 ，如果非要去模仿接口的概念，可以借助第三方模塊：

http://pypi.python.org/pypi/zope.interface

twisted的twisted\internet\interface.py里使用zope.interface

文檔https://zopeinterface.readthedocs.io/en/latest/

設計模式：https://github.com/faif/python-patterns

接口提取了一群類共同的函數，可以把接口當做一個函數的集合。

然后讓子類去實現接口中的函數。

這么做的意義在於歸一化，什么叫歸一化，就是只要是基於同一個接口實現的類，那么所有的這些類產生的對象在使用時，從用法上來說都一樣。

歸一化，讓使用者無需關心對象的類是什么，只需要的知道這些對象都具備某些功能就可以了，這極大地降低了使用者的使用難度。

比如：我們定義一個動物接口，接口里定義了有跑、吃、呼吸等接口函數，這樣老鼠的類去實現了該接口，松鼠的類也去實現了該接口，由二者分別產生一只老鼠和一只松鼠送到你面前，即便是你分別不到底哪只是什么鼠你肯定知道他倆都會跑，都會吃，都能呼吸。

再比如：我們有一個汽車接口，里面定義了汽車所有的功能，然后由本田汽車的類，奧迪汽車的類，大眾汽車的類，他們都實現了汽車接口，這樣就好辦了，大家只需要學會了怎么開汽車，那么無論是本田，還是奧迪，還是大眾我們都會開了，開的時候根本無需關心我開的是哪一類車，操作手法（函數調用）都一樣

抽象類

什么是抽象類

    與java一樣，python也有抽象類的概念但是同樣需要借助模塊實現，抽象類是一個特殊的類，它的特殊之處在於只能被繼承，不能被實例化

為什么要有抽象類

    如果說類是從一堆對象中抽取相同的內容而來的，那么抽象類就是從一堆類中抽取相同的內容而來的，內容包括數據屬性和函數屬性。

　 比如我們有香蕉的類，有蘋果的類，有桃子的類，從這些類抽取相同的內容就是水果這個抽象的類，你吃水果時，要么是吃一個具體的香蕉，要么是吃一個具體的桃子。。。。。。你永遠無法吃到一個叫做水果的東西。

    從設計角度去看，如果類是從現實對象抽象而來的，那么抽象類就是基於類抽象而來的。

　 從實現角度來看，抽象類與普通類的不同之處在於：抽象類中有抽象方法，該類不能被實例化，只能被繼承，且子類必須實現抽象方法。這一點與接口有點類似，但其實是不同的，即將揭曉答案

在python中實現抽象類

抽象類與接口類

抽象類的本質還是類，指的是一組類的相似性，包括數據屬性（如all_type）和函數屬性（如read、write），而接口只強調函數屬性的相似性。

抽象類是一個介於類和接口直接的一個概念，同時具備類和接口的部分特性，可以用來實現歸一化設計 

在python中，並沒有接口類這種東西，即便不通過專門的模塊定義接口，我們也應該有一些基本的概念。

1.多繼承問題

在繼承抽象類的過程中，我們應該盡量避免多繼承；
而在繼承接口的時候，我們反而鼓勵你來多繼承接口

接口隔離原則：
使用多個專門的接口，而不使用單一的總接口。即客戶端不應該依賴那些不需要的接口。

2.方法的實現

在抽象類中，我們可以對一些抽象方法做出基礎實現；
而在接口類中，任何方法都只是一種規范，具體的功能需要子類實現

ps:組合

面向對象的組合用法

軟件重用的重要方式除了繼承之外還有另外一種方式，即：組合

組合指的是，在一個類中以另外一個類的對象作為數據屬性，稱為類的組合

class Person:

    def __init__(self,nickname,sex,hp,ad):
        self.nickname = nickname
        self.sex = sex
        self.hp = hp
        self.ad = ad

    def attack(self,p1):
        p1.hp -= self.ad
        print('%s攻擊了%s,%s還剩%s血量'%(self.nickname,p1.nickname,p1.nickname,p1.hp))

    def weapon_attack(self,wea):
        # 武器類的對象封裝到人的對象中當做一個屬性.就叫做組合.
        self.weapon = wea

class Weapon:

    def __init__(self,name,att):
        self.name = name
        self.att = att

    def Aux_attack(self,p,p1):
        p1.hp -= self.att
        print('%s利用%s打了%s%s滴血,%s還剩%s滴血' %(p.nickname,self.name,p1.nickname,self.att,p1.nickname,p1.hp))


# alex = Person('alex','男',100,20)
# barry = Person('太白','男',200,50)
# axe = Weapon('斧子',30)
# barry.weapon_attack(axe)
# barry.weapon.Aux_attack(barry,alex)

# axe.Aux_attack(alex)
# alex.attack(barry)
# alex.attack(barry)

圓環是由兩個圓組成的，圓環的面積是外面圓的面積減去內部圓的面積。圓環的周長是內部圓的周長加上外部圓的周長。
這個時候，我們就首先實現一個圓形類，計算一個圓的周長和面積。然后在"環形類"中組合圓形的實例作為自己的屬性來用

from math import pi

class Circle:
    '''
    定義了一個圓形類；
    提供計算面積(area)和周長(perimeter)的方法
    '''
    def __init__(self,radius):
        self.radius = radius

    def area(self):
         return pi * self.radius * self.radius

    def perimeter(self):
        return 2 * pi *self.radius


circle =  Circle(10) #實例化一個圓
area1 = circle.area() #計算圓面積
per1 = circle.perimeter() #計算圓周長
print(area1,per1) #打印圓面積和周長

class Ring:
    '''
    定義了一個圓環類
    提供圓環的面積和周長的方法
    '''
    def __init__(self,radius_outside,radius_inside):
        self.outsid_circle = Circle(radius_outside)
        self.inside_circle = Circle(radius_inside)

    def area(self):
        return self.outsid_circle.area() - self.inside_circle.area()

    def perimeter(self):
        return  self.outsid_circle.perimeter() + self.inside_circle.perimeter()


ring = Ring(10,5) #實例化一個環形
print(ring.perimeter()) #計算環形的周長
print(ring.area()) #計算環形的面積

 

用組合的方式建立了類與組合的類之間的關系，它是一種‘有’的關系,比如教授有生日，教授教python課程

class BirthDate:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day

class Couse:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period

class Teacher:
    def __init__(self,name,gender,birth,course):

        self.name=name 
        self.gender=gender
        self.birth=birth
        self.course=course

    def teach(self): 
        print('teaching')

p1=Teacher('egon','male', 
            BirthDate('1995','1','27'), 
            Couse('python','28000','4 months')
           ) 

print(p1.birth.year,p1.birth.month,p1.birth.day) 

print(p1.course.name,p1.course.price,p1.course.period)
''' 
運行結果: 
1 27 
python 28000 4 months 
'''

當類之間有顯著不同，並且較小的類是較大的類所需要的組件時，用組合比較好

2.2多態

Pyhon不支持Java和C#這一類強類型語言中多態的寫法，但是原生多態，其Python崇尚“鴨子類型”。

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#的多態

class F1:
    pass


class S1(F1):

    def show(self):
        print 'S1.show'


class S2(F1):

    def show(self):
        print 'S2.show'

def Func(obj):
    print obj.show()

s1_obj = S1()
Func(s1_obj) 

s2_obj = S2()
Func(s2_obj) 

Python “鴨子類型”

2.3封裝

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

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

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

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

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

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

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

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

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

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

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13

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間接調用被封裝的內容

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

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間接獲取被封裝的內容。

封裝與擴展性

封裝在於明確區分內外，使得類實現者可以修改封裝內的東西而不影響外部調用者的代碼；而外部使用用者只知道一個接口(函數)，只要接口（函數）名、參數不變，使用者的代碼永遠無需改變。這就提供一個良好的合作基礎——或者說，只要接口這個基礎約定不變，則代碼改變不足為慮。

#類的設計者
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #對外提供的接口，隱藏了內部的實現細節，此時我們想求的是面積
        return self.__width * self.__length


#使用者
>>> r1=Room('卧室','egon',20,20,20)
>>> r1.tell_area() #使用者調用接口tell_area


#類的設計者，輕松的擴展了功能，而類的使用者完全不需要改變自己的代碼
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #對外提供的接口，隱藏內部實現，此時我們想求的是體積,內部邏輯變了,只需求修該下列一行就可以很簡答的實現,而且外部調用感知不到,仍然使用該方法，但是功能已經變了
        return self.__width * self.__length * self.__high


#對於仍然在使用tell_area接口的人來說，根本無需改動自己的代碼，就可以用上新功能
>>> r1.tell_area()

相關面試題:

class Parent:
    def func(self):
        print('in Parent func')

    def __init__(self):
        self.func()

class Son(Parent):
    def func(self):
        print('in Son func')

son1 = Son()


class A:
    a = 0
    b = 1
    def __init__(self):
        c = 222
d = A()
d.a = 1
d.b = 2
d.c = {'1':1}
e = A()
# print(e.a,e.b,e.c)