[Python3]Python面向對象的程序設計

[Python3]Python面向對象的程序設計

1、面向對象的程序設計的由來

1.第一階段：面向機器，1940年之前

最先的程序設計都是採用機器語言來編寫的,直接使用二進制碼來表示機器可以識別和執行的指令和數據。

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

優勢：機器語言由機器直接執行,速度快；

缺點：寫比較困難，修改也麻煩，這樣直接致使程序編寫效率十分低下,編寫程序花費的時間每每是實際運行時間的幾十倍或幾百倍。

因爲機器語言實在是太難編寫了,因而就發展出了彙編語言。

彙編語言亦稱符號語言,用助記符代替機器 指令的操做碼,用地址符號(Symbol)或標號(Label)代替指令或操做數的地址。

彙編語言因爲是採用了助記符號來編寫程序,比用機器語言的二進制代碼編程要方便些,在必定程度上簡化了編程過程。例如 使用 LOAD 來代替 0000,使用 STORE 來代替 0001。

即便彙編語言相比機器語言提高了可讀性,但其本質上仍是一種面向機器的語言,編寫一樣困難,也很容易出錯。

2.第二階段：面向過程

面向機器的語言一般狀況下被認爲是一種「低級語言」,爲了解決面向機器的語言存在的問題,計算機科學的前輩們又建立了面向過程的語言。

面向過程的語言被認爲是一種「高級語言」,相比面向機器的語言來講,面向過程的語言已經再也不關注機器自己的操做指令、存儲等方面,而是關注如何一步一步的解決具體的問題,即:解決問題的過程,這應該也是面向過程說法的來由。

相比面向機器的思想來講,面向過程是一次思想上的飛躍,將程序員從複雜的機器操做和運行的細節中解放出來,轉而關注具體須要解決的問題;

面向過程的語言也再也不須要和具體的機器綁定,從而具有了移植性和通用性;

面向過程的語言自己也更加容易編寫和維護。

這些因素疊加起來,大大減輕了程序員的負擔, 提高了程序員的工做效率,從而促進了軟件行業的快速發展。

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

3.第三階段：結構化程序設計

根本緣由就是一些面向過程語言中的goto語句致使的麪條式代碼，極大的限制了程序的規模。

結構化程序設計（英語：Structured programming），一種編程範型。它採用子程序（函數就是一種子程序）、代碼區塊、for循環以及while循環等結構，來替換傳統的goto。但願藉此來改善計算機程序的明晰性、質量以及開發時間，而且避免寫出麪條式代碼。

隨着計算機硬件的飛速發展,以及應用複雜度愈來愈高,軟件規模愈來愈大,原有的程序開發方式已經愈來愈不能知足需求了。1960 年代中期開始爆發了第一次軟件危機,典型表現有軟件質量低下、項目沒法如期完成、項目嚴重超支等,由於軟件而致使的重大事故時有發生。例如 1963 年美國 (http://en.wikipedia.org/wiki/... 的水手一號火箭發射失敗事故,就是由於一行 FORTRAN 代碼 錯誤致使的。

軟件危機最典型的例子莫過於 IBM 的 System/360 的操做系統開發。佛瑞德·布魯克斯(Frederick P. Brooks, Jr.)做爲項目主管,率領 2000 多個程序員夜以繼日的工做,共計花費了 5000 人一年的工做量,寫出將近 100 萬行的源碼,總共投入 5 億美圓,是美國的「曼哈頓」原子彈計劃投入的 1/4。儘管投入如此巨大, 但項目進度卻一再延遲,軟件質量也得不到保障。布魯克斯後來基於這個項目經驗而總結的《人月神話》 一書,成了史上最暢銷的軟件工程書籍。

爲了解決問題,在 196八、1969 年連續召開兩次著名的 NATO 會議,會議正式創造了「軟件危機」一詞, 並提出了針對性的解決方法「軟件工程」。雖然「軟件工程」提出以後也曾被視爲軟件領域的銀彈,但後來事實證實,軟件工程一樣沒法解決軟件危機。

差很少同一時間,「結構化程序設計」做爲另一種解決軟件危機的方案被提出來了。 Edsger Dijkstra 於 1968 發表了著名的《GOTO 有害論》的論文,引發了長達數年的論戰,並由此產生告終構化程序設計方 法。同時,第一個結構化的程序語言 Pascal 也在此時誕生,並迅速流行起來。

結構化程序設計的主要特色是拋棄 goto 語句,採起「自頂向下、逐步細化、模塊化」的指導思想。

結構化程序設計本質上仍是一種面向過程的設計思想,但經過「自頂向下、逐步細化、模塊化」的方法,將軟件的複雜度控制在必定範圍內,從而從總體上下降了軟件開發的複雜度。

結構化程序方法成爲了 1970 年 代軟件開發的潮流。

科學研究證實,人腦存在人類短時間記憶通常一次只能記住 5-9 個事物,這就是著名的 7+- 2 原理。結構化程序設計是面向過程設計思想的一個改進,使得軟件開發更加符合人類思惟的 7+-2 特色。

4.第四階段：面向對象程序設計

結構化編程的風靡在必定程度上緩解了軟件危機,然而好景不長,隨着硬件的快速發展,業務需求愈來愈複雜,以及編程應用領域愈來愈普遍,第二次軟件危機很快就到來了。

第二次軟件危機的根本緣由仍是在於軟件生產力遠遠跟不上硬件和業務的發展,相比第一次軟件危機主要體如今「複雜性」,第二次軟件危機主要體如今「可擴展性」、「可維護性」上面。

傳統的面向過程(包括 結構化程序設計)方法已經愈來愈不能適應快速多變的業務需求了,軟件領域迫切但願找到新的銀彈來解 決軟件危機,在這種背景下,面向對象的思想開始流行起來。

面向對象的思想並非在第二次軟件危機後纔出現的,早在 1967 年的 Simula 語言中就開始提出來了,但第二次軟件危機促進了面向對象的發展。

面向對象真正開始流行是在 1980s 年代,主要得益於 C++的功 勞,後來的 Java、C#把面向對象推向了新的高峯。到如今爲止,面向對象已經成爲了主流的開發思想。

雖然面向對象開始也被當作解決軟件危機的銀彈,但事實證實,和軟件工程同樣,面向對象也不是銀彈, 而只是一種新的軟件方法而已。

雖然面向對象並非解決軟件危機的銀彈,但和麪向過程相比,面向對象的思想更加貼近人類思惟的特色, 更加脫離機器思惟,是一次軟件設計思想上的飛躍。

補充：

編程語言發展史上的傑出人物

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

2、面向對象程序設計的意義

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

• 優勢是：極大的下降了程序的複雜度；
• 缺點是：可擴展性差，修改代碼麻煩；
• 應用場景：一旦完成基本不多改變的場景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

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

面向對象的程序設計

• 優勢：解決了程序的擴展性。對某一個對象單獨修改，會馬上反映到整個體系中，如對遊戲中一我的物參數的特徵和技能修改都很容易。
• 缺點：可控性差，沒法向面向過程的程序設計流水線式的能夠很精準的預測問題的處理流程與結果，面向對象的程序一旦開始就由對象之間的交互解決問題，沒法預測最終結果。因而咱們常常看到一個遊戲人某一參數的修改極有可能致使bug的技能出現，一刀砍死3我的，這個遊戲就失去平衡。
• 應用場景：需求常常變化的軟件，通常需求的變化都集中在用戶層，互聯網應用，企業內部軟件，遊戲等都是面向對象的程序設計大顯身手的好地方。

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

3、類和對象

1.定義

python中一切皆爲對象，且python3統一了類與類型的概念，類型就是類。

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

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

在python中，用變量表示特徵，用函數表示技能，於是類是變量與函數的結合體，對象是變量與方法（指向類的函數）的結合體。

2.類的聲明

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

• 聲明類

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


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

• 分類：新式類和經典類

注意：

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

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

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

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

例:

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

3.類的兩種用法

• 類的屬性引用

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

print(Garen.camp) #引用類的數據屬性，該屬性與全部對象/實例共享

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

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

# Garen.name='Garen')#增長屬性
# del Garen.name #刪除屬性

輸出

Demacia
<function Garen.attack at 0x106acd400>
{'__doc__': None, 'attack': <function Garen.attack at 0x106acd400>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Garen' objects>, 'camp': 'Demacia', '__dict__': <attribute '__dict__' of 'Garen' objects>}

• 類的實例化

類名加括號就是實例化，會自動觸發__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=‘草叢倫’等
print(g1)
print(g1.nickname)

輸出

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

注：self的做用是在實例化時自動將對象/實例自己傳給__init__的第一個參數，self能夠是任意名字

補充：

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

4.對象的產生和引用

• 對象是關於類而實際存在的一個例子，即類的實例化。

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

輸出

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

• 對象的引用只有一種：屬性引用
  對象/實例自己其實只有數據屬性

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('草叢倫') #類的實例化就是對象
print(g1.nickname)　　#對象的屬性引用
print(g1.aggressivity)
print(g1.life_value)

輸出

草叢倫
58
455

補充：

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

print(g1.attack)　　#對象的綁定方法
print(Garen.attack)　　#對象的綁定方法attack本質就是調用類的函數attack的功能，兩者是一種綁定關係

輸出

<bound method Garen.attack of <__main__.Garen object at 0x10809ee10>>
<function Garen.attack at 0x1081e3488>

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

5.對象之間的交互

仿照garen類再建立一個Riven類，用瑞雯攻擊蓋倫，完成對象交互

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 #根據本身的攻擊力，攻擊敵人就用敵人的生命值減攻擊力。


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 #根據本身的攻擊力，攻擊敵人就用敵人的生命值減攻擊力。


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

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

輸出

455
None
401

6.類名稱空間與對象/實例名稱空間

建立一個類就會建立一個類的名稱空間，用來存儲類中定義的全部名字，這些名字稱爲類的屬性。
類有兩種屬性：數據屬性和函數屬性

其中類的數據屬性是共享給全部對象的

定義在類內部的變量，是全部對象共有的，id全同樣

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

4482776512
4482776512

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

定義在類內部的函數，是綁定到全部對象的，是給對象來用，obj.func() 會把obj自己當作第一個參數出入

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

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

輸出

4372850184
4374779288

注：

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

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

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

四.繼承和派生

1.繼承的定義

繼承是一種建立新類的方式，在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__)

輸出

<class '__main__.ParentClass1'>
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

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

print(ParentClass1.__base__)

輸出

<class 'object'>

2. 繼承與抽象

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

抽象分紅兩個層次：

1.將奧巴馬和梅西這倆對象比較像的部分抽取成類；

2.將人，豬，狗這三個類比較像的部分抽取成父類。

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

• 繼承：是基於抽象的結果，經過編程語言去實現它，確定是先經歷抽象這個過程，才能經過繼承的方式去表達出抽象的結構。
  抽象只是分析和設計的過程當中，一個動做或者說一種技巧，經過抽象能夠獲得類。

3.繼承與重用性

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

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

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

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之類的屬性引用，會先從實例中找life_value而後去類中找，而後再去父類中找...直到最頂級的父類。

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

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

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

4.組合與重用性

軟件重用的重要方式除了繼承以外還有另一種方式，即：組合。組合指的是，在一個類中以另一個類的對象做爲數據屬性，稱爲類的組合。

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

對比：

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

• 1.繼承的方式
  經過繼承創建了派生類與基類之間的關係，它是一種'是'的關係，好比白馬是馬，人是動物。

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

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.組合的方式
  用組合的方式創建了類與組合的類之間的關係，它是一種‘有’的關係,好比教授有生日，教授教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

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

5.接口與歸一化設計

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

繼承有兩種用途：

①繼承基類的方法，而且作出本身的改變或者擴展（代碼重用）；

②聲明某個子類兼容於某基類，定義一個接口類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('進程數據的讀取方法')

實踐中，

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

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

歸一化使得高層的外部使用者能夠不加區分的處理全部接口兼容的對象集合——就好象linux的泛文件概念同樣，全部東西均可以當文件處理，沒必要關心它是內存、磁盤、網絡仍是屏幕（固然，對底層設計者，固然也能夠區分出「字符設備」和「塊設備」，而後作出針對性的設計：細緻到什麼程度，視需求而定）。

• 爲何要使用接口？
  接口提取了一羣類共同的函數，能夠把接口當作一個函數的集合，而後讓子類去實現接口中的函數。

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

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

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

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

6.抽象類

• 抽象類
  抽象類是一個特殊的類，它的特殊之處在於只能被繼承，不能被實例化

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

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

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

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

• 在python中實現抽象類

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

• 補充：Python的abc模塊

abc模塊做用：Python自己不提供抽象類和接口機制，要想實現抽象類，能夠藉助abc模塊。ABC是Abstract Base Class的縮寫。

模塊中的類和函數：

abc.ABCMeta　　這是用來生成抽象基礎類的元類。由它生成的類能夠被直接繼承。

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

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

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

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

7.繼承的順序

• 繼承順序

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中才分新式類與經典類

輸出

from D
(<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

• 繼承原理
• 對於你定義的每個類，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會在MRO列表上從左到右開始查找基類,直到找到第一個匹配這個屬性的類爲止。
而這個MRO列表的構造是經過一個C3線性化算法來實現的。咱們不去深究這個算法的數學原理,它實際上就是合併全部父類的MRO列表並遵循以下三條準則:

1.子類會先於父類被檢查
2.多個父類會根據它們在列表中的順序被檢查
3.若是對下一個類存在兩個合法的選擇,選擇第一個父類

8.子類中調用父類的方法

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

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

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) 就至關於實例自己 在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()

注意：

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

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

5、多態與多態性

1.多態

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

• 序列類型有多種形態：字符串，列表，元組。
• 動物有多種形態：人，狗，豬

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 aoao')

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

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

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 aoao')

def func(animal):
    animal.talk()

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

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

多態性是‘一個接口（函數func），多種實現（如f.click()）’

3.爲何要使用多態性？

• 增長了程序的靈活性
  以不變應萬變，不論對象變幻無窮，使用者都是同一種形式去調用，如func(animal)
• 增長了程序可擴展性
  經過繼承animal類建立了一個新的類，使用者無需更改本身的代碼，仍是用

func(animal)去調用 　

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

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.封裝的定義

「封裝」就是將抽象獲得的數據和行爲（或功能）相結合，造成一個有機的總體（即類）。

封裝的目的是加強安全性和簡化編程，使用者沒必要了解具體的實現細節，而只是要經過外部接口，一特定的訪問權限來使用類的成員。

保護隱私和隔離複雜度。

2.封裝的層面

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

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

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

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

在python中用雙下劃線的方式實現隱藏屬性（設置成私有的），類中全部雙下劃線開頭的名稱如__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': <function Foo.__test at 0x10e842400>, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__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

這種自動變形的特色：

1.類中定義的__x只能在內部使用，如self.__x，引用的就是變形的結果。
2.這種變形其實正是針對外部的變形，在外部是沒法經過__x這個名字訪問到的。
3.在子類定義的__x不會覆蓋在父類定義的__x，由於子類中變造成了：_子類名__x,而父類中變造成了：_父類名__x，即雙下滑線開頭的屬性在繼承給子類時，子類是沒法覆蓋的。

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

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

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

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

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

3. 特性（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)

輸出

10
314.1592653589793
62.83185307179586

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

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

爲何要使用特性？

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

補充：面向對象的封裝有三種方式:

• 【public】
  這種其實就是不封裝,是對外公開的
• 【protected】
  這種封裝方式對外不公開,但對朋友(friend)或者子類公開
• 【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('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 #將全部的數據屬性都隱藏起來

    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) #不如裝飾器的方式清晰

4.封裝與擴展性

封裝在於明確區份內外，使得類實現者能夠修改封裝內的東西而不影響外部調用者的代碼；而外部使用用者只知道一個接口(函數)，只要接口（函數）名、參數不變，使用者的代碼永遠無需改變。

#類的設計者
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('臥室','hexin',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

7、綁定方法與非綁定方法

1.定義

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

• 綁定方法（綁定給誰，誰來調用就自動將它自己看成第一個參數傳入）：
  　

1.綁定到類的方法：用classmethod裝飾器裝飾的方法。爲類量身定製
類.boud_method(),自動將類看成第一個參數傳入 （其實對象也可調用，但仍將類看成第一個參數傳入）
　　
2.綁定到對象的方法：沒有被任何裝飾器裝飾的方法。 爲對象量身定製
對象.boud_method(),自動將對象看成第一個參數傳入 （屬於類的函數，類能夠調用，可是必須按照函數的規則來，沒有自動傳值那麼一說）　　

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

1.與類或對象綁定，類和對象均可以調用，可是沒有自動傳值那麼一說。就是一個普通工具而已　　　　

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

2.staticmethod

statimethod不與類或對象綁定，誰均可以調用，沒有自動傳值效果，python爲咱們內置了函數staticmethod來把類中的函數定義成靜態方法。

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) #<function MySQL.create_id at 0x0000000001E6B9D8> #查看結果爲普通函數
conn=MySQL('127.0.0.1',3306)
print(conn.create_id) #<function MySQL.create_id at 0x00000000026FB9D8> #查看結果爲普通函數

3.classmethod

classmehtod是給類用的，即綁定到類，類在使用時會將類自己當作參數傳給類方法的第一個參數（即使是對象來調用也會將類看成第一個參數傳入），python爲咱們內置了函數classmethod來把類中的函數定義成類方法

settings.py
HOST='127.0.0.1'
PORT=3306
DB_PATH=r'C:\Users\Administrator\PycharmProjects\test\面向對象編程\test1\db'

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) #<bound method MySQL.from_conf of <class '__main__.MySQL'>>
conn=MySQL.from_conf()

print(conn.host,conn.port)
conn.from_conf() #對象也能夠調用，可是默認傳的第一個參數仍然是類

比較staticmethod和classmethod的區別

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 '主機:%s 端口:%s' %(self.host,self.port)


m=Mariadb.from_conf()
print(m) #咱們的意圖是想觸發Mariadb.__str__,可是結果觸發了MySQL.__str__的執行，打印就不告訴你

定義MySQL類

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

2.定義工具create_id，在實例化時爲每一個對象隨機生成id，保證id惟一

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

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

#settings.py內容
'''
HOST='127.0.0.1'
PORT=3306
DB_PATH=r'C:\Users\Administrator\PycharmProjects\test\面向對象編程\test1\db'
'''
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真實時間，不要用time.time()，不然會出現id重複
        return m.hexdigest()
    @classmethod
    def from_conf(cls):
        print(cls)
        return cls(settings.HOST,settings.PORT)

# print(MySQL.from_conf) #<bound method MySQL.from_conf of <class '__main__.MySQL'>>
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)

小練習

import time
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)

輸出

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) #咱們的意圖是想觸發EuroDate.__str__,可是結果爲
'''
輸出結果:
<__main__.Date object at 0x1013f9d68>
'''
由於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
'''