摘要：于發(fā)表了著名的有害論的論文引起了長達(dá)數(shù)年的論戰(zhàn)并由此產(chǎn)生了結(jié)構(gòu)化程序設(shè)計方法。到現(xiàn)在為止面向?qū)ο笠呀?jīng)成為了主流的開發(fā)思想。面向?qū)ο蟮某绦蛟O(shè)計優(yōu)點(diǎn)解決了程序的擴(kuò)展性。

最早的程序設(shè)計都是采用機(jī)器語言來編寫的,直接使用二進(jìn)制碼來表示機(jī)器能夠識別和執(zhí)行的指令和數(shù)據(jù)。

簡單來說,就是直接編寫 0 和 1 的序列來代表程序語言。例如:使用 0000 代表 加載(LOAD),0001 代表 存儲(STORE)等。

優(yōu)點(diǎn)：機(jī)器語言由機(jī)器直接執(zhí)行,速度快；

缺點(diǎn)：寫比較困難，修改也麻煩，這樣直接導(dǎo)致程序編寫效率十分低下,編寫程序花費(fèi)的時間往往是實(shí)際運(yùn)行時間的幾十倍或幾百倍。

由于機(jī)器語言實(shí)在是太難編寫了,于是就發(fā)展出了匯編語言。

匯編語言亦稱符號語言,用助記符代替機(jī)器 指令的操作碼,用地址符號(Symbol)或標(biāo)號(Label)代替指令或操作數(shù)的地址。

匯編語言由于是采用了助記符號來編寫程序,比用機(jī)器語言的二進(jìn)制代碼編程要方便些,在一定程度上簡化了編程過程。例如 使用 LOAD 來代替 0000,使用 STORE 來代替 0001。

即使匯編語言相比機(jī)器語言提升了可讀性,但其本質(zhì)上還是一種面向機(jī)器的語言,編寫同樣困難,也很容易出錯。

面向機(jī)器的語言通常情況下被認(rèn)為是一種“低級語言”,為了解決面向機(jī)器的語言存在的問題,計算機(jī)科學(xué)的前輩們又創(chuàng)建了面向過程的語言。

面向過程的語言被認(rèn)為是一種“高級語言”,相比面向機(jī)器的語言來說,面向過程的語言已經(jīng)不再關(guān)注機(jī)器本身的操作指令、存儲等方面,而是關(guān)注如何一步一步的解決具體的問題,即:解決問題的過程,這應(yīng)該也是面向過程說法的來由。

相比面向機(jī)器的思想來說,面向過程是一次思想上的飛躍,將程序員從復(fù)雜的機(jī)器操作和運(yùn)行的細(xì)節(jié)中解放出來,轉(zhuǎn)而關(guān)注具體需要解決的問題;

面向過程的語言也不再需要和具體的機(jī)器綁定,從而具備了移植性和通用性;

面向過程的語言本身也更加容易編寫和維護(hù)。

這些因素疊加起來,大大減輕了程序員的負(fù)擔(dān), 提升了程序員的工作效率,從而促進(jìn)了軟件行業(yè)的快速發(fā)展。

典型的面向過程的語言有:COBOL、FORTRAN、BASIC、C 語言等。

根本原因就是一些面向過程語言中的goto語句導(dǎo)致的面條式代碼，極大的限制了程序的規(guī)模。

結(jié)構(gòu)化程序設(shè)計（英語：Structured programming），一種編程范型。它采用子程序（函數(shù)就是一種子程序）、代碼區(qū)塊、for循環(huán)以及while循環(huán)等結(jié)構(gòu)，來替換傳統(tǒng)的goto。希望借此來改善計算機(jī)程序的明晰性、質(zhì)量以及開發(fā)時間，并且避免寫出面條式代碼。

隨著計算機(jī)硬件的飛速發(fā)展,以及應(yīng)用復(fù)雜度越來越高,軟件規(guī)模越來越大,原有的程序開發(fā)方式已經(jīng)越來越不能滿足需求了。1960 年代中期開始爆發(fā)了第一次軟件危機(jī),典型表現(xiàn)有軟件質(zhì)量低下、項(xiàng)目無法如期完成、項(xiàng)目嚴(yán)重超支等,因?yàn)檐浖鴮?dǎo)致的重大事故時有發(fā)生。例如 1963 年美國 (http://en.wikipedia.org/wiki/... 的水手一號火箭發(fā)射失敗事故,就是因?yàn)橐恍?FORTRAN 代碼 錯誤導(dǎo)致的。

軟件危機(jī)最典型的例子莫過于 IBM 的 System/360 的操作系統(tǒng)開發(fā)。佛瑞德·布魯克斯(Frederick P. Brooks, Jr.)作為項(xiàng)目主管,率領(lǐng) 2000 多個程序員夜以繼日的工作,共計花費(fèi)了 5000 人一年的工作量,寫出將近 100 萬行的源碼,總共投入 5 億美元,是美國的“曼哈頓”原子彈計劃投入的 1/4。盡管投入如此巨大, 但項(xiàng)目進(jìn)度卻一再延遲,軟件質(zhì)量也得不到保障。布魯克斯后來基于這個項(xiàng)目經(jīng)驗(yàn)而總結(jié)的《人月神話》 一書,成了史上最暢銷的軟件工程書籍。

為了解決問題,在 1968、1969 年連續(xù)召開兩次著名的 NATO 會議,會議正式創(chuàng)造了“軟件危機(jī)”一詞, 并提出了針對性的解決方法“軟件工程”。雖然“軟件工程”提出之后也曾被視為軟件領(lǐng)域的銀彈,但后來事實(shí)證明,軟件工程同樣無法解決軟件危機(jī)。

差不多同一時間,“結(jié)構(gòu)化程序設(shè)計”作為另外一種解決軟件危機(jī)的方案被提出來了。 Edsger Dijkstra 于 1968 發(fā)表了著名的《GOTO 有害論》的論文,引起了長達(dá)數(shù)年的論戰(zhàn),并由此產(chǎn)生了結(jié)構(gòu)化程序設(shè)計方 法。同時,第一個結(jié)構(gòu)化的程序語言 Pascal 也在此時誕生,并迅速流行起來。

結(jié)構(gòu)化程序設(shè)計的主要特點(diǎn)是拋棄 goto 語句,采取“自頂向下、逐步細(xì)化、模塊化”的指導(dǎo)思想。

結(jié)構(gòu)化程序設(shè)計本質(zhì)上還是一種面向過程的設(shè)計思想,但通過“自頂向下、逐步細(xì)化、模塊化”的方法,將軟件的復(fù)雜度控制在一定范圍內(nèi),從而從整體上降低了軟件開發(fā)的復(fù)雜度。

結(jié)構(gòu)化程序方法成為了 1970 年 代軟件開發(fā)的潮流。

科學(xué)研究證明,人腦存在人類短期記憶一般一次只能記住 5-9 個事物,這就是著名的 7+- 2 原理。結(jié)構(gòu)化程序設(shè)計是面向過程設(shè)計思想的一個改進(jìn),使得軟件開發(fā)更加符合人類思維的 7+-2 特點(diǎn)。

結(jié)構(gòu)化編程的風(fēng)靡在一定程度上緩解了軟件危機(jī),然而好景不長,隨著硬件的快速發(fā)展,業(yè)務(wù)需求越來越復(fù)雜,以及編程應(yīng)用領(lǐng)域越來越廣泛,第二次軟件危機(jī)很快就到來了。

第二次軟件危機(jī)的根本原因還是在于軟件生產(chǎn)力遠(yuǎn)遠(yuǎn)跟不上硬件和業(yè)務(wù)的發(fā)展,相比第一次軟件危機(jī)主要體現(xiàn)在“復(fù)雜性”,第二次軟件危機(jī)主要體現(xiàn)在“可擴(kuò)展性”、“可維護(hù)性”上面。

傳統(tǒng)的面向過程(包括 結(jié)構(gòu)化程序設(shè)計)方法已經(jīng)越來越不能適應(yīng)快速多變的業(yè)務(wù)需求了,軟件領(lǐng)域迫切希望找到新的銀彈來解 決軟件危機(jī),在這種背景下,面向?qū)ο蟮乃枷腴_始流行起來。

面向?qū)ο蟮乃枷氩⒉皇窃诘诙诬浖C(jī)后才出現(xiàn)的,早在 1967 年的 Simula 語言中就開始提出來了,但第二次軟件危機(jī)促進(jìn)了面向?qū)ο蟮陌l(fā)展。

面向?qū)ο笳嬲_始流行是在 1980s 年代,主要得益于 C++的功 勞,后來的 Java、C#把面向?qū)ο笸葡蛄诵碌母叻濉５浆F(xiàn)在為止,面向?qū)ο笠呀?jīng)成為了主流的開發(fā)思想。

雖然面向?qū)ο箝_始也被當(dāng)做解決軟件危機(jī)的銀彈,但事實(shí)證明,和軟件工程一樣,面向?qū)ο笠膊皇倾y彈, 而只是一種新的軟件方法而已。

雖然面向?qū)ο蟛⒉皇墙鉀Q軟件危機(jī)的銀彈,但和面向過程相比,面向?qū)ο蟮乃枷敫淤N近人類思維的特點(diǎn), 更加脫離機(jī)器思維,是一次軟件設(shè)計思想上的飛躍。

補(bǔ)充：

編程語言發(fā)展史上的杰出人物

約翰·巴科斯，發(fā)明了Fortran。
阿蘭·庫珀，開發(fā)了Visual Basic。
艾茲格·迪杰斯特拉，開創(chuàng)了正確運(yùn)用編程語言(proper programming)的框架。
詹姆斯·高斯林，開發(fā)了Oak，該語言為Java的先驅(qū)。
安德斯·海爾斯伯格，開發(fā)了Turbo Pascal、Delphi，以及C#。
葛麗絲·霍普，開發(fā)了Flow-Matic，該語言對COBOL造成了影響。
肯尼斯·艾佛森，開發(fā)了APL，并與Roger Hui合作開發(fā)了J。
比爾·喬伊，發(fā)明了vi，BSD Unix的前期作者，以及SunOS的發(fā)起人，該操作系統(tǒng)后來改名為Solaris。
艾倫·凱，開創(chuàng)了面向?qū)ο缶幊陶Z言，以及Smalltalk的發(fā)起人。
Brian Kernighan，與丹尼斯·里奇合著第一本C程序設(shè)計語言的書籍，同時也是AWK與AMPL程序設(shè)計語言的共同作者。
約翰·麥卡錫，發(fā)明了LISP。
約翰·馮·諾伊曼，操作系統(tǒng)概念的發(fā)起者。
丹尼斯·里奇，發(fā)明了C。
比雅尼·斯特勞斯特魯普，開發(fā)了C++。
肯·湯普遜，發(fā)明了Unix。
尼克勞斯·維爾特，發(fā)明了Pascal與Modula。
拉里·沃爾，創(chuàng)造了Perl與Perl 6。
吉多·范羅蘇姆，創(chuàng)造了Python。

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

優(yōu)點(diǎn)是：極大的降低了程序的復(fù)雜度；

缺點(diǎn)是：可擴(kuò)展性差，修改代碼麻煩；

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

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

面向?qū)ο蟮某绦蛟O(shè)計

優(yōu)點(diǎn)：解決了程序的擴(kuò)展性。對某一個對象多帶帶修改，會立刻反映到整個體系中，如對游戲中一個人物參數(shù)的特征和技能修改都很容易。

缺點(diǎn)：可控性差，無法向面向過程的程序設(shè)計流水線式的可以很精準(zhǔn)的預(yù)測問題的處理流程與結(jié)果，面向?qū)ο蟮某绦蛞坏╅_始就由對象之間的交互解決問題，無法預(yù)測最終結(jié)果。于是我們經(jīng)?？吹揭粋€游戲人某一參數(shù)的修改極有可能導(dǎo)致bug的技能出現(xiàn)，一刀砍死3個人，這個游戲就失去平衡。

應(yīng)用場景：需求經(jīng)常變化的軟件，一般需求的變化都集中在用戶層，互聯(lián)網(wǎng)應(yīng)用，企業(yè)內(nèi)部軟件，游戲等都是面向?qū)ο蟮某绦蛟O(shè)計大顯身手的好地方。

面向?qū)ο蟮某绦蛟O(shè)計并不是全部。對于一個軟件質(zhì)量來說，面向?qū)ο蟮某绦蛟O(shè)計只是用來解決擴(kuò)展性。

python中一切皆為對象，且python3統(tǒng)一了類與類型的概念，類型就是類。

基于面向?qū)ο笤O(shè)計一個款游戲：英雄聯(lián)盟，每個玩家選一個英雄，每個英雄都有自己的特征和和技能，特征即數(shù)據(jù)屬性，技能即方法屬性，特征與技能的結(jié)合體就一個對象。

從一組對象中提取相似的部分就是類，類所有對象都具有的特征和技能的結(jié)合體。

在python中，用變量表示特征，用函數(shù)表示技能，因而類是變量與函數(shù)的結(jié)合體，對象是變量與方法（指向類的函數(shù)）的結(jié)合體。

在python中聲明類與聲明函數(shù)很相似

聲明類

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


# 我們創(chuàng)建一個類
class Data:
    pass

分類：新式類和經(jīng)典類

注意：

1.只有在python2中才分新式類和經(jīng)典類，python3中統(tǒng)一都是新式類
2.新式類和經(jīng)典類聲明的最大不同在于,所有新式類必須繼承至少一個父類
3.所有類甭管是否顯式聲明父類，都有一個默認(rèn)繼承object父類

# 在python2中的區(qū)分
# 經(jīng)典類：
class 類名:
　　pass

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

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

例:

class Garen:        #定義英雄蓋倫的類，不同的玩家可以用它實(shí)例出自己英雄;
    camp="Demacia"  #所有玩家的英雄(蓋倫)的陣營都是Demacia;
    def attack(self,enemy):   #普通攻擊技能，enemy是敵人;
        enemy.life_value-=self.aggressivity #根據(jù)自己的攻擊力，攻擊敵人就減掉敵人的生命值。

類的屬性引用

class Garen:        #定義英雄蓋倫的類，不同的玩家可以用它實(shí)例出自己英雄;
    camp="Demacia"  #所有玩家的英雄(蓋倫)的陣營都是Demacia;
    def attack(self,enemy):   #普通攻擊技能，enemy是敵人;
        enemy.life_value-=self.aggressivity #根據(jù)自己的攻擊力，攻擊敵人就減掉敵人的生命值。

print(Garen.camp) #引用類的數(shù)據(jù)屬性，該屬性與所有對象/實(shí)例共享

print(Garen.attack) #引用類的函數(shù)屬性，該屬性也共享

print(Garen.__dict__) #查看類的屬性字典，或者說名稱空間

# Garen.name="Garen")#增加屬性
# del Garen.name #刪除屬性

輸出

Demacia

{"__doc__": None, "attack": , "__module__": "__main__", "__weakref__": , "camp": "Demacia", "__dict__": }

類的實(shí)例化

類名加括號就是實(shí)例化，會自動觸發(fā)__init__函數(shù)的運(yùn)行，可以用它來為每個實(shí)例定制自己的特征

class Garen:        #定義英雄蓋倫的類，不同的玩家可以用它實(shí)例出自己英雄;
    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 #根據(jù)自己的攻擊力，攻擊敵人就減掉敵人的生命值。

g1=Garen("草叢倫") #就是在執(zhí)行Garen.__init__(g1,"草叢倫")，然后執(zhí)行__init__內(nèi)的代碼g1.nickname=‘草叢倫’等
print(g1)
print(g1.nickname)

輸出

<__main__.Garen object at 0x10ee26e10>
草叢倫

注：self的作用是在實(shí)例化時自動將對象/實(shí)例本身傳給__init__的第一個參數(shù)，self可以是任意名字

補(bǔ)充：

# 我們定義的類的屬性到底存到哪里了？有兩種方式查看
# dir(類名)：查出的是一個名字列表
# 類名.__dict__:查出的是一個字典，key為屬性名，value為屬性值
# 二：特殊的類屬性
類名.__name__# 類的名字(字符串)
類名.__doc__# 類的文檔字符串
類名.__base__# 類的第一個父類(在講繼承時會講)
類名.__bases__# 類所有父類構(gòu)成的元組(在講繼承時會講)
類名.__dict__# 類的字典屬性
類名.__module__# 類定義所在的模塊
類名.__class__# 實(shí)例對應(yīng)的類(僅新式類中)

對象是關(guān)于類而實(shí)際存在的一個例子，即類的實(shí)例化。

g1=Garen("草叢倫") #實(shí)例化類就是對象
print(g1)
print(g1.nickname)
print(type(g1)) #查看g1的類型就是類Garen
print(isinstance(g1,Garen)) #g1就是Garen的實(shí)例

輸出

<__main__.Garen object at 0x108d55dd8>
草叢倫

True

對象的引用只有一種：屬性引用
對象/實(shí)例本身其實(shí)只有數(shù)據(jù)屬性

class Garen:        #定義英雄蓋倫的類，不同的玩家可以用它實(shí)例出自己英雄;
    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 #根據(jù)自己的攻擊力，攻擊敵人就減掉敵人的生命值。

g1=Garen("草叢倫") #類的實(shí)例化就是對象
print(g1.nickname)　　#對象的屬性引用
print(g1.aggressivity)
print(g1.life_value)

輸出

草叢倫
58
455

補(bǔ)充：

對象/實(shí)例本身只有數(shù)據(jù)屬性，但是python的class機(jī)制會將類的函數(shù)綁定到對象上，稱為對象的方法，或者叫綁定方法，綁定方法唯一綁定一個對象，同一個類的方法綁定到不同的對象上，屬于不同的方法，內(nèi)存地址都不會一樣。

print(g1.attack)　　#對象的綁定方法
print(Garen.attack)　　#對象的綁定方法attack本質(zhì)就是調(diào)用類的函數(shù)attack的功能，二者是一種綁定關(guān)系

輸出

>

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

仿照garen類再創(chuàng)建一個Riven類，用瑞雯攻擊蓋倫，完成對象交互

class Garen:        #定義英雄蓋倫的類，不同的玩家可以用它實(shí)例出自己英雄;
    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 #根據(jù)自己的攻擊力，攻擊敵人就用敵人的生命值減攻擊力。


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 #根據(jù)自己的攻擊力，攻擊敵人就用敵人的生命值減攻擊力。


g1=Garen("蓋倫") #就是在執(zhí)行Garen.__init__(g1,"草叢倫")，然后執(zhí)行__init__內(nèi)的代碼g1.nickname=‘草叢倫’等
r1=Riven("瑞雯")

print(g1.life_value)
print(r1.attack(g1))    #對象交互,瑞雯攻擊蓋倫
print(g1.life_value)

輸出

455
None
401

創(chuàng)建一個類就會創(chuàng)建一個類的名稱空間，用來存儲類中定義的所有名字，這些名字稱為類的屬性。
類有兩種屬性：數(shù)據(jù)屬性和函數(shù)屬性

其中類的數(shù)據(jù)屬性是共享給所有對象的

定義在類內(nèi)部的變量，是所有對象共有的，id全一樣

print(id(r1.camp)) #本質(zhì)就是在引用類的camp屬性，二者id一樣
print(id(Riven.camp))

4482776512
4482776512

而類的函數(shù)屬性是綁定到所有對象的：

定義在類內(nèi)部的函數(shù)，是綁定到所有對象的，是給對象來用，obj.func() 會把obj本身當(dāng)做第一個參數(shù)出入

r1.attack就是在執(zhí)行Riven.attack的功能，python的class機(jī)制會將Riven的函數(shù)屬性attack綁定給r1，r1相當(dāng)于拿到了一個指針，指向Riven類的attack功能,r1.attack()會將r1傳給attack的第一個參數(shù)

print(id(r1.attack))
print(id(Riven.attack))

輸出

4372850184
4374779288

注：

創(chuàng)建一個對象/實(shí)例就會創(chuàng)建一個對象/實(shí)例的名稱空間，存放對象/實(shí)例的名字，稱為對象/實(shí)例的屬性

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

print(g1.x) #先從g1.__dict__,找不到再找Garen.__dict__,找不到就會報錯

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

分類：單繼承和多繼承

class ParentClass1: #定義父類
    pass

class ParentClass2: #定義父類
    pass

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

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

查看繼承

__base__只查看從左到右繼承的第一個子類，__bases__則是查看所有繼承的父類

print(SubClass2.__base__)
print(SubClass2.__bases__)

輸出

(, )

如果沒有指定基類，python的類會默認(rèn)繼承object類，object是所有python類的基類，它提供了一些常見方法（如__str__）的實(shí)現(xiàn)。

print(ParentClass1.__base__)

輸出

抽象即抽取類似或者說比較像的部分。

抽象分成兩個層次：

1.將奧巴馬和梅西這倆對象比較像的部分抽取成類； 
2.將人，豬，狗這三個類比較像的部分抽取成父類。

抽象：最主要的作用是劃分類別（可以隔離關(guān)注點(diǎn)，降低復(fù)雜度）

繼承：是基于抽象的結(jié)果，通過編程語言去實(shí)現(xiàn)它，肯定是先經(jīng)歷抽象這個過程，才能通過繼承的方式去表達(dá)出抽象的結(jié)構(gòu)。
抽象只是分析和設(shè)計的過程中，一個動作或者說一種技巧，通過抽象可以得到類。

在開發(fā)程序的過程中，如果我們定義了一個類A，然后又想新建立另外一個類B，但是類B的大部分內(nèi)容與類A的相同時

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

通過繼承的方式新建類B，讓B繼承A，B會‘遺傳’A的所有屬性(數(shù)據(jù)屬性和函數(shù)屬性)，實(shí)現(xiàn)代碼重用

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.nickname)
print(r1.nickname)
print(g1.life_value)
r1.attack(g1)
print(g1.life_value)

輸出

草叢倫
300
243

注意：

像g1.life_value之類的屬性引用，會先從實(shí)例中找life_value然后去類中找，然后再去父類中找...直到最頂級的父類。

當(dāng)然子類也可以添加自己新的屬性或者在自己這里重新定義這些屬性（不會影響到父類），需要注意的是，一旦重新定義了自己的屬性且與父類重名，那么調(diào)用新增的屬性時，就以自己為準(zhǔn)了。

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

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):
    camp="Noxus"
    def attack(self,enemy): #在自己這里定義新的attack,不再使用父類的attack,且不會影響父類
        print("from riven")
    def fly(self): #在自己這里定義新的
        print("%s is flying" %self.nickname)

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

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

輸出

草叢倫
銳雯雯
300
from riven
300

軟件重用的重要方式除了繼承之外還有另外一種方式，即：組合。組合指的是，在一個類中以另外一個類的對象作為數(shù)據(jù)屬性，稱為類的組合。

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類產(chǎn)生一個裝備,賦值給實(shí)例的equip屬性

r1=Riven("銳雯雯")
r1.equip.fire() #可以使用組合的類產(chǎn)生的對象所持有的方法

輸出

release Fire skill

對比：

組合與繼承都是有效地利用已有類的資源的重要方式。但是二者的概念和使用場景皆不同，

1.繼承的方式
通過繼承建立了派生類與基類之間的關(guān)系，它是一種"是"的關(guān)系，比如白馬是馬，人是動物。

當(dāng)類之間有很多相同的功能，提取這些共同的功能做成基類，用繼承比較好，比如教授是老師

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

class Professor(Teacher):
     pass

p1=Professor("hexin","male")
p1.teach()

輸出

teaching

2.組合的方式
用組合的方式建立了類與組合的類之間的關(guān)系，它是一種‘有’的關(guān)系,比如教授有生日，教授教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("hexin","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)

輸出

1995 1 27
python 28000 4 months

當(dāng)類之間有顯著不同，并且較小的類是較大的類所需要的組件時，用組合比較好

接口定義：接口就是一些方法特征的集合------接口是對抽象的抽象。

繼承有兩種用途：

①繼承基類的方法，并且做出自己的改變或者擴(kuò)展（代碼重用）；
②聲明某個子類兼容于某基類，定義一個接口類Interface，接口類中定義了一些接口名（就是函數(shù)名）且并未實(shí)現(xiàn)接口的功能，子類繼承接口類，并且實(shí)現(xiàn)接口中的功能；

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

    def write(self): #定義接口函數(shù)write
        pass


class Txt(Interface): #文本，具體實(shí)現(xiàn)read和write
    def read(self):
        print("文本數(shù)據(jù)的讀取方法")

    def write(self):
        print("文本數(shù)據(jù)的讀取方法")

class Sata(Interface): #磁盤，具體實(shí)現(xiàn)read和write
    def read(self):
        print("硬盤數(shù)據(jù)的讀取方法")

    def write(self):
        print("硬盤數(shù)據(jù)的讀取方法")

class Process(Interface):
    def read(self):
        print("進(jìn)程數(shù)據(jù)的讀取方法")

    def write(self):
        print("進(jìn)程數(shù)據(jù)的讀取方法")

實(shí)踐中，

繼承的第一種含義意義并不很大，甚至常常是有害的。因?yàn)樗沟米宇惻c基類出現(xiàn)強(qiáng)耦合。

繼承的第二種含義叫“接口繼承”。接口繼承實(shí)質(zhì)上是要求“做出一個良好的抽象，這個抽象規(guī)定了一個兼容接口，使得外部調(diào)用者無需關(guān)心具體細(xì)節(jié)，可一視同仁的處理實(shí)現(xiàn)了特定接口的所有對象”——這在程序設(shè)計上，叫做歸一化。

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

為什么要使用接口？
接口提取了一群類共同的函數(shù)，可以把接口當(dāng)做一個函數(shù)的集合，然后讓子類去實(shí)現(xiàn)接口中的函數(shù)。

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

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

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

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

抽象類
抽象類是一個特殊的類，它的特殊之處在于只能被繼承，不能被實(shí)例化

為什么要有抽象類
如果說類是從一堆對象中抽取相同的內(nèi)容而來的，那么抽象類就是從一堆類中抽取相同的內(nèi)容而來的，內(nèi)容包括數(shù)據(jù)屬性和函數(shù)屬性?！?/p>

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

從設(shè)計角度去看，如果類是從現(xiàn)實(shí)對象抽象而來的，那么抽象類就是基于類抽象而來的。　

從實(shí)現(xiàn)角度來看，抽象類與普通類的不同之處在于：抽象類中只能有抽象方法（沒有實(shí)現(xiàn)功能），該類不能被實(shí)例化，只能被繼承，且子類必須實(shí)現(xiàn)抽象方法。這一點(diǎn)與接口有點(diǎn)類似，但其實(shí)是不同的

在python中實(shí)現(xiàn)抽象類

import abc #利用abc模塊實(shí)現(xiàn)抽象類

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

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

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

class Txt(All_file): #子類繼承抽象類，但是必須定義read和write方法
    def read(self):
        print("文本數(shù)據(jù)的讀取方法")

    def write(self):
        print("文本數(shù)據(jù)的讀取方法")

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

    def write(self):
        print("硬盤數(shù)據(jù)的讀取方法")

class Process(All_file): #子類繼承抽象類，但是必須定義read和write方法
    def read(self):
        print("進(jìn)程數(shù)據(jù)的讀取方法")

    def write(self):
        print("進(jìn)程數(shù)據(jù)的讀取方法")

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

#這樣大家都是被歸一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

輸出

文本數(shù)據(jù)的讀取方法
硬盤數(shù)據(jù)的讀取方法
進(jìn)程數(shù)據(jù)的讀取方法
file
file
file

補(bǔ)充：Python的abc模塊

abc模塊作用：Python本身不提供抽象類和接口機(jī)制，要想實(shí)現(xiàn)抽象類，可以借助abc模塊。ABC是Abstract Base Class的縮寫。

模塊中的類和函數(shù)：

abc.ABCMeta　　這是用來生成抽象基礎(chǔ)類的元類。由它生成的類可以被直接繼承。

abc.abstractmethod(function)　　表明抽象方法的生成器

abc.abstractproperty([fget[,fset[,fdel[,doc]]]])　　表明一個抽象屬性

抽象類與接口
抽象類的本質(zhì)還是類，指的是一組類的相似性，包括數(shù)據(jù)屬性（如all_type）和函數(shù)屬性（如read、write），而接口只強(qiáng)調(diào)函數(shù)屬性的相似性。

抽象類是一個介于類和接口直接的一個概念，同時具備類和接口的部分特性，可以用來實(shí)現(xiàn)歸一化設(shè)計 。

繼承順序

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__) #只有新式才有這個屬性可以查看線性列表，經(jīng)典類沒有這個屬性

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

輸出

from D
(, , , , , , )

繼承原理

對于你定義的每一個類，python會計算出一個方法解析順序(MRO)列表，這個MRO列表就是一個簡單的所有基類的線性順序列表，例如

>>> F.mro() #等同于F.__mro__
[, , , , , , ]

為了實(shí)現(xiàn)繼承,python會在MRO列表上從左到右開始查找基類,直到找到第一個匹配這個屬性的類為止。
而這個MRO列表的構(gòu)造是通過一個C3線性化算法來實(shí)現(xiàn)的。我們不去深究這個算法的數(shù)學(xué)原理,它實(shí)際上就是合并所有父類的MRO列表并遵循如下三條準(zhǔn)則:

1.子類會先于父類被檢查
2.多個父類會根據(jù)它們在列表中的順序被檢查
3.如果對下一個類存在兩個合法的選擇,選擇第一個父類

子類繼承了父類的方法，然后想進(jìn)行修改，注意了是基于原有的基礎(chǔ)上修改，那么就需要在子類中調(diào)用父類的方法

方法一：父類名.父類方法()

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()

輸出

地鐵13號線歡迎您
開動啦...

方法二：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) 就相當(dāng)于實(shí)例本身 在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()

注意：

當(dāng)你使用super()函數(shù)時,Python會在MRO列表上繼續(xù)搜索下一個類。只要每個重定義的方法統(tǒng)一使用super()并只調(diào)用它一次,那么控制流最終會遍歷完整個MRO列表,每個方法也只會被調(diào)用一次

使用super調(diào)用的所有屬性，都是從MRO列表當(dāng)前的位置往后找，千萬不要通過看代碼去找繼承關(guān)系，一定要看MRO列表

多態(tài)指的是一類事物有多種形態(tài)，（一個抽象類有多個子類，因而多態(tài)的概念依賴于繼承）。

序列類型有多種形態(tài)：字符串，列表，元組。

動物有多種形態(tài)：人，狗，豬

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

class People(Animal): #動物的形態(tài)之一:人
    def talk(self):
        print("say hello")

class Dog(Animal): #動物的形態(tài)之二:狗
    def talk(self):
        print("say wangwang")

class Pig(Animal): #動物的形態(tài)之三:豬
    def talk(self):
        print("say aoao")

文件有多種形態(tài)：文本文件，可執(zhí)行文件

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

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

class ExeFile(File): #文件的形態(tài)之二:可執(zhí)行文件
    def click(self):
        print("execute file")

多態(tài)性是指具有不同功能的函數(shù)可以使用相同的函數(shù)名，這樣就可以用一個函數(shù)名調(diào)用不同功能的函數(shù)。

比如：老師.下課鈴響了（），學(xué)生.下課鈴響了()，老師執(zhí)行的是下班操作，學(xué)生執(zhí)行的是放學(xué)操作，雖然二者消息一樣，但是執(zhí)行的效果不同。

靜態(tài)多態(tài)性：如任何類型都可以用運(yùn)算符+進(jìn)行運(yùn)算

動態(tài)多態(tài)性：

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

class People(Animal): #動物的形態(tài)之一:人
    def talk(self):
        print("say hello")

class Dog(Animal): #動物的形態(tài)之二:狗
    def talk(self):
        print("say wangwang")

class Pig(Animal): #動物的形態(tài)之三:豬
    def talk(self):
        print("say aoao")

def func(animal):
    animal.talk()

people1=People()
pig1=Pig()
dog1=Dog()

func(people1)
func(pig1)
func(dog1)

多態(tài)性是‘一個接口（函數(shù)func），多種實(shí)現(xiàn)（如f.click()）’

增加了程序的靈活性
以不變應(yīng)萬變，不論對象千變?nèi)f化，使用者都是同一種形式去調(diào)用，如func(animal)

增加了程序可擴(kuò)展性
通過繼承animal類創(chuàng)建了一個新的類，使用者無需更改自己的代碼，還是用

func(animal)去調(diào)用 　

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

class Cat(Animal):  #屬于動物的另外一種形態(tài)：貓
    def talk(self):
        print("say miao")

def func(animal):   #對于使用者來說，自己的代碼根本無需改動
        animal.talk()

cat1=Cat()  #實(shí)例出一只貓
func(cat1)  #甚至連調(diào)用方式也無需改變，就能調(diào)用貓的talk功能

輸出

say miao

這樣我們新增了一個形態(tài)Cat，由Cat類產(chǎn)生的實(shí)例cat1，使用者可以在完全不需要修改自己代碼的情況下。使用和人、狗、豬一樣的方式調(diào)用cat1的talk方法，即func(cat1)

“封裝”就是將抽象得到的數(shù)據(jù)和行為（或功能）相結(jié)合，形成一個有機(jī)的整體（即類）。

封裝的目的是增強(qiáng)安全性和簡化編程，使用者不必了解具體的實(shí)現(xiàn)細(xì)節(jié)，而只是要通過外部接口，一特定的訪問權(quán)限來使用類的成員。

保護(hù)隱私和隔離復(fù)雜度。

第一個層面的封裝（什么都不用做）：創(chuàng)建類和對象會分別創(chuàng)建二者的名稱空間，我們只能用類名.或者obj.的方式去訪問里面的名字，這本身就是一種封裝。

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

注意： 對于這一層面的封裝（隱藏），類名.和實(shí)例名.就是訪問隱藏屬性的接口

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

在python中用雙下劃線的方式實(shí)現(xiàn)隱藏屬性（設(shè)置成私有的），類中所有雙下劃線開頭的名稱如__x都會自動變形成：_類名__x的形式：

class Foo:
    __x=1 #_Foo__x
    def __test(self): #_Foo__test
        print("from test")

print(Foo.__dict__)

print(Foo._Foo__x)

輸出

{"_Foo__test": , "__module__": "__main__", "__dict__": , "__weakref__": , "__doc__": None, "_Foo__x": 1}


1

class Teacher:
    def __init__(self,name,age):
        self.__name=name
        self.__age=age

    def tell_info(self):
        print("姓名:%s,年齡:%s" %(self.__name,self.__age))
    def set_info(self,name,age):
        if not isinstance(name,str):
            raise TypeError("姓名必須是字符串類型")
        if not isinstance(age,int):
            raise TypeError("年齡必須是整型")
        self.__name=name
        self.__age=age

t=Teacher("hexin",18)
t.tell_info()

輸出

姓名:hexin,年齡:18

這種自動變形的特點(diǎn)：

1.類中定義的__x只能在內(nèi)部使用，如self.__x，引用的就是變形的結(jié)果。
2.這種變形其實(shí)正是針對外部的變形，在外部是無法通過__x這個名字訪問到的。
3.在子類定義的__x不會覆蓋在父類定義的__x，因?yàn)樽宇愔凶冃纬闪耍篲子類名__x,而父類中變形成了：_父類名__x，即雙下滑線開頭的屬性在繼承給子類時，子類是無法覆蓋的。

注意：對于這一層面的封裝（隱藏），我們需要在類中定義一個函數(shù)（接口函數(shù)）在它內(nèi)部訪問被隱藏的屬性，然后外部就可以使用了.

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

1.這種機(jī)制也并沒有真正意義上限制我們從外部直接訪問屬性，知道了類名和屬性名就可以拼出名字：_類名__屬性，然后就可以訪問了，如a._A__N
2.變形的過程只在類的定義是發(fā)生一次,在定義后的賦值操作，不會變形
3.在繼承中，父類如果不想讓子類覆蓋自己的方法，可以將方法定義為私有的

property是一種特殊的屬性，訪問它時會執(zhí)行一段功能（函數(shù)）然后返回值

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) #可以向訪問數(shù)據(jù)屬性一樣去訪問area,會觸發(fā)一個函數(shù)的執(zhí)行,動態(tài)計算出一個值
print(c.perimeter) 

輸出

10
314.1592653589793
62.83185307179586

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

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

為什么要使用特性？

將一個類的函數(shù)定義成特性以后，對象再去使用的時候obj.name,根本無法察覺自己的name是執(zhí)行了一個函數(shù)然后計算出來的，這種特性的使用方式遵循了統(tǒng)一訪問的原則

補(bǔ)充：面向?qū)ο蟮姆庋b有三種方式:

【public】
這種其實(shí)就是不封裝,是對外公開的

【protected】
這種封裝方式對外不公開,但對朋友(friend)或者子類公開

【private】
這種封裝對誰都不公開

python并沒有在語法上把它們?nèi)齻€內(nèi)建到自己的class機(jī)制中，在C++里一般會將所有的所有的數(shù)據(jù)都設(shè)置為私有的，然后提供set和get方法（接口）去設(shè)置和獲取，在python中通過property方法可以實(shí)現(xiàn)

class Foo:
    def __init__(self,val):
        self.__NAME=val #將所有的數(shù)據(jù)屬性都隱藏起來

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

    @name.setter
    def name(self,value):
        if not isinstance(value,str):  #在設(shè)定值之前進(jìn)行類型檢查
            raise TypeError("%s must be str" %value)
        self.__NAME=value #通過類型檢查后,將值value存放到真實(shí)的位置self.__NAME

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

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

一種property的古老用法

class Foo:
    def __init__(self,val):
        self.__NAME=val #將所有的數(shù)據(jù)屬性都隱藏起來

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

    def setname(self,value):
        if not isinstance(value,str):  #在設(shè)定值之前進(jìn)行類型檢查
            raise TypeError("%s must be str" %value)
        self.__NAME=value #通過類型檢查后,將值value存放到真實(shí)的位置self.__NAME

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

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

封裝在于明確區(qū)分內(nèi)外，使得類實(shí)現(xiàn)者可以修改封裝內(nèi)的東西而不影響外部調(diào)用者的代碼；而外部使用用者只知道一個接口(函數(shù))，只要接口（函數(shù)）名、參數(shù)不變，使用者的代碼永遠(yuǎn)無需改變。

#類的設(shè)計者
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): #對外提供的接口，隱藏了內(nèi)部的實(shí)現(xiàn)細(xì)節(jié)，此時我們想求的是面積
        return self.__width * self.__length

#使用者
>>> r1=Room("臥室","hexin",20,20,20)
>>> r1.tell_area() #使用者調(diào)用接口tell_area
400

要計算體積

#類的設(shè)計者，輕松的擴(kuò)展了功能，而類的使用者完全不需要改變自己的代碼
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): #對外提供的接口，隱藏內(nèi)部實(shí)現(xiàn)，此時我們想求的是體積,內(nèi)部邏輯變了,只需求修該下列一行就可以很簡答的實(shí)現(xiàn),而且外部調(diào)用感知不到,仍然使用該方法，但是功能已經(jīng)變了
        return self.__width * self.__length * self.__high

對于仍然在使用tell_area接口的人來說，根本無需改動自己的代碼，就可以用上新功能

>>> r1.tell_area()
8000

類中定義的函數(shù)分成兩大類：

綁定方法（綁定給誰，誰來調(diào)用就自動將它本身當(dāng)作第一個參數(shù)傳入）：
　

1.綁定到類的方法：用classmethod裝飾器裝飾的方法。為類量身定制
類.boud_method(),自動將類當(dāng)作第一個參數(shù)傳入 （其實(shí)對象也可調(diào)用，但仍將類當(dāng)作第一個參數(shù)傳入）
　　
2.綁定到對象的方法：沒有被任何裝飾器裝飾的方法。 為對象量身定制
對象.boud_method(),自動將對象當(dāng)作第一個參數(shù)傳入 （屬于類的函數(shù)，類可以調(diào)用，但是必須按照函數(shù)的規(guī)則來，沒有自動傳值那么一說）　　

非綁定方法：用staticmethod裝飾器裝飾的方法　
　

1.與類或?qū)ο蠼壎?，類和對象都可以調(diào)用，但是沒有自動傳值那么一說。就是一個普通工具而已　　　　

注意：與綁定到對象方法區(qū)分開，在類中直接定義的函數(shù)，沒有被任何裝飾器裝飾的，都是綁定到對象的方法，可不是普通函數(shù)，對象調(diào)用該方法會自動傳值，而staticmethod裝飾的方法，不管誰來調(diào)用，都沒有自動傳值一說

statimethod不與類或?qū)ο蠼壎?，誰都可以調(diào)用，沒有自動傳值效果，python為我們內(nèi)置了函數(shù)staticmethod來把類中的函數(shù)定義成靜態(tài)方法。

import hashlib
import time
class MySQL:
    def __init__(self,host,port):
        self.id=self.create_id()
        self.host=host
        self.port=port
    @staticmethod
    def create_id(): #就是一個普通工具
        m=hashlib.md5(str(time.clock()).encode("utf-8"))
        return m.hexdigest()


print(MySQL.create_id) # #查看結(jié)果為普通函數(shù)
conn=MySQL("127.0.0.1",3306)
print(conn.create_id) # #查看結(jié)果為普通函數(shù)

classmehtod是給類用的，即綁定到類，類在使用時會將類本身當(dāng)做參數(shù)傳給類方法的第一個參數(shù)（即便是對象來調(diào)用也會將類當(dāng)作第一個參數(shù)傳入），python為我們內(nèi)置了函數(shù)classmethod來把類中的函數(shù)定義成類方法

settings.py
HOST="127.0.0.1"
PORT=3306
DB_PATH=r"C:UsersAdministratorPycharmProjects	est面向?qū)ο缶幊?est1db"

import settings
import hashlib
import time
class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port

    @classmethod
    def from_conf(cls):
        print(cls)
        return cls(settings.HOST,settings.PORT)

print(MySQL.from_conf) #>
conn=MySQL.from_conf()

print(conn.host,conn.port)
conn.from_conf() #對象也可以調(diào)用，但是默認(rèn)傳的第一個參數(shù)仍然是類

比較staticmethod和classmethod的區(qū)別

import settings
class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port
    @staticmethod
    def from_conf():
        return MySQL(settings.HOST,settings.PORT)

    # @classmethod
    # def from_conf(cls):
    #     return cls(settings.HOST,settings.PORT)

    def __str__(self):
        return "就不告訴你"



class Mariadb(MySQL):
    def __str__(self):
        return "主機(jī):%s 端口:%s" %(self.host,self.port)


m=Mariadb.from_conf()
print(m) #我們的意圖是想觸發(fā)Mariadb.__str__,但是結(jié)果觸發(fā)了MySQL.__str__的執(zhí)行，打印就不告訴你

定義MySQL類

1.對象有id、host、port三個屬性

2.定義工具create_id，在實(shí)例化時為每個對象隨機(jī)生成id，保證id唯一

3.提供兩種實(shí)例化方式，方式一：用戶傳入host和port 方式二：從配置文件中讀取host和port進(jìn)行實(shí)例化

4.為對象定制方法，save和get，save能自動將對象序列化到文件中，文件名為id號，文件路徑為配置文件中DB_PATH;get方法用來從文件中反序列化出對象

#settings.py內(nèi)容
"""
HOST="127.0.0.1"
PORT=3306
DB_PATH=r"C:UsersAdministratorPycharmProjects	est面向?qū)ο缶幊?est1db"
"""
import settings
import hashlib
import time
import random
import pickle
import os
class MySQL:
    def __init__(self,host,port):
        self.id=self.create_id()
        self.host=host
        self.port=port
    def save(self):
        file_path=r"%s%s%s" %(settings.DB_PATH,os.sep,self.id)
        pickle.dump(self,open(file_path,"wb"))

    def get(self):
        file_path = r"%s%s%s" % (settings.DB_PATH, os.sep, self.id)
        return pickle.load(open(file_path,"rb"))

    @staticmethod
    def create_id():
        m=hashlib.md5(str(time.clock()).encode("utf-8")) #查看clock源碼注釋，指的是cpu真實(shí)時間，不要用time.time()，否則會出現(xiàn)id重復(fù)
        return m.hexdigest()
    @classmethod
    def from_conf(cls):
        print(cls)
        return cls(settings.HOST,settings.PORT)

# print(MySQL.from_conf) #>
conn=MySQL.from_conf()
# print(conn.id)

print(conn.create_id())
print(MySQL.create_id())

# print(conn.id)
# conn.save()
# obj=conn.get()
# print(obj.id)

小練習(xí)

import time
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    @staticmethod
    def now(): #用Date.now()的形式去產(chǎn)生實(shí)例,該實(shí)例用的是當(dāng)前時間
        t=time.localtime() #獲取結(jié)構(gòu)化的時間格式
        return Date(t.tm_year,t.tm_mon,t.tm_mday) #新建實(shí)例并且返回
    @staticmethod
    def tomorrow():#用Date.tomorrow()的形式去產(chǎn)生實(shí)例,該實(shí)例用的是明天的時間
        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() #采用當(dāng)前時間
c=Date.tomorrow() #采用明天的時間

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

輸出

1987 11 27
2017 6 15
2017 6 16

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) #我們的意圖是想觸發(fā)EuroDate.__str__,但是結(jié)果為
"""
輸出結(jié)果:
<__main__.Date object at 0x1013f9d68>
"""
因?yàn)閑就是用Date類產(chǎn)生的,所以根本不會觸發(fā)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) #哪個類來調(diào)用,即用哪個類cls來實(shí)例化

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

e=EuroDate.now()
print(e) #我們的意圖是想觸發(fā)EuroDate.__str__,此時e就是由EuroDate產(chǎn)生的,所以會如我們所愿
"""
輸出結(jié)果:
year:2017 month:3 day:3
"""