【python基礎】面向物件程式設計（初級篇）

阿新 • • 發佈：2019-01-11

在Python教學中發現，很多同學在走到面向物件程式設計這塊就開始蒙圈了，為了幫助大家更好的理解面向物件程式設計並其能將其用到自己的開發過程中，特寫此文。

概述

面向過程：根據業務邏輯從上到下寫壘程式碼
函式式：將某功能程式碼封裝到函式中，日後便無需重複編寫，僅呼叫函式即可
面向物件：對函式進行分類和封裝，讓開發“更快更好更強...”

面向物件(object-oriented ;簡稱: OO) 至今還沒有統一的概念我這裡把它定義為: 按人們認識客觀世界的系統思維方式,採用基於物件(實體) 的概念建立模型,模擬客觀世界分析、設計、實現軟體的辦法。

面向物件程式設計(Object Oriented Programming-OOP) 是一種解決軟體複用的設計和程式設計方法。這種方法把軟體系統中相近相似的操作邏輯和操作應用資料、狀態,以類的型式描述出來,以物件例項的形式在軟體系統中複用,以達到提高軟體開發效率的作用。

面向過程程式設計最易被初學者接受，其往往用一長段程式碼來實現指定功能，開發過程中最常見的操作就是貼上複製，即：將之前實現的程式碼塊複製到現需功能處。

while True：
    if cpu利用率 > 90%:
        #傳送郵件提醒
        連線郵箱伺服器
        傳送郵件
        關閉連線
 
    if 硬碟使用空間 > 90%:
        #傳送郵件提醒
        連線郵箱伺服器
        傳送郵件
        關閉連線
 
    if 記憶體佔用 > 80%:
        #傳送郵件提醒
        連線郵箱伺服器
        傳送郵件
        關閉連線

隨著時間的推移，開始使用了函數語言程式設計，增強程式碼的重用性和可讀性，就變成了這樣：

def 傳送郵件(內容)
    #傳送郵件提醒
    連線郵箱伺服器
    傳送郵件
    關閉連線
 
while True：
 
    if cpu利用率 > 90%:
        傳送郵件('CPU報警')
 
    if 硬碟使用空間 > 90%:
        傳送郵件('硬碟報警')
 
    if 記憶體佔用 > 80%:
        傳送郵件('記憶體報警')

今天我們來學習一種新的程式設計方式：面向物件程式設計（Object Oriented Programming，OOP，面向物件程式設計）
注：Java和C#來說只支援面向物件程式設計，而python比較靈活即支援面向物件程式設計也支援函數語言程式設計

建立類和物件

面向物件程式設計是一種程式設計方式，此程式設計方式的落地需要使用 “類” 和 “物件” 來實現，所以，面向物件程式設計其實就是對 “類” 和 “物件” 的使用。

　　類就是一個模板，模板裡可以包含多個函式，函式裡實現一些功能

　　物件則是根據模板建立的例項，通過例項物件可以執行類中的函式

class是關鍵字，表示類
建立物件，類名稱後加括號即可

ps：類中的函式第一個引數必須是self（詳細見：類的三大特性之封裝）
　　 類中定義的函式叫做 “方法”

# 建立類
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方法

誒，你在這裡是不是有疑問了？使用函數語言程式設計和麵向物件程式設計方式來執行一個“方法”時函式要比面向物件簡便

面向物件：【建立物件】【通過物件執行方法】
函式程式設計：【執行函式】

觀察上述對比答案則是肯定的，然後並非絕對，場景的不同適合其的程式設計方式也不同。

總結：函式式的應用場景 --> 各個函式之間是獨立且無共用的資料

面向物件三大特性

面向物件的三大特性是指：封裝、繼承和多型。

一、封裝

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

所以，在使用面向物件的封裝特性時，需要：

將內容封裝到某處
從某處呼叫被封裝的內容

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

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

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

所以，內容其實被封裝到了物件 obj1 和 obj2 中，每個物件中都封裝了 name 和 age ，之前說的“內容封裝到某處”其在內容裡類似於下圖來儲存。

第二步：從某處呼叫被封裝的內容

呼叫被封裝的內容時，有兩種情況：

通過物件直接呼叫
通過self間接呼叫

1、通過物件直接呼叫被封裝的內容

上圖展示了物件 obj1 和 obj2 在記憶體中儲存的方式，根據儲存格式可以如此呼叫被封裝的內容：物件.屬性名

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屬性

2、通過self間接呼叫被封裝的內容

執行類中的方法時，需要通過self間接呼叫被封裝的內容

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間接獲取被封裝的內容。

練習一：在終端輸出如下資訊

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

函數語言程式設計

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

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('小明', 10, '男')
laoli.kanchai()
laoli.qudongbei()
laoli.dabaojian()

上述對比可以看出，如果使用函數語言程式設計，需要在每次執行函式時傳入相同的引數，如果引數多的話，又需要貼上複製了... ；而對於面向物件只需要在建立物件時，將所有需要的引數封裝到當前物件中，之後再次使用時，通過self間接去當前物件中取值即可。

練習二：遊戲人生程式

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

蒼井井，女，18，初始戰鬥力1000
東尼木木，男，20，初始戰鬥力1800
波多多，女，19，初始戰鬥力2500

2、遊戲場景，分別：

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

# -*- 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()

遊戲人生

二、繼承

繼承，面向物件中的繼承和現實生活中的繼承相同，即：子可以繼承父的內容。

例如：

　　貓可以：喵喵叫、吃、喝、拉、撒

　　狗可以：汪汪叫、吃、喝、拉、撒

如果我們要分別為貓和狗建立一個類，那麼就需要為貓和狗實現他們所有的功能，如下所示：

虛擬碼

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

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

　　動物：吃、喝、拉、撒

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

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

虛擬碼

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 ('喵喵叫')

程式碼例項

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

所以，對於面向物件的繼承來說，其實就是將多個類共有的方法提取到父類中，子類僅需繼承父類而不必一一實現每個方法。

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

學習了繼承的寫法之後，我們用程式碼來是上述阿貓阿狗的功能：

程式碼例項

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

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

是否可以繼承多個類
如果繼承的多個類每個類中都定了相同的函式，那麼那一個會被使用呢？

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

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

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

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

經典類多繼承

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

新式類多繼承

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類中找，如果還是未找到，則報錯

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

print(C.__mro__) #可以檢視C類的物件搜尋方法時的先後順序

結果：
A.bar
(<class '__main__.C'>, <class '__main__.D'>, <class 'object'>)

三、多型

Pyhon不支援多型並且也用不到多型，多型的概念是應用於Java和C#這一類強型別語言中，而Python崇尚“鴨子型別”。

Python虛擬碼實現Java或C#的多型

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 “鴨子型別”

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)

【python基礎】面向物件程式設計（初級篇）

概述

建立類和物件

面向物件三大特性

【python基礎】面向物件程式設計（初級篇）

【CPP基礎】面向物件的程式設計思想 + 輸入和輸出相關（一）

Python——面向物件程式設計（未完）

【python基礎】保護物件的屬性

【軟考】——面向物件技術（1）

【軟考】——面向物件技術（3）

【軟考】——面向物件技術（互動圖、構件圖、組合結構圖、協作圖、部署圖、包圖）

【Java-3】面向物件程式設計理解

自學Python day6--------面向物件程式設計（訪問限制）

【C#基礎】面向物件

【設計原則】面向物件程式設計的六大原則

前端練級之路——面向物件程式設計（閉包）

實驗2 面向物件程式設計（6學時）

java面向物件程式設計（第二版）讀書筆記-------第一章

C++筆記：面向物件程式設計（Handle類）

Python之面向對象（初級篇）

Python 面向對象（初級篇）

【FastDFS專題】fastdfs使用實戰（配置篇）

【FastDFS專題】fastdfs使用實戰（使用篇）

Python 正則表達式入門（初級篇）

【python基礎】面向物件程式設計（初級篇）

概述

建立類和物件

面向物件三大特性

相關推薦