python 面向對象詳解

Python 面向對象

概述

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

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

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

while True：      if cpu利用率 > 90 % :          #發送郵件提醒         鏈接郵箱服務器         發送郵件         關閉鏈接        if 硬盤使用空間 > 90 % :          #發送郵件提醒         鏈接郵箱服務器         發送郵件         關閉鏈接        if 內存佔用 > 80 % :          #發送郵件提醒         鏈接郵箱服務器         發送郵件         關閉鏈接

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

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def 發送郵件 (內容 )      #發送郵件提醒     鏈接郵箱服務器     發送郵件     關閉鏈接   while True：        if cpu利用率 > 90 % :         發送郵件 ( 'CPU報警' )        if 硬盤使用空間 > 90 % :         發送郵件 ( '硬盤報警' )        if 內存佔用 > 80 % :         發送郵件 ( '內存報警' )

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

建立類和對象

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

類就是一個模板，模板裏能夠包含多個函數，函數裏實現一些功能

對象則是根據模板建立的實例，經過實例對象能夠執行類中的函數

• class是關鍵字，表示類
• 建立對象，類名稱後加括號便可

ps：類中的函數第一個參數必須是self（詳細見：類的三大特性之封裝）
　　 類中定義的函數叫作 「方法」

Python

1 2 3 4 5 6 7 8 9 10 11 12 13

# 建立類 class Foo :        def Bar ( self ) :          print 'Bar'        def Hello ( self , name ) :          print 'i am %s' % name   # 根據類Foo建立對象obj obj = Foo ( ) obj . Bar ( )              #執行Bar方法 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 在內存中保存的方式，根據保存格式能夠如此調用被封裝的內容：對象.屬性名

Python

1 2 3 4 5 6 7 8 9 10 11 12 13

class Foo :        def __init__ ( self , name , age ) :          self . name = name          self . age = age   obj1 = Foo ( 'wupeiqi' , 18 ) print obj1 . name      # 直接調用obj1對象的name屬性 print obj1 . age      # 直接調用obj1對象的age屬性   obj2 = Foo ( 'alex' , 73 ) print obj2 . name      # 直接調用obj2對象的name屬性 print obj2 . age      # 直接調用obj2對象的age屬性

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

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

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

class Foo :        def __init__ ( self , name , age ) :          self . name = name          self . age = age        def detail ( self ) :          print self . name          print self . age   obj1 = Foo ( 'wupeiqi' , 18 ) obj1 . detail ( )    # Python默認會將obj1傳給self參數，即：obj1.detail(obj1)，因此，此時方法內部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18   obj2 = Foo ( 'alex' , 73 ) obj2 . detail ( )    # Python默認會將obj2傳給self參數，即：obj1.detail(obj2)，因此，此時方法內部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

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

Python

1 2 3 4 5 6 7 8 9

練習一：在終端輸出以下信息   小明， 10歲，男，上山去砍柴 小明， 10歲，男，開車去東北 小明， 10歲，男，最愛大保健 老李， 90歲，男，上山去砍柴 老李， 90歲，男，開車去東北 老李， 90歲，男，最愛大保健 老張 . . .

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def kanchai ( name , age , gender ) :      print "%s,%s歲,%s,上山去砍柴" % ( name , age , gender )   def qudongbei ( name , age , gender ) :      print "%s,%s歲,%s,開車去東北" % ( name , age , gender )   def dabaojian ( name , age , gender ) :      print "%s,%s歲,%s,最愛大保健" % ( name , age , gender )   kanchai ( '小明' , 10 , '男' ) qudongbei ( '小明' , 10 , '男' ) dabaojian ( '小明' , 10 , '男' )   kanchai ( '老李' , 90 , '男' ) qudongbei ( '老李' , 90 , '男' ) dabaojian ( '老李' , 90 , '男' )

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

class Foo :        def __init__ ( self , name , age , gender ) :          self . name = name          self . age = age          self . gender = gender        def kanchai ( self ) :          print "%s,%s歲,%s,上山去砍柴" % ( self . name , self . age , self . gender )        def qudongbei ( self ) :          print "%s,%s歲,%s,開車去東北" % ( self . name , self . age , self . gender )        def dabaojian ( self ) :          print "%s,%s歲,%s,最愛大保健" % ( self . name , self . age , self . gender )   xiaoming = Foo ( '小明' , 10 , '男' ) xiaoming . kanchai ( ) xiaoming . qudongbei ( ) xiaoming . dabaojian ( )   laoli = Foo ( '老李' , 90 , '男' ) laoli . kanchai ( ) laoli . qudongbei ( ) laoli . dabaojian ( )

Python

1 2 3 4 5 6 7 8 9 10 11 12

練習二：遊戲人生程序   1、建立三個遊戲人物，分別是：   蒼井井，女， 18，初始戰鬥力 1000 東尼木木，男， 20，初始戰鬥力 1800 波多多，女， 19，初始戰鬥力 2500 2、遊戲場景，分別：   草叢戰鬥，消耗 200戰鬥力 自我修煉，增加 100戰鬥力 多人遊戲，消耗 500戰鬥力

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

# -*- coding:utf-8 -*-   # #####################  定義實現功能的類  #####################   class Person :        def __init__ ( self , na , gen , age , fig ) :          self . name = na          self . gender = gen          self . age = age          self . fight = fig        def grassland ( self ) :          """註釋：草叢戰鬥，消耗200戰鬥力"""            self . fight = self . fight - 200        def practice ( self ) :          """註釋：自我修煉，增加100戰鬥力"""            self . fight = self . fight + 200        def incest ( self ) :          """註釋：多人遊戲，消耗500戰鬥力"""            self . fight = self . fight - 500        def detail ( self ) :          """註釋：當前對象的詳細狀況"""            temp = "姓名:%s ; 性別:%s ; 年齡:%s ; 戰鬥力:%s"    % ( self . name , self . gender , self . age , self . fight )          print temp   # #####################  開始遊戲  #####################   cang = Person ( '蒼井井' , '女' , 18 , 1000 )      # 建立蒼井井角色 dong = Person ( '東尼木木' , '男' , 20 , 1800 )    # 建立東尼木木角色 bo = Person ( '波多多' , '女' , 19 , 2500 )        # 建立波多多角色   cang . incest ( ) #蒼井空參加一次多人遊戲 dong . practice ( ) #東尼木木自我修煉了一次 bo . grassland ( ) #波多多參加一次草叢戰鬥   #輸出當前全部人的詳細狀況 cang . detail ( ) dong . detail ( ) bo . detail ( )   cang . incest ( ) #蒼井空又參加一次多人遊戲 dong . incest ( ) #東尼木木也參加了一個多人遊戲 bo . practice ( ) #波多多自我修煉了一次   #輸出當前全部人的詳細狀況 cang . detail ( ) dong . detail ( ) bo . detail ( )

2、繼承

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

例如：

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

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

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

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

class 貓：        def 喵喵叫 ( self ) :          print '喵喵叫'        def 吃 ( self ) :          # do something        def 喝 ( self ) :          # do something        def 拉 ( self ) :          # do something        def 撒 ( self ) :          # do something   class 狗：        def 汪汪叫 ( self ) :          print '喵喵叫'        def 吃 ( self ) :          # do something        def 喝 ( self ) :          # do something        def 拉 ( self ) :          # do something        def 撒 ( self ) :          # do something

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

動物：吃、喝、拉、撒

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

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

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

class 動物 :        def 吃 ( self ) :          # do something        def 喝 ( self ) :          # do something        def 拉 ( self ) :          # do something        def 撒 ( self ) :          # do something   # 在類後面括號中寫入另一個類名，表示當前類繼承另一個類 class 貓 (動物 )：        def 喵喵叫 ( self ) :          print '喵喵叫'   # 在類後面括號中寫入另一個類名，表示當前類繼承另一個類 class 狗 (動物 )：        def 汪汪叫 ( self ) :          print '喵喵叫'

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

class Animal :        def eat ( self ) :          print "%s 吃 " % self . name        def drink ( self ) :          print "%s 喝 " % self . name        def shit ( self ) :          print "%s 拉 " % self . name        def pee ( self ) :          print "%s 撒 " % self . name   class Cat ( Animal ) :        def __init__ ( self , name ) :          self . name = name          self . breed ＝ '貓'        def cry ( self ) :          print '喵喵叫'   class Dog ( Animal ) :        def __init__ ( self , name ) :          self . name = name          self . breed ＝ '狗'        def cry ( self ) :          print '汪汪叫'   # ######### 執行 #########   c1 = Cat ( '小白家的小黑貓' ) c1 . eat ( )   c2 = Cat ( '小黑的小白貓' ) c2 . drink ( )   d1 = Dog ( '胖子家的小瘦狗' ) d1 . eat ( )

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

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

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

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

class Animal :        def eat ( self ) :          print "%s 吃 " % self . name        def drink ( self ) :          print "%s 喝 " % self . name        def shit ( self ) :          print "%s 拉 " % self . name        def pee ( self ) :          print "%s 撒 " % self . name   class Cat ( Animal ) :        def __init__ ( self , name ) :          self . name = name          self . breed ＝ '貓'        def cry ( self ) :          print '喵喵叫'   class Dog ( Animal ) :        def __init__ ( self , name ) :          self . name = name          self . breed ＝ '狗'        def cry ( self ) :          print '汪汪叫'   # ######### 執行 #########   c1 = Cat ( '小白家的小黑貓' ) c1 . eat ( )   c2 = Cat ( '小黑的小白貓' ) c2 . drink ( )   d1 = Dog ( '胖子家的小瘦狗' ) d1 . eat ( )

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

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

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

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

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

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

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

class D :        def bar ( self ) :          print 'D.bar'   class C ( D ) :        def bar ( self ) :          print 'C.bar'   class B ( D ) :        def bar ( self ) :          print 'B.bar'   class A ( B , C ) :        def bar ( self ) :          print 'A.bar'   a = A ( ) # 執行bar方法時 # 首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去D類中找，若是D類中麼有，則繼續去C類中找，若是仍是未找到，則報錯 # 因此，查找順序：A --> B --> D --> C # 在上述查找bar方法的過程當中，一旦找到，則尋找過程當即中斷，便不會再繼續找了 a . bar ( )

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

class D ( object ) :        def bar ( self ) :          print 'D.bar'   class C ( D ) :        def bar ( self ) :          print 'C.bar'   class B ( D ) :        def bar ( self ) :          print 'B.bar'   class A ( B , C ) :        def bar ( self ) :          print 'A.bar'   a = A ( ) # 執行bar方法時 # 首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去C類中找，若是C類中麼有，則繼續去D類中找，若是仍是未找到，則報錯 # 因此，查找順序：A --> B --> C --> D # 在上述查找bar方法的過程當中，一旦找到，則尋找過程當即中斷，便不會再繼續找了 a . bar ( )

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

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

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

3、多態 

Pyhon不支持多態而且也用不到多態，多態的概念是應用於Java和C#這一類強類型語言中，而Python崇尚「鴨子類型」。

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

class F1 :      pass   class S1 ( F1 ) :        def show ( self ) :          print 'S1.show'   class S2 ( F1 ) :        def show ( self ) :          print 'S2.show'   # 因爲在Java或C#中定義函數參數時，必須指定參數的類型 # 爲了讓Func函數既能夠執行S1對象的show方法，又能夠執行S2對象的show方法，因此，定義了一個S1和S2類的父類 # 而實際傳入的參數是：S1對象和S2對象   def Func ( F1 obj ) :      """Func函數須要接收一個F1類型或者F1子類的類型"""        print obj . show ( )   s1_obj = S1 ( ) Func ( s1_obj ) # 在Func函數中傳入S1類的對象 s1_obj，執行 S1 的show方法，結果：S1.show   s2_obj = S2 ( ) Func ( s2_obj ) # 在Func函數中傳入Ss類的對象 ss_obj，執行 Ss 的show方法，結果：S2.show

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

class F1 :      pass   class S1 ( F1 ) :        def show ( self ) :          print 'S1.show'   class S2 ( F1 ) :        def show ( self ) :          print 'S2.show'   def Func ( obj ) :      print obj . show ( )   s1_obj = S1 ( ) Func ( s1_obj )   s2_obj = S2 ( ) Func ( s2_obj )

總結

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

• 面向對象是一種編程方式，此編程方式的實現是基於對 類 和 對象 的使用
• 類 是一個模板，模板中包裝了多個「函數」供使用
• 對象，根據模板建立的實例（即：對象），實例用於調用被包裝在類中的函數
• 面向對象三大特性：封裝、繼承和多態

問答專區

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

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

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