python學習------面向對象的程序設計

時間 2019-11-19

原文原文鏈接

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

1940年之前：面向機器
    
最先的程序設計都是採用機器語言來編寫的,直接使用二進制碼來表示機器可以識別和執行的指令和數 據。簡單來講,就是直接編寫 0 和 1 的序列來表明程序語言。例如:使用 0000 表明 加載(LOAD),0001 表明 存儲(STORE)等。
機器語言由機器直接執行,速度快,但一個很明顯的缺點就是:寫起來實在是太困難了,一旦你發現本身
寫錯了,改起來更蛋疼!這樣直接致使程序編寫效率十分低下,編寫程序花費的時間每每是實際運行時間
的幾十倍或幾百倍。
有一個關於機器語言和比爾蓋茨的笑話,是說比爾蓋茨拿着繡花針在一張光盤上戳,把 Windows 給戳出 來了!但若是真的讓你去戳,不要說 Windows,連一個簡單的「Hello world」都要讓人戳到眼睛冒煙!

因爲機器語言實在是太難編寫了,因而就發展出了彙編語言。彙編語言亦稱符號語言,用助記符代替機器 指令的操做碼,用地址符號(Symbol)或標號(Label)代替指令或操做數的地址,。彙編語言因爲是採用 了助記符號來編寫程序,比用機器語言的二進制代碼編程要方便些,在必定程度上簡化了編程過程。例如 使用 LOAD 來代替 0000,使用 STORE 來代替 0001。

即便彙編語言相比機器語言提高了可讀性,但其本質上仍是一種面向機器的語言,編寫一樣困難,也很容 易出錯。相信不少計算機畢業的學生至今都對學校的彙編課程中的練習程序心有餘悸。 

脫離機器第一步:面向過程
面向機器的語言一般狀況下被認爲是一種「低級語言」,爲了解決面向機器的語言存在的問題,計算機科 學的前輩們又建立了面向過程的語言。面向過程的語言被認爲是一種「高級語言」,相比面向機器的語言 來講,面向過程的語言已經再也不關注機器自己的操做指令、存儲等方面,而是關注如何一步一步的解決具體的問題,即:解決問題的過程,這應該也是面向過程說法的來由。

 

相比面向機器的思想來講,面向過程是一次思想上的飛躍,將程序員從複雜的機器操做和運行的細節中解 放出來,轉而關注具體須要解決的問題;面向過程的語言也再也不須要和具體的機器綁定,從而具有了移植 性和通用性;面向過程的語言自己也更加容易編寫和維護。這些因素疊加起來,大大減輕了程序員的負擔, 提高了程序員的工做效率,從而促進了軟件行業的快速發展。

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

第一次軟件危機:結構化程序設計

根本緣由就是一些面向過程語言中的goto語句致使的麪條式代碼，極大的限制了程序的規模。結構化程序設計（英語：Structured programming），一種編程範型。它採用子程序（函數就是一種子程序）、代碼區塊、for循環以及while循環等結構，來替換傳統的goto。但願藉此來改善計算機程序的明晰性、質量以及開發時間，而且避免寫出麪條式代碼。

 

隨着計算機硬件的飛速發展,以及應用複雜度愈來愈高,軟件規模愈來愈大,原有的程序開發方式已經越 來越不能知足需求了。1960 年代中期開始爆發了第一次軟件危機,典型表現有軟件質量低下、項目沒法 如期完成、項目嚴重超支等,由於軟件而致使的重大事故時有發生。例如 1963 年美國 (http://en.wikipedia.org/wiki/Mariner_1) 的水手一號火箭發射失敗事故,就是由於一行 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#把面向對象推向了新的高峯。到如今爲止,面向對象已經成爲了主流的開發思想。

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

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

由來

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

面向過程的程序設計：核心是過程二字，過程指的是解決問題的步驟，即先幹什麼再幹什麼......面向過程的設計就比如精心設計好一條流水線，是一種機械式的思惟方式。python

優勢是：複雜度的問題流程化，進而簡單化（一個複雜的問題，分紅一個個小的步驟去實現，實現小的步驟將會很是簡單）linux

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

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

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

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

缺點：sql

1. 編程的複雜度遠高於面向過程，不瞭解面向對象而當即上手基於它設計程序，極容易出現過分設計的問題。一些擴展性要求低的場景使用面向對象會徒增編程難度，好比管理linux系統的shell腳本就不適合用面向對象去設計，面向過程反而更加適合。shell

2. 沒法向面向過程的程序設計流水線式的能夠很精準的預測問題的處理流程與結果，面向對象的程序一旦開始就由對象之間的交互解決問題，即使是上帝也沒法準確地預測最終結果。因而咱們常常看到對戰類遊戲，新增一個遊戲人物，在對戰的過程當中極容易出現陰霸的技能，一刀砍死3我的，這種狀況是沒法準確預知的，只有對象之間交互才能準確地知道最終的結果。編程

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

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

三類與對象

類即類別、種類，是面向對象設計最重要的概念，對象是特徵與技能的結合體，而類則是一系列對象類似的特徵與技能的結合體

那麼問題來了，先有的一個個具體存在的對象（好比一個具體存在的人），仍是先有的人類這個概念，這個問題須要分兩種狀況去看

在現實世界中：先有對象，再有類

世界上確定是先出現各類各樣的實際存在的物體，而後隨着人類文明的發展，人類站在不一樣的角度總結出了不一樣的種類，如人類、動物類、植物類等概念

也就說，對象是具體的存在，而類僅僅只是一個概念，並不真實存在

在程序中：務必保證先定義類，後產生對象

這與函數的使用是相似的，先定義函數，後調用函數，類也是同樣的，在程序中須要先定義類，後調用類

不同的是，調用函數會執行函數體代碼返回的是函數體執行的結果，而調用類會產生對象，返回的是對象

按照上述步驟，咱們來定義一個類（咱們站在學校的角度去看，在座的各位都是學生）

#在現實世界中，站在老男孩學校的角度：先有對象，再有類
對象1：李坦克
    特徵:
        學校=oldboy
        姓名=李坦克
        性別=男
        年齡=18
    技能：
        學習
        吃飯
        睡覺

對象2：王大炮
    特徵:
        學校=oldboy
        姓名=王大炮
        性別=女
        年齡=38
    技能：
        學習
        吃飯
        睡覺

對象3：牛榴彈
    特徵:
        學校=oldboy
        姓名=牛榴彈
        性別=男
        年齡=78
    技能：
        學習
        吃飯
        睡覺


現實中的老男孩學生類
    類似的特徵:
        學校=oldboy
    類似的技能：
        學習
        吃飯
        睡覺

在現實世界中：先有對象，再有類

#在程序中，務必保證：先定義（類），後使用（產生對象）
PS:
  1. 在程序中特徵用變量標識，技能用函數標識
  2. 於是類中最多見的無非是：變量和函數的定義

#程序中的類
class OldboyStudent:
    school='oldboy'
    def learn(self):
        print('is learning')
        
    def eat(self):
        print('is eating')
    
    def sleep(self):
        print('is sleeping')
  


#注意：
  1.類中能夠有任意python代碼，這些代碼在類定義階段便會執行
  2.於是會產生新的名稱空間，用來存放類的變量名與函數名，能夠經過OldboyStudent.__dict__查看
  3.對於經典類來講咱們能夠經過該字典操做類名稱空間的名字（新式類有限制），但python爲咱們提供專門的.語法
  4.點是訪問屬性的語法，類中定義的名字，都是類的屬性

#程序中類的用法
.:專門用來訪問屬性，本質操做的就是__dict__
OldboyStudent.school #等於經典類的操做OldboyStudent.__dict__['school']
OldboyStudent.school='Oldboy' #等於經典類的操做OldboyStudent.__dict__['school']='Oldboy'
OldboyStudent.x=1 #等於經典類的操做OldboyStudent.__dict__['x']=1
del OldboyStudent.x #等於經典類的操做OldboyStudent.__dict__.pop('x')


#程序中的對象
#調用類，或稱爲實例化，獲得對象
s1=OldboyStudent()
s2=OldboyStudent()
s3=OldboyStudent()

#如此，s一、s二、s3都同樣了，而這三者除了類似的屬性以外還各類不一樣的屬性，這就用到了__init__
#注意：該方法是在對象產生以後纔會執行，只用來爲對象進行初始化操做，能夠有任意代碼，但必定不能有返回值
class OldboyStudent:
    ......
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    ......


s1=OldboyStudent('李坦克','男',18) #先調用類產生空對象s1，而後調用OldboyStudent.__init__(s1,'李坦克','男',18)
s2=OldboyStudent('王大炮','女',38)
s3=OldboyStudent('牛榴彈','男',78)


#程序中對象的用法
#執行__init__,s1.name='牛榴彈'，很明顯也會產生對象的名稱空間
s2.__dict__
{'name': '王大炮', 'age': '女', 'sex': 38}

s2.name #s2.__dict__['name']
s2.name='王三炮' #s2.__dict__['name']='王三炮'
s2.course='python' #s2.__dict__['course']='python'
del s2.course #s2.__dict__.pop('course')

在程序中：先定義類，後產生對象

！！！細說__init__方法！！！

#方式1、爲對象初始化本身獨有的特徵
class People:
    country='China'
    x=1
    def run(self):
        print('----->', self)

# 實例化出三個空對象
obj1=People()
obj2=People()
obj3=People()

# 爲對象定製本身獨有的特徵
obj1.name='egon'
obj1.age=18
obj1.sex='male'

obj2.name='lxx'
obj2.age=38
obj2.sex='female'

obj3.name='alex'
obj3.age=38
obj3.sex='female'

# print(obj1.__dict__)
# print(obj2.__dict__)
# print(obj3.__dict__)
# print(People.__dict__)





#方式2、爲對象初始化本身獨有的特徵
class People:
    country='China'
    x=1
    def run(self):
        print('----->', self)

# 實例化出三個空對象
obj1=People()
obj2=People()
obj3=People()

# 爲對象定製本身獨有的特徵
def chu_shi_hua(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'
    obj.name = x
    obj.age = y
    obj.sex = z

chu_shi_hua(obj1,'egon',18,'male')
chu_shi_hua(obj2,'lxx',38,'female')
chu_shi_hua(obj3,'alex',38,'female')





#方式3、爲對象初始化本身獨有的特徵
class People:
    country='China'
    x=1

    def chu_shi_hua(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'
        obj.name = x
        obj.age = y
        obj.sex = z

    def run(self):
        print('----->', self)


obj1=People()
# print(People.chu_shi_hua)
People.chu_shi_hua(obj1,'egon',18,'male')

obj2=People()
People.chu_shi_hua(obj2,'lxx',38,'female')

obj3=People()
People.chu_shi_hua(obj3,'alex',38,'female')




# 方式4、爲對象初始化本身獨有的特徵
class People:
    country='China'
    x=1

    def __init__(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'
        obj.name = x
        obj.age = y
        obj.sex = z

    def run(self):
        print('----->', self)

obj1=People('egon',18,'male') #People.__init__(obj1,'egon',18,'male')
obj2=People('lxx',38,'female') #People.__init__(obj2,'lxx',38,'female')
obj3=People('alex',38,'female') #People.__init__(obj3,'alex',38,'female')


# __init__方法
# 強調：
#   一、該方法內能夠有任意的python代碼
#   二、必定不能有返回值
class People:
    country='China'
    x=1

    def __init__(obj, name, age, sex): #obj=obj1,x='egon',y=18,z='male'
        # if type(name) is not str:
        #     raise TypeError('名字必須是字符串類型')
        obj.name = name
        obj.age = age
        obj.sex = sex


    def run(self):
        print('----->', self)


# obj1=People('egon',18,'male')
obj1=People(3537,18,'male')

# print(obj1.run)
# obj1.run() #People.run(obj1)
# print(People.run)

！！！__init__方法之爲對象定製本身獨有的特徵

PS：

1. 站的角度不一樣，定義出的類是大相徑庭的，詳見面向對象實戰之需求分析

2. 現實中的類並不徹底等於程序中的類，好比現實中的公司類，在程序中有時須要拆分紅部門類，業務類......

3. 有時爲了編程需求，程序中也可能會定義現實中不存在的類，好比策略類，現實中並不存在，可是在程序中倒是一個很常見的類

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

類的特殊屬性(瞭解便可)

！！！補充說明：從代碼級別看面向對象！！！

#一、在沒有學習類這個概念時，數據與功能是分離的
def exc1(host,port,db,charset):
    conn=connect(host,port,db,charset)
    conn.execute(sql)
    return xxx


def exc2(host,port,db,charset,proc_name)
    conn=connect(host,port,db,charset)
    conn.call_proc(sql)
    return xxx

#每次調用都須要重複傳入一堆參數
exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;')
exc2('127.0.0.1',3306,'db1','utf8','存儲過程的名字')




#二、咱們能想到的解決方法是，把這些變量都定義成全局變量
HOST=‘127.0.0.1’
PORT=3306
DB=‘db1’
CHARSET=‘utf8’

def exc1(host,port,db,charset):
    conn=connect(host,port,db,charset)
    conn.execute(sql)
    return xxx


def exc2(host,port,db,charset,proc_name)
    conn=connect(host,port,db,charset)
    conn.call_proc(sql)
    return xxx

exc1(HOST,PORT,DB,CHARSET,'select * from tb1;')
exc2(HOST,PORT,DB,CHARSET,'存儲過程的名字')


#三、可是2的解決方法也是有問題的，按照2的思路，咱們將會定義一大堆全局變量，這些全局變量並無作任何區分，即可以被全部功能使用，然而事實上只有HOST，PORT，DB，CHARSET是給exc1和exc2這兩個功能用的。言外之意：咱們必須找出一種可以將數據與操做數據的方法組合到一塊兒的解決方法，這就是咱們說的類了

class MySQLHandler:
    def __init__(self,host,port,db,charset='utf8'):
        self.host=host
        self.port=port
        self.db=db
        self.charset=charset
    def exc1(self,sql):
        conn=connect(self.host,self.port,self.db,self.charset)
        res=conn.execute(sql)
        return res


    def exc2(self,sql):
        conn=connect(self.host,self.port,self.db,self.charset)
        res=conn.call_proc(sql)
        return res


obj=MySQLHandler('127.0.0.1',3306,'db1')
obj.exc1('select * from tb1;')
obj.exc2('存儲過程的名字')


#改進
class MySQLHandler:
    def __init__(self,host,port,db,charset='utf8'):
        self.host=host
        self.port=port
        self.db=db
        self.charset=charset
        self.conn=connect(self.host,self.port,self.db,self.charset)
    def exc1(self,sql):
        return self.conn.execute(sql)

    def exc2(self,sql):
        return self.conn.call_proc(sql)


obj=MySQLHandler('127.0.0.1',3306,'db1')
obj.exc1('select * from tb1;')
obj.exc2('存儲過程的名字')

數據與專門操做該數據的功能組合到一塊兒

四屬性查找

類有兩種屬性：數據屬性和函數屬性

1. 類的數據屬性是全部對象共享的

2. 類的函數屬性是綁定給對象用的

#類的數據屬性是全部對象共享的,id都同樣
print(id(OldboyStudent.school))

print(id(s1.school))
print(id(s2.school))
print(id(s3.school))

'''
4377347328
4377347328
'''



#類的函數屬性是綁定給對象使用的,obj.method稱爲綁定方法,內存地址都不同
#ps:id是python的實現機制,並不能真實反映內存地址,若是有內存地址,仍是之內存地址爲準
print(OldboyStudent.learn)
print(s1.learn)
print(s2.learn)
print(s3.learn)
'''
<function OldboyStudent.learn at 0x1021329d8>
<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x1021466d8>>
<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x102146710>>
<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x102146748>>
'''

View Code

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

練習：編寫一個學生類，產生一堆學生對象，要求有一個計數器（屬性），統計總共實例了多少個對象

五綁定到對象的方法的特殊之處

#改寫
class OldboyStudent:
    school='oldboy'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def learn(self):
        print('%s is learning' %self.name) #新增self.name

    def eat(self):
        print('%s is eating' %self.name)

    def sleep(self):
        print('%s is sleeping' %self.name)


s1=OldboyStudent('李坦克','男',18)
s2=OldboyStudent('王大炮','女',38)
s3=OldboyStudent('牛榴彈','男',78)

類中定義的函數（沒有被任何裝飾器裝飾的）是類的函數屬性，類可使用，但必須遵循函數的參數規則，有幾個參數須要傳幾個參數

OldboyStudent.learn(s1) #李坦克 is learning
OldboyStudent.learn(s2) #王大炮 is learning
OldboyStudent.learn(s3) #牛榴彈 is learning

類中定義的函數（沒有被任何裝飾器裝飾的）,其實主要是給對象使用的，並且是綁定到對象的，雖然全部對象指向的都是相同的功能，可是綁定到不一樣的對象就是不一樣的綁定方法

強調：綁定到對象的方法的特殊之處在於，綁定給誰就由誰來調用，誰來調用，就會將‘誰’自己當作第一個參數傳給方法，即自動傳值（方法__init__也是同樣的道理）

s1.learn() #等同於OldboyStudent.learn(s1)
s2.learn() #等同於OldboyStudent.learn(s2)
s3.learn() #等同於OldboyStudent.learn(s3)

注意：綁定到對象的方法的這種自動傳值的特徵，決定了在類中定義的函數都要默認寫一個參數self，self能夠是任意名字，可是約定俗成地寫出self。

類即類型

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

　　python中一切皆爲對象，且python3中類與類型是一個概念，類型就是類

#類型dict就是類dict
>>> list
<class 'list'>

#實例化的到3個對象l1,l2,l3
>>> l1=list()
>>> l2=list()
>>> l3=list()

#三個對象都有綁定方法append,是相同的功能,但內存地址不一樣
>>> l1.append
<built-in method append of list object at 0x10b482b48>
>>> l2.append
<built-in method append of list object at 0x10b482b88>
>>> l3.append
<built-in method append of list object at 0x10b482bc8>

#操做綁定方法l1.append(3),就是在往l1添加3,絕對不會將3添加到l2或l3
>>> l1.append(3)
>>> l1
[3]
>>> l2
[]
>>> l3
[]
#調用類list.append(l3,111)等同於l3.append(111)
>>> list.append(l3,111) #l3.append(111)
>>> l3
[111]

六對象之間的交互

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

咱們能夠仿照garen類再建立一個Riven類

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

實例出倆英雄

>>> g1=Garen('草叢倫')
>>> r1=Riven('銳雯雯')

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

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

補充：

　　garen_hero.Q()稱爲向garen_hero這個對象發送了一條消息，讓他去執行Q這個功能，相似的有：

　　garen_hero.W()

　　garen_hero.E()

　　garen_hero.R()

七練習

八繼承與派生

九多態與多態性

十封裝

十一綁定方法與非綁定方法

十二小白容易犯的錯誤

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

2.不少人喜歡說面向對象三大特性（這是從哪傳出來的，封裝，多態，繼承？漏洞太多太多，好吧暫且稱爲三大特性），那麼我在基於面向對象編程時，我必定要讓我定義的類中完整的包含這三種特性，這樣寫確定是好的程序

好傢伙，我說降龍十八掌有十八掌，那麼你每次跟人幹仗都要從第一掌打到第18掌這才顯得你會了是麼：面對敵人，你打到第三掌對方就已經倒下了，你說，不行，你給老子起來，老子尚未show完...

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

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

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

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

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

抽象/實現

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

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

封裝/接口

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

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

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

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

合成

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

派生/繼承/繼承結構

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

泛化/特化

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

多態與多態性

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

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

冰，水蒸氣，都繼承於水，它們都有一個同名的方法就是變成雲，可是冰.變雲(),與水蒸氣.變雲()是大相徑庭的過程，雖然調用的方法都同樣

自省/反射

自省也稱做反射，這個性質展現了某對象是如何在運行期取得自身信息的。若是傳一個對象給你,你能夠查出它有什麼能力,這是一項強大的特性。若是Python不支持某種形式的自省功能,dir和type內建函數,將很難正常工做。還有那些特殊屬性,像__dict__,__name__及__doc__

十四面向對象的軟件開發

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

十五面向對象實戰

本週做業

角色:學校、學員、課程、講師
要求:
1. 建立北京、上海 2 所學校
2. 建立linux , python , go 3個課程， linux\py 在北京開， go 在上海開
3. 課程包含，週期，價格，經過學校建立課程
4. 經過學校建立班級，班級關聯課程、講師
5. 建立學員時，選擇學校，關聯班級
5. 建立講師角色時要關聯學校，
6. 提供兩個角色接口
6.1 學員視圖，能夠註冊，交學費，選擇班級，
6.2 講師視圖，講師可管理本身的班級，上課時選擇班級，查看班級學員列表，修改所管理的學員的成績
6.3 管理視圖，建立講師，建立班級，建立課程