摘要：于發表了著名的有害論的論文引起了長達數年的論戰并由此產生了結構化程序設計方法。到現在為止面向對象已經成為了主流的開發思想。面向對象的程序設計優點解決了程序的擴展性。

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

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

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

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

由于機器語言實在是太難編寫了,于是就發展出了匯編語言。

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

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

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

面向機器的語言通常情況下被認為是一種“低級語言”,為了解決面向機器的語言存在的問題,計算機科學的前輩們又創建了面向過程的語言。

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

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

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

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

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

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

根本原因就是一些面向過程語言中的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。盡管投入如此巨大, 但項目進度卻一再延遲,軟件質量也得不到保障。布魯克斯后來基于這個項目經驗而總結的《人月神話》 一書,成了史上最暢銷的軟件工程書籍。

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

差不多同一時間,“結構化程序設計”作為另外一種解決軟件危機的方案被提出來了。 Edsger Dijkstra 于 1968 發表了著名的《GOTO 有害論》的論文,引起了長達數年的論戰,并由此產生了結構化程序設計方 法。同時,第一個結構化的程序語言 Pascal 也在此時誕生,并迅速流行起來。

結構化程序設計的主要特點是拋棄 goto 語句,采取“自頂向下、逐步細化、模塊化”的指導思想。

結構化程序設計本質上還是一種面向過程的設計思想,但通過“自頂向下、逐步細化、模塊化”的方法,將軟件的復雜度控制在一定范圍內,從而從整體上降低了軟件開發的復雜度。

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

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

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

第二次軟件危機的根本原因還是在于軟件生產力遠遠跟不上硬件和業務的發展,相比第一次軟件危機主要體現在“復雜性”,第二次軟件危機主要體現在“可擴展性”、“可維護性”上面。

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

面向對象的思想并不是在第二次軟件危機后才出現的,早在 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。

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

優點是：極大的降低了程序的復雜度；

缺點是：可擴展性差，修改代碼麻煩；

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

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

面向對象的程序設計

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

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

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

面向對象的程序設計并不是全部。對于一個軟件質量來說，面向對象的程序設計只是用來解決擴展性。

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

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

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

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

在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 #根據自己的攻擊力，攻擊敵人就減掉敵人的生命值。

類的屬性引用

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

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

類的實例化

類名加括號就是實例化，會自動觸發__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__# 實例對應的類(僅新式類中)

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

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

輸出

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

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的功能，二者是一種綁定關系

輸出

>

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

仿照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

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

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

定義在類內部的變量，是所有對象共有的，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__,找不到就會報錯

繼承是一種創建新類的方式，在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的類會默認繼承object類，object是所有python類的基類，它提供了一些常見方法（如__str__）的實現。

print(ParentClass1.__base__)

輸出

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

抽象分成兩個層次：

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

抽象：最主要的作用是劃分類別（可以隔離關注點，降低復雜度）

繼承：是基于抽象的結果，通過編程語言去實現它，肯定是先經歷抽象這個過程，才能通過繼承的方式去表達出抽象的結構。
抽象只是分析和設計的過程中，一個動作或者說一種技巧，通過抽象可以得到類。

在開發程序的過程中，如果我們定義了一個類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

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

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

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

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

繼承有兩種用途：

①繼承基類的方法，并且做出自己的改變或者擴展（代碼重用）；
②聲明某個子類兼容于某基類，定義一個接口類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的泛文件概念一樣，所有東西都可以當文件處理，不必關心它是內存、磁盤、網絡還是屏幕（當然，對底層設計者，當然也可以區分出“字符設備”和“塊設備”，然后做出針對性的設計：細致到什么程度，視需求而定）。

為什么要使用接口？
接口提取了一群類共同的函數，可以把接口當做一個函數的集合，然后讓子類去實現接口中的函數。

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

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

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

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

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

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

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

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

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

在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），而接口只強調函數屬性的相似性。

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

繼承順序

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

繼承原理

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

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

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

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

子類繼承了父類的方法，然后想進行修改，注意了是基于原有的基礎上修改，那么就需要在子類中調用父類的方法

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

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列表

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

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

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

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

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

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

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

動態多態性：

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

增加了程序的靈活性
以不變應萬變，不論對象千變萬化，使用者都是同一種形式去調用，如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)

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

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

保護隱私和隔離復雜度。

第一個層面的封裝（什么都不用做）：創建類和對象會分別創建二者的名稱空間，我們只能用類名.或者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": , "__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

這種自動變形的特點：

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

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

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

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

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

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

#類的設計者
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

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

綁定方法（綁定給誰，誰來調用就自動將它本身當作第一個參數傳入）：
　

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

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

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

注意：與綁定到對象方法區分開，在類中直接定義的函數，沒有被任何裝飾器裝飾的，都是綁定到對象的方法，可不是普通函數，對象調用該方法會自動傳值，而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) # #查看結果為普通函數
conn=MySQL("127.0.0.1",3306)
print(conn.create_id) # #查看結果為普通函數

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

settings.py
HOST="127.0.0.1"
PORT=3306
DB_PATH=r"C:UsersAdministratorPycharmProjects	est面向對象編程	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() #對象也可以調用，但是默認傳的第一個參數仍然是類

比較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:UsersAdministratorPycharmProjects	est面向對象編程	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真實時間，不要用time.time()，否則會出現id重復
        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)

小練習

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
"""