Python 面向對象

時間 2019-12-04

原文原文鏈接

概述程序員

面向過程：根據業務邏輯從上到下寫壘代碼數據庫
函數式：將某功能代碼封裝到函數中，往後便無需重複編寫，僅調用函數便可編程
面向對象：對函數進行分類和封裝，讓開發「更快更好更強…」服務器

面向過程編程最易被初學者接受，其每每用一長段代碼來實現指定功能，開發過程當中最多見的操做就是粘貼複製，即：將以前實現的代碼塊複製到現需功能處。函數式編程

 1 while True：
 2     if cpu利用率 > 90%:
 3         #發送郵件提醒
 4         鏈接郵箱服務器
 5         發送郵件
 6         關閉鏈接
 7     if 硬盤使用空間 > 90%:
 8         #發送郵件提醒
 9         鏈接郵箱服務器
10         發送郵件
11         關閉鏈接
12     if 內存佔用 > 80%:
13         #發送郵件提醒
14         鏈接郵箱服務器
15         發送郵件
16         關閉鏈接

隨着時間的推移，開始使用了函數式編程，加強代碼的重用性和可讀性，就變成了這樣：函數

 1 def 發送郵件(內容)
 2     #發送郵件提醒
 3     鏈接郵箱服務器
 4     發送郵件
 5     關閉鏈接
 6 while True：
 7     if cpu利用率 > 90%:
 8         發送郵件('CPU報警')
 9     if 硬盤使用空間 > 90%:
10         發送郵件('硬盤報警')
11     if 內存佔用 > 80%:
12         發送郵件('內存報警')

今天咱們來學習一種新的編程方式：面向對象編程（Object Oriented Programming，OOP，面向對象程序設計）。學習

建立類和對象spa

面向對象編程是一種編程方式，此編程方式的落地須要使用「類」和「對象」來實現，因此，面向對象編程其實就是對「類」和「對象」的使用。設計

類就是一個模板，模板裏能夠包含多個函數，函數裏實現一些功能指針
對象則是根據模板建立的實例，經過實例對象能夠執行類中的函數
class是關鍵字，表示類
建立對象，類名稱後加括號便可

　　ps：類中的函數第一個參數必須是self（詳細見：類的三大特性之封裝）

類定義的函數叫作「方法」

 1 # 建立類
 2 class Foo:
 3     
 4     def Bar(self):
 5         print 'Bar'
 6     def Hello(self, name):
 7         print 'i am %s' %name
 8 # 根據類Foo建立對象obj
 9 obj = Foo()
10 obj.Bar()            #執行Bar方法
11 obj.Hello('wupeiqi') #執行Hello方法

誒，你在這裏是否是有疑問了？使用函數式編程和麪向對象編程方式來執行一個「方法」時函數要比面向對象簡便。

面向對象：【建立對象】【經過對象執行方法】
函數編程：【執行函數】

觀察上述對比答案則是確定的，而後並不是絕對，場景的不一樣適合其的編程方式也不一樣。

總結：函數式的應用場景 –> 各個函數之間是獨立且無共用的數據。

面向對象三大特性

面向對象的三大特性是指：封裝、繼承和多態。

1、封裝

封裝，顧名思義就是將內容封裝到某個地方，之後再去調用被封裝在某處的內容。

因此，在使用面向對象的封裝特性時，須要：

將內容封裝到某處
從某處調用被封裝的內容

第一步：將內容封裝到某處

self 是一個形式參數，當執行 obj1 = Foo('wupeiqi', 18 ) 時，self 等於 obj1

當執行 obj2 = Foo('alex', 78 ) 時，self 等於 obj2

因此，內容其實被封裝到了對象 obj1 和 obj2 中，每一個對象中都有 name 和 age 屬性，在內存裏相似於下圖來保存。

第二步：從某處調用被封裝的內容

調用被封裝的內容時，有兩種狀況：

經過對象直接調用
經過self間接調用

一、經過對象直接調用被封裝的內容

上圖展現了對象 obj1 和 obj2 在內存中保存的方式，根據保存格式能夠如此調用被封裝的內容：對象.屬性名

 1 class Foo:
 2     def __init__(self, name, age):
 3         self.name = name
 4         self.age = age
 5 obj1 = Foo('wupeiqi', 18)
 6 print obj1.name    # 直接調用obj1對象的name屬性
 7 print obj1.age     # 直接調用obj1對象的age屬性
 8 obj2 = Foo('alex', 73)
 9 print obj2.name    # 直接調用obj2對象的name屬性
10 print obj2.age     # 直接調用obj2對象的age屬性

二、經過self間接調用被封裝的內容

執行類中的方法時，須要經過self間接調用被封裝的內容

 1 class Foo:
 2   
 3     def __init__(self, name, age):
 4         self.name = name
 5         self.age = age
 6   
 7     def detail(self):
 8         print self.name
 9         print self.age
10   
11 obj1 = Foo('wupeiqi', 18)
12 obj1.detail()  # Python默認會將obj1傳給self參數，即：obj1.detail(obj1)，因此，此時方法內部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18
13   
14 obj2 = Foo('alex', 73)
15 obj2.detail()  # Python默認會將obj2傳給self參數，即：obj1.detail(obj2)，因此，此時方法內部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

綜上所述，對於面向對象的封裝來講，其實就是使用構造方法將內容封裝到對象中，而後經過對象直接或者self間接獲取被封裝的內容。

練習一：在終端輸出以下信息

小明，10歲，男，上山去砍柴
小明，10歲，男，開車去東北
小明，10歲，男，最愛大保健
老李，90歲，男，上山去砍柴
老李，90歲，男，開車去東北
老李，90歲，男，最愛大保健
老張…

 1 def kanchai(name, age, gender):
 2     print "%s,%s歲,%s,上山去砍柴" %(name, age, gender)
 3  
 4  
 5 def qudongbei(name, age, gender):
 6     print "%s,%s歲,%s,開車去東北" %(name, age, gender)
 7  
 8  
 9 def dabaojian(name, age, gender):
10     print "%s,%s歲,%s,最愛大保健" %(name, age, gender)
11  
12  
13 kanchai('小明', 10, '男')
14 qudongbei('小明', 10, '男')
15 dabaojian('小明', 10, '男')
16  
17  
18 kanchai('老李', 90, '男')
19 qudongbei('老李', 90, '男')
20 dabaojian('老李', 90, '男')

 1 class Foo:
 2   
 3     def __init__(self, name, age ,gender):
 4         self.name = name
 5         self.age = age
 6         self.gender = gender
 7  
 8     def kanchai(self):
 9         print "%s,%s歲,%s,上山去砍柴" %(self.name, self.age, self.gender)
10  
11     def qudongbei(self):
12         print "%s,%s歲,%s,開車去東北" %(self.name, self.age, self.gender)
13  
14     def dabaojian(self):
15         print "%s,%s歲,%s,最愛大保健" %(self.name, self.age, self.gender)
16  
17  
18 xiaoming = Foo('小明', 10, '男')
19 xiaoming.kanchai()
20 xiaoming.qudongbei()
21 xiaoming.dabaojian()
22  
23 laoli = Foo('老李', 90, '男')
24 laoli.kanchai()
25 laoli.qudongbei()
26 laoli.dabaojian()

上述對比能夠看出，若是使用函數式編程，須要在每次執行函數時傳入相同的參數，若是參數多的話，又須要粘貼複製了… ；而對於面向對象只須要在建立對象時，將全部須要的參數封裝到當前對象中，以後再次使用時，經過self間接去當前對象中取值便可。

練習二：遊戲人生程序

1、建立三個遊戲人物，分別是：

蒼井井，女，18，初始戰鬥力1000
東尼木木，男，20，初始戰鬥力1800
波多多，女，19，初始戰鬥力2500
2、遊戲場景，分別：

草叢戰鬥，消耗200戰鬥力
自我修煉，增加100戰鬥力
多人遊戲，消耗500戰鬥力

 1 # -*- coding:utf-8 -*-
 2  
 3 # #####################  定義實現功能的類  #####################
 4  
 5 class Person:
 6  
 7     def __init__(self, na, gen, age, fig):
 8         self.name = na
 9         self.gender = gen
10         self.age = age
11         self.fight =fig
12  
13     def grassland(self):
14         """註釋：草叢戰鬥，消耗200戰鬥力"""
15  
16         self.fight = self.fight - 200
17  
18     def practice(self):
19         """註釋：自我修煉，增加100戰鬥力"""
20         
21         self.fight = self.fight + 200
22  
23     def incest(self):
24         """註釋：多人遊戲，消耗500戰鬥力"""
25         
26         self.fight = self.fight - 500
27  
28     def detail(self):
29         """註釋：當前對象的詳細狀況"""
30  
31         temp = "姓名:%s ; 性別:%s ; 年齡:%s ; 戰鬥力:%s"  % (self.name, self.gender, self.age, self.fight)
32         print temp
33  
34         
35 # #####################  開始遊戲  #####################
36  
37 cang = Person('蒼井井', '女', 18, 1000)    # 建立蒼井井角色
38 dong = Person('東尼木木', '男', 20, 1800)  # 建立東尼木木角色
39 bo = Person('波多多', '女', 19, 2500)      # 建立波多多角色
40  
41 cang.incest() #蒼井空參加一次多人遊戲
42 dong.practice()#東尼木木自我修煉了一次
43 bo.grassland() #波多多參加一次草叢戰鬥
44  
45  
46 #輸出當前全部人的詳細狀況
47 cang.detail()
48 dong.detail()
49 bo.detail()
50  
51  
52 cang.incest() #蒼井空又參加一次多人遊戲
53 dong.incest() #東尼木木也參加了一個多人遊戲
54 bo.practice() #波多多自我修煉了一次
55  
56 #輸出當前全部人的詳細狀況
57 cang.detail()
58 dong.detail()
59 bo.detail()

2、繼承

繼承，面向對象中的繼承和現實生活中的繼承相同，即：子能夠繼承父的內容。

例如：

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

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

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

 1 class 貓：
 2  
 3     def 喵喵叫(self):
 4         print '喵喵叫'
 5  
 6     def 吃(self):
 7         # do something
 8  
 9     def 喝(self):
10         # do something
11  
12     def 拉(self):
13         # do something
14  
15     def 撒(self):
16         # do something
17  
18 class 狗：
19  
20     def 汪汪叫(self):
21         print '喵喵叫'
22  
23     def 吃(self):
24         # do something
25  
26     def 喝(self):
27         # do something
28  
29     def 拉(self):
30         # do something
31  
32     def 撒(self):
33         # do something

上述代碼不難看出，吃、喝、拉、撒是貓和狗都具備的功能，而咱們卻分別的貓和狗的類中編寫了兩次。若是使用繼承的思想，以下實現：

動物：吃、喝、拉、撒

貓：喵喵叫（貓繼承動物的功能）

狗：汪汪叫（狗繼承動物的功能）

 1 class 動物:
 2  
 3     def 吃(self):
 4         # do something
 5  
 6     def 喝(self):
 7         # do something
 8  
 9     def 拉(self):
10         # do something
11  
12     def 撒(self):
13         # do something
14  
15 # 在類後面括號中寫入另一個類名，表示當前類繼承另一個類
16 class 貓(動物)：
17  
18     def 喵喵叫(self):
19         print '喵喵叫'
20         
21 # 在類後面括號中寫入另一個類名，表示當前類繼承另一個類
22 class 狗(動物)：
23  
24     def 汪汪叫(self):
25         print '喵喵叫'

因此，對於面向對象的繼承來講，其實就是將多個類共有的方法提取到父類中，子類僅需繼承父類而沒必要一一實現每一個方法。

注：除了子類和父類的稱謂，你可能看到過派生類和基類，他們與子類和父類只是叫法不一樣而已。

學習了繼承的寫法以後，咱們用代碼來是上述阿貓阿狗的功能：

 1 class Animal:
 2  
 3     def eat(self):
 4         print "%s 吃 " %self.name
 5  
 6     def drink(self):
 7         print "%s 喝 " %self.name
 8  
 9     def shit(self):
10         print "%s 拉 " %self.name
11  
12     def pee(self):
13         print "%s 撒 " %self.name
14  
15  
16 class Cat(Animal):
17  
18     def __init__(self, name):
19         self.name = name
20         self.breed ＝ '貓'
21  
22     def cry(self):
23         print '喵喵叫'
24  
25 class Dog(Animal):
26     
27     def __init__(self, name):
28         self.name = name
29         self.breed ＝ '狗'
30         
31     def cry(self):
32         print '汪汪叫'
33         
34  
35 # ######### 執行 #########
36  
37 c1 = Cat('小白家的小黑貓')
38 c1.eat()
39  
40 c2 = Cat('小黑的小白貓')
41 c2.drink()
42  
43 d1 = Dog('胖子家的小瘦狗')
44 d1.eat()

那麼問題又來了，多繼承呢？

是否能夠繼承多個類
若是繼承的多個類每一個類中都定了相同的函數，那麼那一個會被使用呢？

一、Python的類能夠繼承多個類，Java和C#中則只能繼承一個類

二、Python的類若是繼承了多個類，那麼其尋找方法的方式有兩種，分別是：深度優先和廣度優先

當類是經典類時，多繼承狀況下，會按照深度優先方式查找
當類是新式類時，多繼承狀況下，會按照廣度優先方式查找

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

 1 class D:
 2  
 3     def bar(self):
 4         print 'D.bar'
 5  
 6  
 7 class C(D):
 8  
 9     def bar(self):
10         print 'C.bar'
11  
12  
13 class B(D):
14  
15     def bar(self):
16         print 'B.bar'
17  
18  
19 class A(B, C):
20  
21     def bar(self):
22         print 'A.bar'
23  
24 a = A()
25 # 執行bar方法時
26 # 首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去D類中找，若是D類中麼有，則繼續去C類中找，若是仍是未找到，則報錯
27 # 因此，查找順序：A --> B --> D --> C
28 # 在上述查找bar方法的過程當中，一旦找到，則尋找過程當即中斷，便不會再繼續找了
29 a.bar()

經典類：首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去D類中找，若是D類中麼有，則繼續去C類中找，若是仍是未找到，則報錯

新式類：首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去C類中找，若是C類中麼有，則繼續去D類中找，若是仍是未找到，則報錯

注意：在上述查找過程當中，一旦找到，則尋找過程當即中斷，便不會再繼續找了。

3、多態

Pyhon不支持Java和C#這一類強類型語言中多態的寫法，可是原生多態，其Python崇尚「鴨子類型」。

 1 # Python僞代碼實現Java或C#的多態
 2 
 3 class F1:
 4     pass
 5  
 6  
 7 class S1(F1):
 8  
 9     def show(self):
10         print 'S1.show'
11  
12  
13 class S2(F1):
14  
15     def show(self):
16         print 'S2.show'
17  
18  
19 # 因爲在Java或C#中定義函數參數時，必須指定參數的類型
20 # 爲了讓Func函數既能夠執行S1對象的show方法，又能夠執行S2對象的show方法，因此，定義了一個S1和S2類的父類
21 # 而實際傳入的參數是：S1對象和S2對象
22  
23 def Func(F1 obj):
24     """Func函數須要接收一個F1類型或者F1子類的類型"""
25     
26     print obj.show()
27     
28 s1_obj = S1()
29 Func(s1_obj) # 在Func函數中傳入S1類的對象 s1_obj，執行 S1 的show方法，結果：S1.show
30  
31 s2_obj = S2()
32 Func(s2_obj) # 在Func函數中傳入Ss類的對象 ss_obj，執行 Ss 的show方法，結果：S2.show

 1 # Python 「鴨子類型」
 2 class F1:
 3     pass
 4  
 5  
 6 class S1(F1):
 7  
 8     def show(self):
 9         print 'S1.show'
10  
11  
12 class S2(F1):
13  
14     def show(self):
15         print 'S2.show'
16  
17 def Func(obj):
18     print obj.show()
19  
20 s1_obj = S1()
21 Func(s1_obj)
22  
23 s2_obj = S2()
24 Func(s2_obj)

總結

以上就是本節對於面向對象初級知識的介紹，總結以下：

面向對象是一種編程方式，此編程方式的實現是基於對類和對象的使用

類是一個模板，模板中包裝了多個「函數」供使用

對象，根據模板建立的實例（即：對象），實例用於調用被包裝在類中的函數

面向對象三大特性：封裝、繼承和多態

問答專區

問題一：什麼樣的代碼纔是面向對象？

答：從簡單來講，若是程序中的全部功能都是用類和對象來實現，那麼就是面向對象編程了。

問題二：函數式編程和面向對象如何選擇？分別在什麼狀況下使用？

答：須知：對於 C# 和 Java 程序員來講不存在這個問題，由於該兩門語言只支持面向對象編程（不支持函數式編程）。而對於 Python 和 PHP 等語言卻同時支持兩種編程方式，且函數式編程能完成的操做，面向對象均可以實現；而面向對象的能完成的操做，函數式編程不行（函數式編程沒法實現面向對象的封裝功能）。

因此，通常在Python開發中，所有使用面向對象或面向對象和函數式混合使用

面向對象的應用場景:

1. 多函數需使用共同的值，如：數據庫的增、刪、改、查操做都須要鏈接數據庫字符串、主機名、用戶名和密碼

 1 class SqlHelper:
 2  
 3     def __init__(self, host, user, pwd):
 4  
 5         self.host = host
 6         self.user = user
 7         self.pwd = pwd
 8  
 9     def 增(self):
10         # 使用主機名、用戶名、密碼（self.host 、self.user 、self.pwd）打開數據庫鏈接
11         # do something
12         # 關閉數據庫鏈接
13  
14     def 刪(self):
15         # 使用主機名、用戶名、密碼（self.host 、self.user 、self.pwd）打開數據庫鏈接
16         # do something
17         # 關閉數據庫鏈接
18  
19     def 改(self):
20         # 使用主機名、用戶名、密碼（self.host 、self.user 、self.pwd）打開數據庫鏈接
21         # do something
22         # 關閉數據庫鏈接
23  
24     def 查(self):
25     # 使用主機名、用戶名、密碼（self.host 、self.user 、self.pwd）打開數據庫鏈接
26         # do something
27         # 關閉數據庫鏈接# do something

2. 須要建立多個事物，每一個事物屬性個數相同，可是值的需求

如：張3、李4、楊五，他們都有姓名、年齡、血型，但其都是不相同。即：屬性個數相同，但值不相同

 1 class Person:
 2  
 3     def __init__(self, name ,age ,blood_type):
 4  
 5         self.name = name
 6         self.age = age
 7         self.blood_type = blood_type
 8  
 9  
10     def detail(self):
11         temp = "i am %s, age %s , blood type %s " % (self.name, self.age, self.blood_type)
12         print temp
13  
14 zhangsan = Person('張三', 18, 'A')
15 lisi = Person('李四', 73, 'AB')
16 yangwu = Person('楊五', 84, 'A')