Python之路【第八篇】:面向對象的程序設計

時間 2019-12-09

原文原文鏈接

閱讀目錄

一面向對象的程序設計的由來
二什麼是面向對象的程序設計及爲何要有它
三類和對象
3.1 什麼是對象，什麼是類
3.2 類相關知識
3.3 對象相關知識
3.4 對象之間的交互
3.5 類名稱空間與對象/實例名稱空間
3.6 小結
四繼承與派生
4.1 什麼是繼承
4.2 什麼是派生
4.3 繼承與抽象（先抽象再繼承）
4.4 繼承與重用性
4.5 組合與重用性
4.6 接口與歸一化設計
4.7 抽象類
4.8 繼承實現的原理（繼承順序）
4.9 子類中調用父類方法
五多態與多態性
5.1 多態
5.2 多態性
六封裝
6.1 要封裝什麼
6.2 爲何要封裝
6.3 封裝分爲兩個層面
6.4 特性（property）
6.5 封裝與擴展性
七靜態方法和類方法
八面向對象的軟件開發
九小白容易犯的錯誤
十 python中關於OOP的經常使用術語html

一. 面向對象的程序設計由來

參考林海峯老師總結: http://www.cnblogs.com/linhaifeng/articles/6428835.htmljava

二. 什麼是面向對象的程序設計及爲何要有它

1.面向過程的程序設計

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

優勢: 極大的下降了程序的複雜度。linux

缺點: 一套流水線或者流程就是用來解決一個問題，生產汽水的流水線沒法生產汽車，即使是能，也得是大改，改一個組件，牽一髮而動全身。c++

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

2. 面向對象的程序設計

面向對象的程序設計的核心是對象（上帝式思惟），要理解對象爲什麼物，必須把本身當成上帝，上帝眼裏世間存在的萬物皆爲對象，不存在的也能夠創造出來。面向對象的程序設計比如如來設計西遊記，如來要解決的問題是把經書傳給東土大唐，如來想了想解決這個問題須要四我的：唐僧，沙和尚，豬八戒，孫悟空，每一個人都有各自的特徵和技能（這就是對象的概念，特徵和技能分別對應對象的數據屬性和方法屬性），然而這並很差玩，因而如來又安排了一羣妖魔鬼怪，爲了防止師徒四人在取經路上被搞死，又安排了一羣神仙保駕護航，這些都是對象。而後取經開始，師徒四人與妖魔鬼怪神仙交互着直到最後取得真經。如來根本不會管師徒四人按照什麼流程去取。程序員

優勢: 解決了程序的擴展性。對某一個對象單獨修改，會馬上反映到整個體系中，如對遊戲中一我的物參數的特徵和技能修改都很容易。github

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

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

面向對象的程序設計並非所有。對於一個軟件質量來講，面向對象的程序設計只是用來解決擴展性。

三. 類和對象

3.1 什麼是類？什麼是對象？

提示: python的class術語與c++有必定區別，與 Modula-3更像。

python中一切皆爲對象，且python3統一了類與類型的概念，類型就是類，因此，無論你信不信，你已經使用了很長時間的類了

>>> dict                     #類型dict就是類dict
<class 'dict'>
>>> d=dict(name='shuke')     #實例化
>>> d.pop('name')             #向d發一條消息，執行d的方法pop
'shuke'

基於面向對象設計一個款遊戲：英雄聯盟，每一個玩家選一個英雄，每一個英雄都有本身的特徵和和技能，特徵即數據屬性，技能即方法屬性，特徵與技能的結合體就是一個對象。

從一組對象中提取類似的部分就是類，類是全部對象都具備的特徵和技能的結合體。

注: 在python中，用變量表示特徵，用函數表示技能，於是類是變量與函數的結合體，對象是變量與方法(類中的函數)的結合體.

3.2 類相關知識

3.2.1 初始類

在python中聲明函數與聲明類很類似

聲明函數

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

聲明類

'''
語法格式:
class 類名:
    '類的文檔字符串'
     類體
'''

#咱們建立一個類
class Data:
    pass

前提：
1.只有在python2中才分新式類和經典類，python3中統一都是新式類
2.新式類和經典類聲明的最大不一樣在於,全部新式類必須繼承至少一個父類
3.全部類無論是否顯式聲明父類，都有一個默認繼承object父類

在python2中的區分
經典類：
class 類名:
    pass

新式類：
class 類名(父類):
    pass

在python3中，上述兩種定義方式全都是新式類

新式類與經典類

類是數據與函數的結合體，兩者稱爲類的屬性

class Chinese:
    country='China'
    def __init__(self,name,age,sex):
        self.Name=name      # 類的數據屬性
        self.Age=age
        self.Sex=sex

    def talk(self):         # 類的函數屬性
        print('talking',self)

例如：

class Garen:        　　　　　　#定義英雄蓋倫的類，不一樣的玩家能夠用它實例出本身英雄;
    camp='Demacia'  　　　　　　#全部玩家的英雄(蓋倫)的陣營都是Demacia;
    def attack(self,enemy):   #普通攻擊技能，enemy是敵人;
        enemy.life_value-=self.aggressivity #根據本身的攻擊力，攻擊敵人就減掉敵人的生命值。

3.2.2 類的兩種引用方式

1. 屬性引用(類名.屬性)

>>> Garen.camp #引用類的數據屬性，該屬性與全部對象/實例共享
'Demacia'
>>> Garen.attack #引用類的函數屬性，該屬性也共享
<function Garen.attack at 0x101356510>
>>> Garen.name='Garen' #增長屬性
>>> del Garen.name #刪除屬性

2. 實例化

類名加括號就是實例化，會自動觸發__init__函數的運行，能夠用它來爲每一個對象實例定製本身的特徵

class Garen:        #定義英雄蓋倫的類，不一樣的玩家能夠用它實例出本身英雄;
    camp='Demacia'  #全部玩家的英雄(蓋倫)的陣營都是Demacia;
    def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻擊力58...;
        self.nickname=nickname  #爲本身的蓋倫起個別名;
        self.aggressivity=aggressivity #英雄都有本身的攻擊力;
        self.life_value=life_value #英雄都有本身的生命值;
    def attack(self,enemy):   #普通攻擊技能，enemy是敵人;
        enemy.life_value-=self.aggressivity #根據本身的攻擊力，攻擊敵人就減掉敵人的生命值。

實例化:類名+括號

>>> g1=Garen('草叢倫') #就是在執行Garen.__init__(g1,'草叢倫')，而後執行__init__內的代碼g1.nickname=‘草叢倫’等

self的做用: 在實例化的同時自動將對象/實例自己傳給__init__的第一個參數，self能夠是任意名字，建議使用self，編碼規範。

# 實例化
class Chinese:
    country = 'China'       # 類變量
    def __init__(self, name, age, sex):  # Chinese.__init__(p1,'shuke','18','male')
        self.Name = name                 # p1.Name=name; p1.Age=age; p1.Sex=sex
        self.Age = age
        self.Sex = sex

    def talk(self):
        print('%s is talking' % self.Name)

# 實例化        
p1 = Chinese('shuke', '18', 'male')  # Chinese.__init__(p1,'shuke','18','male')
p2 = Chinese('jack', '25', 'female')  # Chinese.__init__(p2,'jack','25','female')

示例

3.類屬性的補充

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

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

3.3 對象相關知識

對象是關於類而實際存在的一個例子，即實例,類實例化以後獲得的就是一個具體的對象。

>>> g1=Garen('草叢倫') #類實例化獲得g1這個實例，基於該實例咱們講解實例相關知識
>>> type(g1) #查看g1的類型就是類Garen
<class '__main__.Garen'>
>>> isinstance(g1,Garen) #g1就是Garen的實例
True

3.3.1 對象/實例只有一種做用:屬性引用

#對象/實例自己其實只有數據屬性
>>> g1.nickname
'草叢倫'
>>> g1.aggressivity
>>> g1.life_value
'''
查看實例屬性
一樣是dir和內置__dict__兩種方式
特殊實例屬性
__class__
__dict__
....
'''

對象/實例自己只有數據屬性，可是python的class機制會將類的函數綁定到對象上，稱爲對象的方法，或者叫綁定方法，綁定方法惟一綁定一個對象，同一個類的方法綁定到不一樣的對象上，屬於不一樣的方法，會存在於不一樣的內存地址中...

>>> g1.attack #對象的綁定方法
<bound method Garen.attack of <__main__.Garen object at 0x101348dd8>>

>>> Garen.attack #對象的綁定方法attack本質就是調用類的函數attack的功能，兩者是一種綁定關係
<function Garen.attack at 0x101356620>

對象的綁定方法的特別之處: obj.func()會把obj傳給func的第一個參數。

3.4 對象之間的交互

建立一個Riven類

class Riven:
    camp='Noxus'  #全部玩家的英雄(銳雯)的陣營都是Noxus;
    def __init__(self,nickname,aggressivity=54,life_value=414): #英雄的初始攻擊力54;
        self.nickname=nickname  #爲本身的銳雯起個別名;
        self.aggressivity=aggressivity #英雄都有本身的攻擊力;
        self.life_value=life_value #英雄都有本身的生命值;
    def attack(self,enemy):   #普通攻擊技能，enemy是敵人;
        enemy.life_value-=self.aggressivity #根據本身的攻擊力，攻擊敵人就減掉敵人的生命值。

實例一個Riven對象

>>> r1=Riven('銳雯雯')

交互：銳雯雯攻擊草叢倫，反之同樣

>>> g1.life_value
455
>>> r1.attack(g1)
>>> g1.life_value
401

3.5 類名稱空間與對象/實例名稱空間

建立一個類就會建立一個類的名稱空間，用來存儲類中定義的全部名字，這些名字稱爲類的屬性。

類有兩種屬性：

數據屬性做用是共享給全部對象使用
函數屬性

>>> id(r1.camp) #本質就是在引用類的camp屬性，兩者id同樣
4315241024
>>> id(Riven.camp)
4315241024

而類的函數屬性是綁定到全部對象的：

>>> id(r1.attack) 
>>> id(Riven.attack)

'''
r1.attack就是在執行Riven.attack的功能，python的class機制會將Riven的函數屬性attack綁定給r1，r1至關於拿到了一個指針，指向Riven類的attack功能

除此以外r1.attack()會將r1傳給attack的第一個參數
'''

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

obj.name會先從obj本身的名稱空間裏查找name，找不到則去類中查找name，類也找不到就找父類...最後都找不到就拋出異常。

3.6 小結

定義瑞雯類：

定義一個瑞雯類:

class Riven:
    camp='Noxus'
    def __init__(self,nickname,
                 aggressivity=54,
                 life_value=414,
                 money=1001,
                 armor=3):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value
        self.money=money
        self.armor=armor
    def attack(self,enemy):
        damage_value=self.aggressivity-enemy.armor
        enemy.life_value-=damage_value

瑞雯類

定義一個蓋倫類:

class Garen:
    camp='Demacia'
    def __init__(self,nickname,
                 aggressivity=58,
                 life_value=455,
                 money=100,
                 armor=10):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value
        self.money=money
        self.armor=armor
    def attack(self,enemy):
        damage_value=self.aggressivity-enemy.armor
        enemy.life_value-=damage_value

蓋倫類

定義裝備：

class BlackCleaver:
    def __init__(self,price=475,aggrev=9,life_value=100):
        self.price=price
        self.aggrev=aggrev
        self.life_value=life_value
    def update(self,obj):
        obj.money-=self.price #減錢
        obj.aggressivity+=self.aggrev #加攻擊
        obj.life_value+=self.life_value #加生命值
    def fire(self,obj): #這是該裝備的主動技能,噴火,燒死對方
        obj.life_value-=1000 #假設火燒的攻擊力是1000

裝備類

類之間的交互:

r1=Riven('草叢倫')
g1=Garen('蓋文')
b1=BlackCleaver()

print(r1.aggressivity,r1.life_value,r1.money) #r1的攻擊力,生命值,護甲

if r1.money > b1.price:
    r1.b1=b1
    b1.update(r1)


print(r1.aggressivity,r1.life_value,r1.money) #r1的攻擊力,生命值,護甲

print(g1.life_value)
r1.attack(g1) #普通攻擊
print(g1.life_value)
r1.b1.fire(g1) #用裝備攻擊
print(g1.life_value) #g1的生命值小於0就死了

類交互

四. 繼承與派生

4.1 什麼是繼承？

繼承是一種建立新類的方式，在python中，新建的類能夠繼承一個或多個父類，父類又可稱爲基類或超類，新建的類稱爲派生類或子類。

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

class ParentClass1: #定義父類
    pass

class ParentClass2: #定義父類
    pass

class SubClass(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'>,)

繼承的優勢:

減小冗餘代碼

4.2 什麼是派生

在子類定義新的屬性，覆蓋掉父類的屬性,稱爲派生。

class Animal:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def talk(self):
        print('%s 正在叫' %self.name)

class People(Animal):       # 繼承了Animal類
    def __init__(self, name, age, sex,education):
        Animal.__init__(self,name,age,sex)
        self.education=education

    def talk(self):         # 子類覆蓋了父類的talk方法,即派生
        Animal.talk(self)
        print('%s say hello' %self.name)

4.3 繼承與抽象（先抽象再繼承）

抽象即抽取相似或者說提取共同存在的部分。

抽象分紅兩個層次:

1.將奧巴馬和梅西兩個對象共同的部分抽取成類，好比:會說話，能夠吃飯，男人等等一系列特徵...

2.將人，豬，狗這三個對象共同的部分抽取成父類。

抽象最主要的做用是劃分類別（能夠隔離關注點，下降複雜度）

繼承: 基於抽象的結果，經過編程語言去實現它，確定是先經歷抽象這個過程，才能經過繼承的方式去表達出抽象的結構。

抽象只是分析和設計的過程當中，一個動做或者說一種技巧，經過抽象能夠獲得類。

4.4 繼承與重用性

在開發程序的過程當中，若是咱們定義了一個類A，而後又想新創建另一個類B，可是類B的大部份內容與類A的相同時

咱們不可能從頭開始寫一個類B，這就用到了類的繼承的概念。

經過繼承的方式新建類B，讓B繼承A，B會‘遺傳’A的全部屬性(數據屬性和函數屬性)，實現代碼重用

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

　　貓能夠：喵喵叫、吃、喝、拉、撒

　　狗能夠：汪汪叫、吃、喝、拉、撒

若是咱們要分別爲貓和狗建立一個類，那麼就須要爲 貓 和 狗 實現他們全部的功能，僞代碼以下：
 

#貓和狗有大量相同的內容
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 cry(self):
        print('喵喵叫')

class Dog(Animal):

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

    def cry(self):
        print('汪汪叫')


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

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

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

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

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

示例1

class Hero:
    def __init__(self,nickname,aggressivity,life_value):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value

    def move_forward(self):
        print('%s move forward' %self.nickname)

    def move_backward(self):
        print('%s move backward' %self.nickname)

    def move_left(self):
        print('%s move forward' %self.nickname)

    def move_right(self):
        print('%s move forward' %self.nickname)

    def attack(self,enemy):
        enemy.life_value-=self.aggressivity
class Garen(Hero):
    pass

class Riven(Hero):
    pass

g1=Garen('草叢倫',100,300)
r1=Riven('銳雯雯',57,200)

print(g1.life_value)
r1.attack(g1)
print(g1.life_value)

'''
運行結果
243
'''

提示: 使用已經建立的的類創建一個新的類，這樣就重用了已有類的代碼中的一大部分功能，大大減小了編程工做量，這就是常說的軟件重用，不只能夠重用本身的類，也能夠繼承別人的，好比標準庫，來定製新的數據類型，這樣就是大大縮短了軟件開發週期，對大型軟件開發來講，意義重大.

注意: 像g1.life_value之類的屬性引用，會先從實例中找life_value而後去類中找，而後再去父類中找...直到最頂級的父類。

固然子類也能夠添加本身新的屬性或者在本身的類體中從新定義這些屬性(不會影響到父類)，須要注意的是，一旦從新定義了本身的屬性且與父類重名，那麼調用新增的屬性時，就以本身爲準了。

class Riven(Hero):
    camp='Noxus'
    def attack(self,enemy): #在子類中定義新的attack,再也不使用父類的attack,且不會影響父類
        print('from riven')
    def fly(self): #在子類中定義新的
        print('%s is flying' %self.nickname)

在子類中，新建的重名的函數屬性，在編輯函數內功能的時候，有可能須要重用父類中重名的那個函數功能，應該是用調用普通函數的方式，即：類名.func()，此時就與調用普通函數無異了，所以即使是self參數也要爲其傳值。

class Riven(Hero):
    camp='Noxus'
    def __init__(self,nickname,aggressivity,life_value,skin):
        Hero.__init__(self,nickname,aggressivity,life_value) #調用父類功能
        self.skin=skin #新屬性
    def attack(self,enemy): #在本身這裏定義新的attack,再也不使用父類的attack,且不會影響父類
        Hero.attack(self,enemy) #調用功能
        print('from riven')
    def fly(self): #在本身這裏定義新的
        print('%s is flying' %self.nickname)

r1=Riven('銳雯雯',57,200,'比基尼')
r1.fly()
print(r1.skin)

'''
運行結果
銳雯雯 is flying
比基尼

'''

4.5 組合與重用性

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

組合: 指的是,在一個類中以另一個類的對象做爲數據屬性，稱爲類的組合

>>> class Equip: #武器裝備類
...     def fire(self):
...         print('release Fire skill')
... 
>>> class Riven: #英雄Riven的類,一個英雄須要有裝備,於是須要組合Equip類
...     camp='Noxus'
...     def __init__(self,nickname):
...         self.nickname=nickname
...         self.equip=Equip()    #組合的使用: 用Equip類產生一個裝備,賦值給實例的equip屬性
... 
>>> r1=Riven('銳雯雯')
>>> r1.equip.fire()       # 使用組合的類產生的對象所特有的方法
release Fire skill

注: 組合與繼承都是有效地利用已有類的資源的重要方式，可是兩者的概念和使用場景皆不一樣。

4.5.1 繼承的方式

經過繼承創建了派生類與基類之間的關係，它們之間是一種'是'的關係，好比白馬是馬，人是動物，西瓜是水果....

當類之間有不少相同的功能，咱們能夠提取這些共同的功能作成基類，此時使用繼承比較好，好比教授是老師

class Teacher:
    def __init__(self,name,gender):
        self.name=name
        self.gender=gender
    def teach(self):
        print('teaching')

class Professor(Teacher):   # 繼承Teacher類
    pass

p1=Professor('shuke','male')
p1.teach()
'''
執行結果:
teaching
'''

4.5.2 組合的方式

用組合的方式創建了類與組合的類之間的關係，它是一種‘有’的關係,好比教授有生日，教授教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):
        self.name=name
        self.gender=gender
    def teach(self):
        print('teaching')

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

p1=Professor('shuke','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
'''

示例1

class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

class Date:
    def __init__(self,year,mon,day):
        self.year=year
        self.mon=mon
        self.day=day

    def tell(self):
        print('%s-%s-%s' %(self.year,self.mon,self.day))

class Teacher(People):
    def __init__(self,name,age,sex,salary,year,mon,day):
        self.name=name
        self.age=age
        self.sex=sex
        self.salary=salary
        self.birth=Date(year,mon,day)

class Student(People):
    def __init__(self,name,age,sex,year,mon,day):
        self.name=name
        self.age=age
        self.sex=sex
        self.birth=Date(year,mon,day)

t=Teacher('shuke',18,'male',3000,1995,12,31)
t.birth.tell()
'''
執行結果:
1995-12-31
'''

示例2

注: 當類之間有顯著不一樣，而且較小的類是較大的類所須要的組件時，用組合比較好。

4.6 接口與歸一化設計

4.6.1 什麼是接口？

=================第一部分：Java 語言中的接口很好的展示了接口的含義: IAnimal.java
/*
* Java的Interface很好的體現了咱們前面分析的接口的特徵:
* 1)是一組功能的集合,而不是一個功能
* 2)接口的功能用於交互,全部的功能都是public,即別的對象可操做
* 3)接口只定義函數,但不涉及函數實現
* 4)這些功能是相關的,都是動物相關的功能,但光合做用就不適宜放到IAnimal裏面了 */

package com.oo.demo;
public interface IAnimal {
    public void eat();
    public void run(); 
    public void sleep(); 
    public void speak();
}

=================第二部分：Pig.java：豬」的類設計,實現了IAnnimal接口 
package com.oo.demo;
public class Pig implements IAnimal{ //以下每一個函數都須要詳細實現
    public void eat(){
        System.out.println("Pig like to eat grass");
    }

    public void run(){
        System.out.println("Pig run: front legs, back legs");
    }

    public void sleep(){
        System.out.println("Pig sleep 16 hours every day");
    }

    public void speak(){
        System.out.println("Pig can not speak"); }
}

=================第三部分：Person2.java
/*
*實現了IAnimal的「人」,有幾點說明一下: 
* 1)一樣都實現了IAnimal的接口,但「人」和「豬」的實現不同,爲了不太多代碼致使影響閱讀,這裏的代碼簡化成一行,但輸出的內容不同,實際項目中同一接口的同一功能點,不一樣的類實現徹底不同
* 2)這裏一樣是「人」這個類,但和前面介紹類時給的類「Person」徹底不同,這是由於一樣的邏輯概念,在不一樣的應用場景下,具有的屬性和功能是徹底不同的 */

package com.oo.demo;
public class Person2 implements IAnimal { 
    public void eat(){
        System.out.println("Person like to eat meat");
    }

    public void run(){
        System.out.println("Person run: left leg, right leg");
    }

    public void sleep(){
        System.out.println("Person sleep 8 hours every dat"); 
    }

    public void speak(){
        System.out.println("Hellow world, I am a person");
    } 
}

=================第四部分：Tester03.java
package com.oo.demo;

public class Tester03 {
    public static void main(String[] args) {
        System.out.println("===This is a person==="); 
        IAnimal person = new Person2();
        person.eat();
        person.run();
        person.sleep();
        person.speak();
        
        System.out.println("\n===This is a pig===");
        IAnimal pig = new Pig();
        pig.eat();
        pig.run();
        pig.sleep();
        pig.speak();
    } 
}

java中的interface

Java中的Interface

繼承的兩種用途:

繼承基類的方法，而且作出本身的改變或者擴展（代碼重用）。
聲明某個子類兼容於某基類，定義一個接口類Interface，接口類中定義了一些接口名(就是函數名)且並未實現接口的功能，子類繼承接口類，而且實現接口中的功能。

class Interface:#定義接口Interface類來模仿接口的概念，python中壓根就沒有interface關鍵字來定義一個接口。
    def read(self): #定接口函數read,未實現
        pass

    def write(self): #定義接口函數write，未實現
        pass


class Txt(Interface): #文本，具體實現read和write
    def read(self):
        print('文本數據的讀取方法')

    def write(self):
        print('文本數據的讀取方法')

class Sata(Interface): #磁盤，具體實現read和write
    def read(self):
        print('硬盤數據的讀取方法')

    def write(self):
        print('硬盤數據的讀取方法')

class Process(Interface):
    def read(self):
        print('進程數據的讀取方法')

    def write(self):
        print('進程數據的讀取方法')

模擬Interface接口實現

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

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

歸一化使得高層的外部使用者能夠不加區分的處理全部接口兼容的對象集合——就好象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

4.6.2 爲何要用接口

接口是提取了一些函數共同的功能，能夠把接口當作一個函數的集合。

在子類中去實現接口中定義的的函數。

這麼作的意義在於歸一化，什麼叫歸一化，就是隻要是基於同一個接口實現的類，那麼全部的這些類產生的對象在使用時，從用法上來講都同樣。

歸一化，讓使用者無需關心對象的類是什麼，只須要的知道這些對象都具有某些功能就能夠了，這極大地下降了使用者的使用難度。

好比: 咱們定義一個動物接口，接口裏定義了有跑、吃、呼吸等接口函數，這樣老鼠的類去實現了該接口，松鼠的類也去實現了該接口，由兩者分別產生一隻老鼠和一隻松鼠送到你面前，即使是你分別不到底哪隻是什麼鼠你確定知道他倆都會跑，都會吃，都能呼吸。

再好比: 咱們有一個汽車接口，裏面定義了汽車全部的功能，而後由本田汽車的類，奧迪汽車的類，大衆汽車的類，他們都實現了汽車接口，這樣就好辦了，你們只須要學會了怎麼開汽車，那麼不管是本田，仍是奧迪，仍是大衆咱們都會開了，開的時候根本無需關心我開的是哪一類車，操做手法(函數調用)都同樣。

4.7 抽象類

4.7.1 什麼是抽象類？

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

4.7.2 爲何要有抽象類

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

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

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

從實現角度來看，抽象類與普通類的不一樣之處在於：抽象類中只能有抽象方法(沒有實現功能)，該類不能被實例化，只能被繼承，且子類必須實現抽象方法。這一點與接口有點相似，但實際上是不一樣的。

注: 抽象方法是基類中定義的方法，但卻沒有任何實現。

4.7.3 python中抽象類的實現

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'Shuke'

#一切皆文件
import abc 　　　　　　　　　　#利用abc模塊實現抽象類

class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod     #定義抽象方法，無需實現功能
    def read(self):
        '子類必須定義讀功能'
        pass

    @abc.abstractmethod     #定義抽象方法，無需實現功能
    def write(self):
        '子類必須定義寫功能'
        pass

# 驗證一
# class Txt(All_file):
#     pass
#
# t1=Txt() #報錯,子類沒有定義抽象方法

# 驗證二
class Txt(All_file):    #子類繼承抽象類，可是必須定義read和write方法
    def read(self):
        print('文本數據的讀取方法')

    def write(self):
        print('文本數據的讀取方法')

class Sata(All_file):   #子類繼承抽象類，可是必須定義read和write方法
    def read(self):
        print('硬盤數據的讀取方法')

    def write(self):
        print('硬盤數據的讀取方法')

class Process(All_file): #子類繼承抽象類，可是必須定義read和write方法
    def read(self):
        print('進程數據的讀取方法')

    def write(self):
        print('進程數據的讀取方法')

wenbenwenjian=Txt()     # 實例化
yingpanwenjian=Sata()
jinchengwenjian=Process()

#這樣你們都是被歸一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()
print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)
'''
執行結果:
文本數據的讀取方法
硬盤數據的讀取方法
進程數據的讀取方法
file
file
file
'''

4.7.4 抽象類與接口

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

抽象類是一個介於類和接口之間的一個概念，同時具有類和接口的部分特性，能夠用來實現歸一化設計。

4.8 繼承實現的原理(繼承順序)

4.8.1 繼承順序

1. python中的類能夠繼承多個類，java和c#中則只能繼承一個類。

2. python中的類若是繼承了多個類，那麼其尋找方法的方式有兩種，分別是深度優先和廣度優先。

注:

當類是經典類時，多繼承的狀況下，則會按照深度優先的順序進行查找
當類是新式類時，多繼承的狀況下，則會按照廣度優先的順序進行查找

經典類和新式類，從字面上面能夠看出一個新一箇舊，新的必然包含了更多的功能，也是以後推薦的用法，從寫法上區分，若是當前類或者父類繼承了object類，那麼當前類即是新式類，不然即是經典類。

pyhon2中才分新式類與經典類。python3中統一都是新式類。

class C1:       # C1是經典類
    pass
class C2(C1):   # C2是經典類
    pass

class N1(object):       # N1是新式類
    pass
class N2(N1):           # N2是新式類
    pass

廣度優先的繼承順序

class A(object):
    def test(self):
        print('from A')

class B(A):
    def test(self):
        print('from B')

class C(A):
    def test(self):
        print('from C')

class D(B):
    def test(self):
        print('from D')

class E(C):
    def test(self):
        print('from E')

class F(D,E):
    # def test(self):
    #     print('from F')
    pass
f1=F()
f1.test()
print(F.__mro__) #只有新式纔有這個屬性能夠查看線性列表，經典類沒有這個屬性

#新式類繼承順序:F->D->B->E->C->A
#經典類繼承順序:F->D->B->A->E->C
#python3中統一都是新式類
#pyhon2中才分新式類與經典類

廣度優先的繼承順序

4.8.2 繼承原理

python究竟是如何實現繼承的，對於你定義的每個類，python會計算出一個方法解析順序(MRO)列表，這個MRO列表就是一個簡單的全部基類的線性順序列表，例如

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

python會按照列表裏面類的排列順序進行查找

爲了實現繼承,python會在MRO列表上從左到右開始查找基類,直到找到第一個匹配這個屬性的類爲止。
而這個MRO列表的構造是經過一個C3線性化算法來實現的。咱們不去深究這個算法的數學原理,它實際上就是合併全部父類的MRO列表並遵循以下三條準則:
1. 子類會先於父類被檢查
2. 多個父類會根據它們在列表中的順序被檢查
3. 若是對下一個類存在兩個合法的選擇,選擇第一個父類

4.9 子類中調用父類方法

子類繼承了父類的方法，而後想進行修改，注意了是基於原有的基礎上修改，那麼就須要在子類中調用父類的方法

方式一: 父類名.父類方法()

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'

class Vehicle: #定義交通工具類
     Country='China'
     def __init__(self,name,speed,load,power):   
         self.name=name
         self.speed=speed
         self.load=load
         self.power=power

     def run(self):
         print('開動啦...')

class Subway(Vehicle): #地鐵
    def __init__(self,name,speed,load,power,line):
        Vehicle.__init__(self,name,speed,load,power)   # 調用:父類名.父類方法()
        self.line=line

    def run(self):
        print('地鐵%s號線歡迎您' %self.line)
        Vehicle.run(self)

line13=Subway('中國地鐵','180m/s','1000人/箱','電',13)
line13.run()

方法1

方式二: super()

class Vehicle: #定義交通工具類
     Country='China'
     def __init__(self,name,speed,load,power):
         self.name=name
         self.speed=speed
         self.load=load
         self.power=power

     def run(self):
         print('開動啦...')

class Subway(Vehicle): #地鐵
    def __init__(self,name,speed,load,power,line):
        #super(Subway,self) 就至關於實例自己 在python3中super()等同於super(Subway,self)
        super().__init__(name,speed,load,power)
        self.line=line

    def run(self):
        print('地鐵%s號線歡迎您' %self.line)
        super(Subway,self).run()

class Mobike(Vehicle):#摩拜單車
    pass

line13=Subway('中國地鐵','180m/s','1000人/箱','電',13)
line13.run()

方法2

不用super()函數引起的慘案

#!/usr/bin/env python
#-*- coding:utf-8 -*-

#每一個類中都繼承了且重寫了父類的方法
class A:
    def __init__(self):
        print('A的構造方法')
class B(A):
    def __init__(self):
        print('B的構造方法')
        A.__init__(self)


class C(A):
    def __init__(self):
        print('C的構造方法')
        A.__init__(self)


class D(B,C):
    def __init__(self):
        print('D的構造方法')
        B.__init__(self)
        C.__init__(self)

    pass
f1=D()

print(D.__mro__) #python2中沒有這個屬性
'''
執行結果:
D的構造方法
B的構造方法
A的構造方法
C的構造方法
A的構造方法
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
'''

示例

當使用super()函數時,Python會在MRO列表上繼續搜索下一個類。只要每一個從新定義的方法統一使用super()並只調用它一次,那麼控制流最終會遍歷完整個MRO列表,每一個方法也只會被調用一次

注: 使用super調用的全部屬性，都是從MRO列表當前的位置日後找，千萬不要經過看代碼去找繼承關係，必定要看MRO列表.

#!/usr/bin/env python
#-*- coding:utf-8 -*-

#每一個類中都繼承了且重寫了父類的方法
class A:
    def __init__(self):
        print('A的構造方法')
class B(A):
    def __init__(self):
        print('B的構造方法')
        super(B,self).__init__()


class C(A):
    def __init__(self):
        print('C的構造方法')
        super(C,self).__init__()


class D(B,C):
    def __init__(self):
        print('D的構造方法')
        super(D,self).__init__()

f1=D()
print(D.__mro__) # python2中沒有這個屬性

'''
執行結果:
D的構造方法
B的構造方法
C的構造方法
A的構造方法
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
'''

示例

五. 多態與多態性

5.1 多態

多態指的是一類事物有多種形態，(一個抽象類有多個子類，於是多態的概念依賴於繼承)

1. 序列類型有多種形態：字符串，列表，元組。

2. 動物有多種形態：人，狗，豬

import abc
class Animal(metaclass=abc.ABCMeta): #同一類事物:動物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #動物的形態之一:人
    def talk(self):
        print('say hello...')

class Dog(Animal): #動物的形態之二:狗
    def talk(self):
        print('say wangwang...')

class Pig(Animal): #動物的形態之三:豬
    def talk(self):
        print('say hengheng...')

3. 文件有多種形態：文本文件，可執行文件

import abc
class File(metaclass=abc.ABCMeta): #同一類事物:文件
    @abc.abstractmethod
    def click(self):
        pass

class Text(File): #文件的形態之一:文本文件
    def click(self):
        print('open file')

class ExeFile(File): #文件的形態之二:可執行文件
    def click(self):
        print('execute file')

5.2 多態性

5.2.1 什麼是多態性？

多態與多態性是兩種不一樣的概念。

多態性是指具備不一樣功能的函數可使用相同的函數名，這樣就能夠用一個函數名調用不一樣功能的函數。

在面向對象方法中通常是這樣表述多態性: 向不一樣的對象發送同一條消息(obj.func():是調用了obj的func方法，又稱爲向obj發送了一條消息func)，不一樣的對象在接收時會產生不一樣的行爲(即方法)。也就是說，每一個對象能夠用本身的方式去響應共同的消息。所謂消息，就是調用函數，不一樣的行爲就是指不一樣的實現，即執行不一樣的函數。

好比：老師.下課鈴響了()，學生.下課鈴響了()，老師執行的是下班操做，學生執行的是放學操做，雖然兩者消息同樣，可是執行的效果不一樣。

多態性分爲靜態多態性和動態多態性

靜態多態性：如任何類型均可以用運算符+進行運算

動態多態性: 以下所示

>>> def func(obj):
...     print(obj.__len__())
... 
>>> func('Hello')
5
>>> func([0,1,2,3])
4
>>> func((7,8,9))
3

示例1

#!/usr/bin/python
# -*- coding:utf-8 -*-

class Animal:
    def talk(self):
        print('Is talking')

class People(Animal):
    def talk(self):
        print('say hello...')

class Pig(Animal):
    def talk(self):
        print('say hengheng...')

class Dog(Animal):
    def talk(self):
        print('say wangwang...')


class Cat(Animal):
    def talk(self):
        print('say miaomiao...')

def func(obj):      # 參數obj就是對態性的體現
    obj.talk()      # 執行同一個方法

peo1=People()       # 產生一我的的對象
pig1=Pig()          # 產生一個豬的對象
dog1=Dog()          # 產生一個狗的對象
cat1=Cat()          # 產生一個貓的對象

func(peo1)
func(pig1)
func(dog1)
func(cat1)
'''
執行結果:
say hello...
say hengheng...
say wangwang...
say miaomiao...
'''

示例2

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import abc
class File(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def click(self):
        pass

class Text(File):
    def click(self):
        print('open file')

class ExeFile(File):
    def click(self):
        print('execute file')

def func(file):         # 參數file就是對態性的體現
   file.click()

t1=Text()               # 實例化一個文本文件的對象
e1=ExeFile()            # 實例化一個可執行文件的對象

func(t1)
func(e1)

'''
執行結果:
open file
execute file
'''

示例3

綜上所述: 多態性是一個接口(函數func),多種實現如obj.talk()

5.2.2 多態性的好處？(優勢)

優勢:

1.增長了程序的靈活性

　　以不變應萬變，不論對象變幻無窮，使用者都是同一種形式去調用，如func(animal)

2.增長了程序額可擴展性

經過繼承animal類建立了一個新的類，使用者無需更改本身的代碼，仍是用func(animal)去調用

>>> class Cat(Animal): #屬於動物的另一種形態：貓
...     def talk(self):
...         print('say miao')
... 
>>> def func(animal): #對於使用者來講，本身的代碼根本無需改動
...     animal.talk()
... 
>>> cat1=Cat() #實例出一隻貓
>>> func(cat1) #甚至連調用方式也無需改變，就能調用貓的talk功能
say miao

'''
這樣咱們新增了一個形態Cat，由Cat類產生的實例cat1，使用者能夠在徹底不須要修改本身代碼的狀況下。使用和人、狗、豬同樣的方式調用cat1的talk方法，即func(cat1)
'''

六. 封裝

6.1 什麼是封裝？

在程序設計中，封裝（Encapsulation）是對具體對象的一種抽象，即將某些部分隱藏起來，在程序外部看不到，其含義是其餘程序沒法調用。

要了解封裝，離不開「私有化」，就是將類或者是函數中的某些屬性限制在某個區域以內，外部沒法調用。

"封裝" 就是將抽象獲得的數據和行爲（或功能）相結合，造成一個有機的總體（即類）；封裝的目的是加強安全性和簡化編程，使用者沒必要了解具體的實現細節，而只是要經過外部接口，一特定的訪問權限來使用類的成員。

6.2 爲何要封裝?

封裝數據的主要緣由是：保護隱私（把不想別人知道的東西封裝起來）

封裝方法的主要緣由是：隔離複雜度（好比：電視機，咱們看見的就是一個黑匣子，其實裏面有不少電器元件，對於用戶來講，咱們不須要清楚裏面都有些元件，電視機把那些電器元件封裝在黑匣子裏，提供給用戶的只是幾個按鈕接口，經過按鈕就能實現對電視機的操做。）

提示：在編程語言裏，對外提供的接口（接口可理解爲了一個入口），就是函數，稱爲接口函數，這與接口的概念還不同，接口表明一組接口函數的集合體。

6.3 封裝什麼？

你錢包的有多少錢 (數據的封裝)

箱子裏面有什麼東西 (數據的封裝)

你撒尿的具體功能是怎麼實現的 (方法的封裝)

6.4 封裝分爲兩個層面

封裝其實分爲兩個層面，但不管哪一種層面的封裝，都要對外界提供好訪問你內部隱藏內容的接口(接口能夠理解爲入口，有了這個入口，使用者無需且不可以直接訪問到內部隱藏的細節，只能走接口，而且咱們能夠在接口的實現上附加更多的處理邏輯，從而嚴格控制使用者的訪問)

第一個層面的封裝（什麼都不用作）：建立類和對象會分別建立兩者的名稱空間，咱們只能用類名.或者obj.的方式去訪問裏面的名字，這自己就是一種封裝。

>>> r1.nickname
'草叢倫'
>>> Riven.camp
'Noxus

注: 對於這一層面的封裝（隱藏），類名.和實例名.就是訪問隱藏屬性的接口

第二個層面的封裝: 類中把某些屬性和方法隱藏起來(或者說定義成私有的)，只在類的內部使用、外部沒法訪問，或者留下少許接口（函數）供外部訪問。

在python中用雙下劃線的方式實現隱藏屬性（設置成私有的）

class A:
    __N=0 #類的數據屬性就應該是共享的,可是語法上是能夠把類的數據屬性設置成私有的如__N,會變形爲_A__N
    def __init__(self):
        self.__X=10 #變形爲self._A__X
    def __foo(self): #變形爲_A__foo
        print('from A')
    def bar(self):
        self.__foo() #只有在類內部才能夠經過__foo的形式訪問到.

這種自動變形的特色：

1. 類中定義的__x只能在內部使用，如self.__x，引用的就是變形的結果。

2. 這種變形其實正是針對外部的變形，在外部是沒法經過__x這個名字訪問到的。

3. 在子類定義的__x不會覆蓋在父類定義的__x，由於子類中變造成了：_子類名__x,而父類中變造成了：_父類名__x，即雙下滑線開頭的屬性在繼承給子類時，子類是沒法覆蓋的。

注: 對於這一層面的封裝(隱藏)，咱們須要在類中定義一個函數(接口函數)在它內部訪問被隱藏的屬性，而後外部就可使用了。

這種變形須要注意的問題是：

1.這種機制也並無真正意義上限制咱們從外部直接訪問屬性，知道了類名和屬性名就能夠拼出名字：_類名__屬性，而後就能夠訪問了，如a._A__N

>>> a=Animal()
>>> a._Animal__name　　　　# 在類外部一種特殊的訪問私有屬性的方式
>>> a._Animal__age
>>>Animal._Animal__sex

2.變形的過程只在類的定義是發生一次,在定義後的賦值操做，不會變形

class A:
    __N = 10
    def __init__(self):
        self.__X = 10

a= A()
print(a.__dict__)
a.__Y=5
print(a.__dict__)
'''
執行結果:
{'_A__X': 10}
{'__Y': 5, '_A__X': 10}     # 定義後的賦值操做，__Y，沒有變形

3.在繼承中，父類若是不想讓子類覆蓋本身的方法，能夠將方法定義爲私有的

>>> class A:
...     def fa(self):
...         print('from A')
...     def test(self):
...         self.fa()
... 
>>> class B(A):
...     def fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from B

正常狀況

#把fa定義成私有的，即__fa
>>> class A:
...     def __fa(self): #在定義時就變形爲_A__fa
...         print('from A')
...     def test(self):
...         self.__fa() #只會與本身所在的類爲準,即調用_A__fa
... 
>>> class B(A):
...     def __fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from A

私有

python並不會真的阻止你訪問私有的屬性，模塊也遵循這種約定，若是模塊名以單下劃線開頭，那麼from module import *時不能被導入,可是你from module import _private_module依然是能夠導入的

其實不少時候你去調用一個模塊的功能時會遇到單下劃線開頭的(socket._socket,sys._home,sys._clear_type_cache),這些都是私有的，原則上是供內部調用的，做爲外部的你，獨斷獨行也是能夠用的，只不過顯得稍微傻逼一點點。

python要想與其餘編程語言同樣，嚴格控制屬性的訪問權限，只能藉助內置方法如__getattr__，詳見面向對象進階。

6.5 特性(property)

6.5.1 什麼是property?

property是一種特殊的屬性，訪問它時會執行一段功能（函數）而後返回值。

import math
class Circle:
    def __init__(self,radius): #圓的半徑radius
        self.radius=radius

    @property
    def area(self):
        return math.pi * self.radius**2 #計算面積

    @property
    def perimeter(self):
        return 2*math.pi*self.radius #計算周長

c=Circle(10)
print(c.radius)
print(c.area) #能夠向訪問數據屬性同樣去訪問area,會觸發一個函數的執行,動態計算出一個值
print(c.perimeter) #同上
'''
輸出結果:
314.1592653589793
62.83185307179586
'''

注: 此時的特性arear和perimeter不能被賦值

c.area=3 #爲特性area賦值
'''
拋出異常:
AttributeError: can't set attribute
'''

6.5.2 爲何要用property？

將一個類的函數定義成特性之後，對象再去使用的時候obj.name,根本沒法察覺本身的name是執行了一個方法而後計算出來的返回值，這種特性的使用方式遵循了統一訪問的原則。

ps：面向對象的封裝有三種方式:
【public】
這種其實就是不封裝,是對外公開的
【protected】
這種封裝方式對外不公開,但對朋友(friend)或者子類(形象的說法是「兒子」,但我不知道爲何你們 不說「女兒」,就像「parent」原本是「父母」的意思,但中文都是叫「父類」)公開
【private】
這種封裝對誰都不公開

python並無在語法上把它們三個內建到本身的class機制中，在C++裏通常會將全部的全部的數據都設置爲私有的，而後提供set和get方法（接口）去設置和獲取，在python中經過property方法能夠實現，以下所示：

class Foo:
    def __init__(self,val):
        self.__NAME=val #將全部的數據屬性都隱藏起來

    @property
    def name(self):
        return self.__NAME #obj.name訪問的是self.__NAME(這也是真實值的存放位置)

    @name.setter
    def name(self,value):
        if not isinstance(value,str):  #在設定值以前進行類型檢查
            raise TypeError('%s must be str' %value)
        self.__NAME=value #經過類型檢查後,將值value存放到真實的位置self.__NAME

    @name.deleter
    def name(self):
        raise TypeError('Can not delete')

f=Foo('shuke')
print(f.name)
# f.name=10 #拋出異常'TypeError: 10 must be str'
del f.name #拋出異常'TypeError: Can not delete'

class Foo:
    def __init__(self,val):
        self.__NAME=val #將全部的數據屬性都隱藏起來

    def getname(self):
        return self.__NAME #obj.name訪問的是self.__NAME(這也是真實值的存放位置)

    def setname(self,value):
        if not isinstance(value,str):  #在設定值以前進行類型檢查
            raise TypeError('%s must be str' %value)
        self.__NAME=value #經過類型檢查後,將值value存放到真實的位置self.__NAME

    def delname(self):
        raise TypeError('Can not delete')

    name=property(getname,setname,delname) #不如裝飾器的方式清晰

一種古老的property用法

6.6 封裝與擴展性

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

#類的設計者
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('臥室','shuke',20,20,20)
>>> r1.tell_area() #使用者調用接口tell_area
400

#類的設計者，輕鬆的擴展了功能，而類的使用者徹底不須要改變本身的代碼
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()
8000

七. 靜態方法與類方法

一般狀況下，在類中定義的全部函數(注意了，這裏說的就是全部，跟self不要緊，self也只是一個再普通不過的參數而已)都是對象的綁定方法，對象在調用綁定方法時會自動將本身做爲參數傳遞給方法的第一個參數。除此以外還有兩種常見的方法：靜態方法和類方法，兩者是爲類量身定製的，可是實例非要使用，也不會報錯，後續將介紹。

7.1 靜態方法

一種普通函數，位於類定義的命名空間中，不會對任何實例類型進行操做，python爲咱們內置了函數staticmethod來把類中的函數定義成靜態方法。

class Foo:
    def spam(x,y,z): 　　　　　　# 類中的一個函數，千萬不要懵逼，self和x沒有什麼不一樣，都是參數名而已
        print(x,y,z)
    spam=staticmethod(spam) 　　# 把spam函數作成靜態方法

基於以前所學裝飾器的知識，@staticmethod 等同於spam=staticmethod(spam),因而

class Foo:
    @staticmethod #裝飾器
    def spam(x,y,z):
        print(x,y,z)

示例：

print(type(Foo.spam)) #類型本質就是函數
Foo.spam(1,2,3) #調用函數應該有幾個參數就傳幾個參數

f1=Foo()
f1.spam(3,3,3) #實例也可使用,但一般靜態方法都是給類用的,實例在使用時喪失了自動傳值的機制

'''
<class 'function'>
2 3
3 3
'''

應用場景: 編寫類時須要採用不少不一樣的方式來建立實例，而咱們只有一個__init__函數，此時靜態方法就派上用場了

class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    @staticmethod
    def now(): #用Date.now()的形式去產生實例,該實例用的是當前時間
        t=time.localtime() #獲取結構化的時間格式
        return Date(t.tm_year,t.tm_mon,t.tm_mday) #新建實例而且返回
    @staticmethod
    def tomorrow():#用Date.tomorrow()的形式去產生實例,該實例用的是明天的時間
        t=time.localtime(time.time()+86400)
        return Date(t.tm_year,t.tm_mon,t.tm_mday)

a=Date('1987',11,27) #本身定義時間
b=Date.now() #採用當前時間
c=Date.tomorrow() #採用明天的時間

print(a.year,a.month,a.day)
print(b.year,b.month,b.day)
print(c.year,c.month,c.day)

7.2 類方法

類方法是給類用的，類在使用時會將類自己當作參數傳給類方法的第一個參數，python爲咱們內置了函數classmethod來把類中的函數定義成類方法。

class A:
    x=1
    @classmethod
    def test(cls):
        print(cls,cls.x)

class B(A):
    x=2
B.test()

'''
輸出結果:
<class '__main__.B'> 2
'''

應用場景:

import time
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    @staticmethod
    def now():
        t=time.localtime()
        return Date(t.tm_year,t.tm_mon,t.tm_mday)

class EuroDate(Date):
    def __str__(self):
        return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)

e=EuroDate.now()
print(e) #咱們的意圖是想觸發EuroDate.__str__,可是結果爲
'''
輸出結果:
<__main__.Date object at 0x1013f9d68>
'''

示例1

由於e就是用Date類產生的,因此根本不會觸發EuroDate.__str__,解決方法就是用classmethod

import time
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    # @staticmethod
    # def now():
    #     t=time.localtime()
    #     return Date(t.tm_year,t.tm_mon,t.tm_mday)

    @classmethod #改爲類方法
    def now(cls):
        t=time.localtime()
        return cls(t.tm_year,t.tm_mon,t.tm_mday) #哪一個類來調用,即用哪一個類cls來實例化

class EuroDate(Date):
    def __str__(self):
        return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)

e=EuroDate.now()
print(e) #咱們的意圖是想觸發EuroDate.__str__,此時e就是由EuroDate產生的,因此會如咱們所願
'''
輸出結果:
year:2017 month:3 day:3
'''

示例2

強調,敲黑板....

注意: 靜態方法和類方法雖然是給類準備的，可是若是實例去用，也是能夠用的，只不過實例去調用的時候容易讓人混淆。

x=e.now() #經過實例e去調用類方法也同樣可使用,靜態方法也同樣
print(x)
'''
輸出結果:
year:2017 month:3 day:3
'''

7.3 類中定義的函數分紅兩大類

1. 綁定方法（綁定給誰，誰來調用就自動將它自己看成第一個參數傳入）：
　　1. 綁定到類的方法：用classmethod裝飾器裝飾的方法(爲類量身定製)。
　　注: 類.boud_method(),自動將類看成第一個參數傳入(其實對象也可調用，但仍將類看成第一個參數傳入)
　　2. 綁定到對象的方法：沒有被任何裝飾器裝飾的方法(爲對象量身定製)。
　　注: 對象.boud_method(),自動將對象看成第一個參數傳入(屬於類的函數，類能夠調用，可是必須按照函數的規則來，並不會進行自動傳值)
2. 非綁定方法：用staticmethod裝飾器裝飾的方法
　　 1. 不與類或對象綁定，類和對象均可以調用，可是並不會進行自動傳值,就是一個普通工具而已。
　　注: 與綁定到對象方法區分開，在類中直接定義的函數，沒有被任何裝飾器裝飾的，都是綁定到對象的方法，可不是普通函數，對象調用該方法會自動傳值，而staticmethod裝飾的方法，無論誰來調用，都不會進行自動傳值。

示例說明:

class Foo:
    def test1(self):
        pass
    @classmethod
    def test2(cls):
        print(cls)
    @staticmethod
    def test3():
        pass

f=Foo()
print(f.test1)      # 對象的綁定方法
print(Foo.test2)    # 類的綁定方法
print(Foo.test3)    # 靜態方法，只是一個函數而已，沒有進行自動傳值功能
print(f.test3)
'''
執行結果:
<bound method Foo.test1 of <__main__.Foo object at 0x0000000000B72D30>>
<bound method Foo.test2 of <class '__main__.Foo'>>
<function Foo.test3 at 0x0000000000B6C510>
<function Foo.test3 at 0x0000000000B6C510>
'''

7.4 statcimethod 與classmethod的區別

# statcimethod 與classmethod的區別
import hashlib
import time
import settings
class MySQL:
    def __init__(self,host,port):
        self.id=self.create_id()
        self.host=host
        self.port=port
        print('conneting...')

    @staticmethod
    def create_id():        # 非綁定方法，就是類中的普通工具包
        m=hashlib.md5(str(time.clock()).encode('utf-8'))
        return m.hexdigest()

    @staticmethod
    def from_conf():
        return MySQL(settings.HOST, settings.PORT)  # MySQL('127.0.0.1',3306)

    @classmethod
    def from_conf(cls):
        return cls(settings.HOST,settings.PORT)     # 在Mariadb類中調用，就將Mariadb類自身傳入，靈活性更好，至關於Mariadb('127.0.0.1',3306)

class Mariab(MySQL):
    # def __str__(self):
    #     return 'host:%s port:%s' %(self.host,self.port)
    pass

conn=MySQL.from_conf()
print(conn.host)

conn1=Mariab.from_conf()
print(conn1)
'''
執行結果:
conneting...
127.0.0.1
conneting...
<__main__.Mariab object at 0x0000000000A5D3C8>
'''

八. 面向對象的軟件開發

不少人在學完了python的class機制以後，遇到一個生產中的問題，仍是會懵逼，這其實太正常了，由於任何程序的開發都是先設計後編程，python的class機制只不過是一種編程方式，若是你硬要拿着class去和你的問題死磕，變得更加懵逼都是分分鐘的事，在之前，軟件的開發相對簡單，從任務的分析到編寫程序，再到程序的調試，能夠由一我的或一個小組去完成。可是隨着軟件規模的迅速增大，軟件任意麪臨的問題十分複雜，須要考慮的因素太多，在一個軟件中所產生的錯誤和隱藏的錯誤、未知的錯誤可能達到驚人的程度，這也不是在設計階段就徹底解決的。

因此軟件的開發實際上是一整套規範，咱們所學的只是其中的一小部分，一個完整的開發過程，須要明確每一個階段的任務，在保證一個階段正確的前提下再進行下一個階段的工做，稱之爲軟件工程。

面向對象的軟件工程包括下面幾個部：

8.1 面向對象分析（object oriented analysis ，OOA）

軟件工程中的系統分析階段，要求分析員和用戶結合在一塊兒，對用戶的需求作出精確的分析和明確的表述，從大的方面解析軟件系統應該作什麼，而不是怎麼去作。面向對象的分析要按照面向對象的概念和方法，在對任務的分析中，從客觀存在的事物和事物之間的關係，貴南出有關的對象（對象的‘特徵’和‘技能’）以及對象之間的聯繫，並將具備相同屬性和行爲的對象用一個類class來標識。

創建一個能反映這是工做狀況的需求模型，此時的模型是粗略的。

8.2 面向對象設計（object oriented design，OOD）

根據面向對象分析階段造成的需求模型，對每一部分分別進行具體的設計。

首先是類的設計，類的設計可能包含多個層次（利用繼承與派生機制）。而後以這些類爲基礎提出程序設計的思路和方法，包括對算法的設計。

在設計階段並不牽涉任何一門具體的計算機語言，而是用一種更通用的描述工具（如僞代碼或流程圖）來描述。

8.3 面向對象編程（object oriented programming，OOP）

根據面向對象設計的結果，選擇一種計算機語言把它寫成程序，能夠是python，也能夠是別的編程語言。

8.4 面向對象測試（object oriented test，OOT）

在寫好程序後交給用戶使用前，必須對程序進行嚴格的測試，測試的目的是發現程序中的錯誤並修正它。

面向對象的測試是用面向對象的方法進行測試，以類做爲測試的基本單元。

8.5 面向對象維護（object oriendted soft maintenance，OOSM）

正如對任何產品都須要進行售後服務和維護同樣，軟件在使用時也會出現一些問題，或者軟件商想改進軟件的性能，這就須要修改程序。

因爲使用了面向對象的方法開發程序，使用程序的維護比較容易。

由於對象的封裝性，修改一個對象對其餘的對象影響很小，利用面向對象的方法維護程序，大大提升了軟件維護的效率，可擴展性高。

在面向對象方法中，最先發展的確定是面向對象編程(OOP),那時OOA和OOD都尚未發展起來，所以程序設計者爲了寫出面向對象的程序，還必須深刻到分析和設計領域，尤爲是設計領域，那時的OOP實際上包含了如今的OOD和OOP兩個階段，這對程序設計者要求比較高，許多人感到很難掌握。

如今設計一個大的軟件，是嚴格按照面向對象軟件工程的5個階段進行的，這個5個階段的工做不是由一我的從頭至尾完成的，而是由不一樣的人分別完成，這樣OOP階段的任務就比較簡單了。程序編寫者只須要根據OOd提出的思路，用面嚮對象語言編寫出程序既可。

在一個大型軟件開發過程當中，OOP只是很小的一個部分。

對於全棧開發的你來講，這五個階段都有了，對於簡單的問題，沒必要嚴格按照這個5個階段進行，每每由程序設計者按照面向對象的方法進行程序設計，包括類的設計和程序的設計。

九.小白容易犯的錯誤

1. 面向對象的程序設計看起來高大上，因此我在編程時就應該保證通篇class，這樣寫出的程序必定是好的程序（面向對象只適合那些可擴展性要求比較高的場景）

2. 不少人喜歡說面向對象三大特性（這是從哪傳出來的，封裝，多態，繼承？漏洞太多太多，好吧暫且稱爲三大特性），那麼我在基於面向對象編程時，我必定要讓我定義的類中完整的包含這三種特性，這樣寫確定是好的程序，好傢伙，我說降龍十八掌有十八掌，那麼你每次跟人幹仗都要從第一掌打到第18掌這才顯得你會了是麼，我來一萬我的你須要打10000*18掌對麼，傻叉。

3. 類有類屬性，實例有實例屬性，因此咱們在定義class時必定要定義出那麼幾個類屬性，想不到怎麼辦，那就使勁的想，定義的越多越牛逼。

這就犯了一個嚴重的錯誤，程序越早面向對象，死的越早，爲啥面向對象，由於咱們要將數據與功能結合到一塊兒，程序總體的結構都沒有出來，或者說須要考慮的問題你都沒有搞清楚個八九不離十，你就開始面向對象了，這就致使了，你在那裏幹想，自覺得想通了，定義了一堆屬性，結果後來又都用不到，或者想不通到底應該定義啥，那就一直想吧，想着想着就瘋了。

你見過哪家公司要開發一個軟件，上來就開始寫，確定是頻繁的開會討論計劃。

4. 既然這麼麻煩，那麼我完全解脫了，咱們不要用面向對象編程了，你啊，你有大才，你能成事啊，傻叉。

十. python中關於OOP的經常使用術語

抽象/實現

抽象指對現實世界問題和實體的本質表現,行爲和特徵建模,創建一個相關的子集,能夠用於繪程序結構,從而實現這種模型。抽象不只包括這種模型的數據屬性,還定義了這些數據的接口。

對某種抽象的實現就是對此數據及與之相關接口的現實化(realization)。現實化這個過程對於客戶程序應當是透明並且無關的。

封裝/接口

封裝描述了對數據/信息進行隱藏的觀念,它對數據屬性提供接口和訪問函數。經過任何客戶端直接對數據的訪問,無視接口,與封裝性都是背道而馳的,除非程序員容許這些操做。做爲實現的一部分,客戶端根本就不須要知道在封裝以後,數據屬性是如何組織的。在Python中,全部的類屬性都是公開的,但名字可能被「混淆」了,以阻止未經受權的訪問,但僅此而已,再沒有其餘預防措施了。這就須要在設計時,對數據提供相應的接口,以避免客戶程序經過不規範的操做來存取封裝的數據屬性。

注: 封裝毫不是等於「把不想讓別人看到、之後可能修改的東西用private隱藏起來」

真正的封裝是，通過深刻的思考，作出良好的抽象，給出「完整且最小」的接口，並使得內部細節能夠對外透明。

（注: 對外透明的意思是，外部調用者能夠順利的獲得本身想要的任何功能，徹底意識不到內部細節的存在）

合成

合成擴充了對類的述,使得多個不一樣的類合成爲一個大的類,來解決現實問題。合成述了一個異常複雜的系統,好比一個類由其它類組成,更小的組件也多是其它的類,數據屬性及行爲, 全部這些合在一塊兒,彼此是「有一個」的關係。

派生/繼承/繼承結構

派生描述了子類衍生出新的特性,新類保留已存類類型中全部須要的數據和行爲,但容許修改或者其它的自定義操做,都不會修改原類的定義。
繼承描述了子類屬性從祖先類繼承這樣一種方式
繼承結構表示多「代」派生,能夠述成一個「族譜」,連續的子類,與祖先類都有關係。

泛化/特化

基於繼承
泛化表示全部子類與其父類及祖先類有同樣的特色。
特化描述全部子類的自定義,也就是,什麼屬性讓它與其祖先類不一樣。

多態與多態性

多態指的是同一種事物的多種狀態：水這種事物有多種不一樣的狀態：冰，水蒸氣。

多態性的概念指出了對象如何經過他們共同的屬性和動做來操做及訪問,而不需考慮他們具體的類。