Python類和對象如何應(yīng)用

這篇文章主要介紹了Python類和對象如何應(yīng)用的相關(guān)知識，內(nèi)容詳細易懂，操作簡單快捷，具有一定借鑒價值，相信大家閱讀完這篇Python類和對象如何應(yīng)用文章都會有所收獲，下面我們一起來看看吧。

我們提供的服務(wù)有：成都做網(wǎng)站、網(wǎng)站制作、微信公眾號開發(fā)、網(wǎng)站優(yōu)化、網(wǎng)站認證、延邊朝鮮族ssl等。為上千家企事業(yè)單位解決了網(wǎng)站和推廣的問題。提供周到的售前咨詢和貼心的售后服務(wù)，是有科學(xué)管理、有技術(shù)的延邊朝鮮族網(wǎng)站制作公司

對象 = 屬性 + 方法

我們前面其實已經(jīng)接觸過封裝的概念，把亂七八糟的數(shù)據(jù)扔進列表里面，這是一種封裝，是數(shù)據(jù)層面的封裝；把常用的代碼段打包成一個函數(shù)，這也是一種封裝，是語句層面的封裝；現(xiàn)在我們要學(xué)習(xí)的對象，也是一種封裝的思想， 對象的來源是模擬真是世界，將數(shù)據(jù)和代碼都封裝在了一起。

打個比方，烏龜就是真實世界的一個對象，通常會從兩個部分來描述它。
（1）從靜態(tài)的特征描述：例如，綠色的，有四條腿，有外殼等等，這是靜態(tài)一方面的描述。
（2）從動態(tài)的行為描述：例如，它會爬，如果追它，它還會跑，有時還會咬人，睡覺等等，這都是從行為方面進行描述的。

Python中的對象也是如此，一個對象的特征稱為“屬性”，一個對象的行為稱為“方法”。：

如果將烏龜寫成代碼，將會是下面這樣：

class Turtle: # Python中的類名約定以大寫字母開頭
    
    # 特征的描述稱為屬性，在代碼層面看來其實就是變量
    color = 'green'
    legs = 4
    shell = True

    # 方法實際就是函數(shù)，通過調(diào)用這些函數(shù)來完成某些工作
    def climb(self):
        print('向前爬')
    def run(self):
        print('向前跑')
    def bite(self):
        print('咬人')
    def sleep(self):
        print('睡覺')

以上代碼定義了對象的特征（屬性）和行為（方法），但還不是一個完整的對象，將定義的這些稱為類（Class）。需要使用類來創(chuàng)建一個真正的對象，這個對象就叫作這個類的一個實例（Instance），也叫實例對象（Instance Objects）。
舉個例子，這就像工廠需要生產(chǎn)一系列玩具，需要先作出這個玩具的模具，然后根據(jù)這個模具再進行批量生產(chǎn)。

那么怎么創(chuàng)建真正的實例對象呢？創(chuàng)建一個對象，也叫類的實例化，其實很簡單：

# 首先要有上面那一段類的定義
tt = Turtle()

注意：類名后面跟著小括號，這跟調(diào)用函數(shù)是一樣的。所以在Python中，類名約定用大寫字母開頭，函數(shù)用小寫字母開頭，這樣更容易區(qū)分。另外，賦值操作并不是必需的，但如果沒有把創(chuàng)建好的實例對象賦值給一個變量，這個對象就沒辦法使用，因為沒有引用指向這個實例，最終會被Python的垃圾回收機制自動回收。

如果要 調(diào)用對象里的方法，使用點操作符（.）即可。

接下來我們看一段代碼，再深入理解一下類、類對象和實例對象三個概念：

從這個例子可以看出，對實例對象c的count屬性進行賦值后，就相當于覆蓋了類對象C的count屬性。如下圖所示，如果沒有賦值覆蓋，那么引用的是類對象的count屬性。

需要注意的是，類中定義的屬性是靜態(tài)變量，類的屬性是與類對象進行綁定，并不會依賴任何它的實例對象。

另外，如果屬性的名字跟方法名相同，屬性會覆蓋方法：

為了避免名字上的沖突，應(yīng)該遵守一些約定俗成的規(guī)矩：
（1）不要試圖在一個類里面定義出所有能想到的特性和方法，應(yīng)該利用繼承和組合機制進行擴展。
（2）用不同的詞性命名，如屬性名用名詞、方法名用動詞，并使用駝峰命名法等。

self是什么

細心的讀者發(fā)現(xiàn)對象的方法都會有一個self參數(shù)，那么這個self是什么呢？如果你接觸過C++，那么你應(yīng)該很容易對號入座，Python的self其實就相當于C++的this指針。

如果你此前沒有接觸過任何編程語言，那么簡單說，如果把類比作圖紙，那么由類實例化后的對象才是真正可以住的房子。根據(jù)一張圖紙可以設(shè)計出成千上萬的房子，它們外觀都差不多，但是每一個房子都有不同的主人。每個人要找到自己的房子，那self就相當于這里的門牌號，有了self，你就可以輕松找到自己的房子。

Python的self參數(shù)就是同一個道理，由一個類可以生成無數(shù)個對象，當一個對象方法被調(diào)用的時候，對象會將自身的引用作為第一個參數(shù)傳給該方法，那么Python就知道需要操作哪個對象的方法了。

舉個簡單的例子：

公有和私有

一般面向?qū)ο蟮木幊陶Z言都會區(qū)分公有和私有的數(shù)據(jù)類型，像C++和Java它們使用public和private關(guān)鍵字用于聲明數(shù)據(jù)是公有的還是私有的，但在Python中并沒有類似的關(guān)鍵字來修飾。

默認上對象的屬性和方法都是公開的，可以直接通過點操作符（.）進行訪問：

為了實現(xiàn)類似私有變量的特征，Python內(nèi)部采用了一種叫name mangling（名字改編）的技術(shù)，在Python中定義私有變量只需要在變量名或函數(shù)名前加上“_ _”兩個下劃線，那么這個函數(shù)或變量就會成為私有的了：

這樣，在外部將變量名“隱藏”起來了，理論上如果要訪問，就要從內(nèi)部進行：

但是認真想一下這個技術(shù)的名字name mangling（名字改編），那就不難發(fā)現(xiàn)其實Python只是把雙下橫線開頭的變量進行了改名而已。實際上，在外部使用“_類名_ _變量名”即可訪問雙下橫線開頭的私有變量了：

說明：Python目前的私有機制其實是偽私有的，Python的類是沒有權(quán)限控制的，所有的變量都是可以被外部調(diào)用的。

繼承

舉個例子來說明繼承。例如現(xiàn)在有個游戲，需要對魚類進行細分，有金魚（Goldfish）、鯉魚（Carp）、三文魚（Salmon）以及鯊魚（Shark）。那么我們能不能不要每次都從頭到尾去重新定義一個新的魚類呢？因為我們知道大多數(shù)魚的屬性和方法是相似的，如果有一種機制可以讓這些相似的東西得以自動傳遞，那么就方便多了。這就是繼承。

繼承的語法很簡單：

c l a s s 類 名 （ 被 繼 承 的 類 ） : . . . class 類名（被繼承的類）: \\ \quad ... class類名（被繼承的類）:...

被繼承的類稱為基類、父類或超類；繼承者稱為子類，一個子類可以繼承它的父類的任何屬性和方法。

舉個例子：

需要注意的是，如果子類中定義與父類同名的方法或?qū)傩?，則會自動覆蓋父類對應(yīng)的方法或?qū)傩?/strong>：

接下來，嘗試寫一下開頭提到的金魚（Goldfish）、鯉魚（Carp）、三文魚（Salmon）以及鯊魚（Shark）的例子。

import random as r
class Fish:
    def __init__(self):
        self.x = r.randint(0, 10)
        self.y = r.randint(0, 10)
    def move(self):
        # 這里主要演示類的繼承機制，就不考慮檢查場景邊界和移動方向問題
        # 假設(shè)所有的魚都是一路向西游
        self.x -= 1
        print("我的位置是：", self.x, self.y)
# 金魚
class Goldfish(Fish):
    pass
# 鯉魚
class Carp(Fish):
    pass
#三文魚
class Salmon(Fish):
    pass
# 上面三種魚都是食物，直接繼承Fish類的全部屬性和方法
# 下面定義鯊魚類，除了繼承Fish類的屬性和方法，還要添加一個吃的方法
class Shark(Fish):
    def __init__(self):
        self.hungry = True
    def eat(self):
        if self.hungry:
            print("吃掉你!")
            self.hungry = False
        else:
            print("太飽了，吃不下了~")

首先運行這段代碼，然后進行測試：

同樣是繼承于Fish類，為什么金魚（goldfish）可以移動，而鯊魚（shark）一移動就報錯呢？
可以看到報錯提示為：Shark對象沒有x屬性，這是因為在Shark類中，重寫了_ _init_ _()方法，但新的_ _init_ _()方法里面沒有初始化鯊魚的x坐標和y坐標，因此調(diào)用move()方法就會出錯。
那么解決這個問題，只要在鯊魚類中重寫_ _init_ _()方法的時候先調(diào)用基類Fish的_ _init_ _()方法。

下面介紹兩種可以實現(xiàn)的技術(shù)：

• （1）調(diào)用未綁定的父類方法

• （2）使用super函數(shù)

調(diào)用未綁定的父類方法

什么是調(diào)用未綁定的父類方法？舉個例子：

修改之后，再運行下發(fā)現(xiàn)鯊魚也可以成功移動了：

這里需要注意的是，這個self并不是父類Fish的實例對象，而是子類Shark的實例對象。所以這里說的未綁定是指并不需要綁定父類的實例對象，使用子類的實例對象代替即可。

使用super函數(shù)

super函數(shù)能夠幫助我們自動找到基類的方法，而且還為我們傳入了self參數(shù)，這樣就不需要做這些事情了：

運行后得到同樣的結(jié)果：

多重繼承

除此之外，Python還支持多重繼承，就是可以同時繼承多個父類的屬性和方法：

c l a s s 類 名 ( 父 類 1 ， 父 類 2 ， 父 類 3 ， . . . ) : . . . class 類名(父類1，父類2，父類3，...):\\ \quad ... class類名(父類1，父類2，父類3，...):...

舉個例子：

這就是基本的多重繼承語法，但多重繼承很容易導(dǎo)致代碼混亂，所以當你不確定是否真的必須使用多重繼承的時候，請盡量避免使用它，因為有些時候會出現(xiàn)不可預(yù)見的BUG。

組合

前面學(xué)習(xí)了繼承的概念，又提到了多重繼承，但如果現(xiàn)在我們有了烏龜類、魚類，現(xiàn)在要求定義一個類，叫水池，水池里要有烏龜和魚。用多重繼承就顯得很奇怪，因為水池和烏龜、魚是不同物種，那怎樣把它們組合成一個水池的類呢？
其實在Python中很簡單，直接把需要的類放進去實例化就可以了，這就叫組合：

先運行上段代碼，然后測試：

構(gòu)造和析構(gòu)

Python的對象有許多神奇的方法，如果你的對象實現(xiàn)了這些方法中的某一個，那么這個方法就會在特殊情況下被Python所調(diào)用，而這一切都是自動發(fā)生的。

_ _init_ _(self[, …])構(gòu)造方法

通常把_ _init_ _()方法稱為構(gòu)造方法，只要實例化一個對象，這個方法就會在對象被創(chuàng)建時自動調(diào)用。實例化對象時是可以傳入?yún)?shù)的，這些參數(shù)會自動傳入_ _init_ _()方法中，可以通過重寫這個方法來自定義對象的初始化操作。

舉個例子：

有些讀者可能會問，有些時候在類定義時寫_ _init_ _()方法，有時候卻沒有，這是為什么呢？看下面這個例子：

這里需要注意的是，_ _init_ _()方法的返回值一定是None，不能是其他：

所以，一般在需要進行初始化的時候才重寫_ _init_ _()方法。所以這個_ _init_ _()方法并不是實例化對象時第一個被調(diào)用的方法。

_ _new_ _(cls[, …])方法

_ _new_ _()方法才是一個對象實例化的時候所調(diào)用的第一個方法。與其他方法不同的是，它的第一個參數(shù)不是self而是這個類（cls），而其他的參數(shù)會直接傳遞給_ _init_ _()方法的。

_ _new_ _()方法需要返回一個實例對象，通常是cls這個類實例化的對象，當然你也可以返回其他對象。

_ _new_ _()方法平時很少去重寫它，一般讓Python用默認的方案執(zhí)行即可。但是有一種情況需要重寫這個方法，就是當繼承一個不可變的類型的時候，它的特性就顯得尤為重要了。

_ _del_ _(self)析構(gòu)方法

如果說_ _init_ _()和_ _new_ _()方法是對象的構(gòu)造器的話，那么Python也提供了一個析構(gòu)器，叫作_ _del_ _()方法。當對象將要被銷毀的時候，這個方法就會被調(diào)用。但是需要注意的是，并非 del x 就相當于自動調(diào)用 x._ _del_ _()，_ _del_ _()方法是當垃圾回收機制回收這個對象的時候調(diào)用的。舉個例子：

什么是綁定

前面提到過綁定的概念，那到底什么是綁定呢？Python中嚴格要求了方法需要有實例才能被調(diào)用，這種限制其實就是Python所謂的綁定概念。

有人可能會這么嘗試，而且發(fā)現(xiàn)也可以調(diào)用：

但是，這樣做會有一個問題，就是根據(jù)類實例化后的對象根本無法調(diào)用里面的函數(shù)：

實際上是由于Python的綁定機制，這里自動把bb對象作為第一個參數(shù)傳入，所以才會出現(xiàn)TypeError。

再看一個例子：

_ _dict_ _屬性是由一個字典組成，字典中僅有實例對象的屬性，不顯示類屬性和特殊屬性，鍵表示的是屬性名，值表示屬性相應(yīng)的數(shù)據(jù)值。

現(xiàn)在實例對象dd有了兩個新屬性，而且這兩個屬性是僅屬于實例對象的：

為什么會這樣？其實這完全歸功于self參數(shù)：當實例對象dd去調(diào)用setXY方法的時候，它傳入的第一個參數(shù)就是dd，那么self.x = 4, self.y = 5也就相當于dd.x = 4, dd.y = 5，所以在實例對象，甚至類對象中都看不到x和y，是因為這兩個屬性是只屬于實例對象dd的。

如果把類實例刪掉，實例對象dd還能否調(diào)用printXY方法？答案是可以的：

關(guān)于“Python類和對象如何應(yīng)用”這篇文章的內(nèi)容就介紹到這里，感謝各位的閱讀！相信大家對“Python類和對象如何應(yīng)用”知識都有一定的了解，大家如果還想學(xué)習(xí)更多知識，歡迎關(guān)注創(chuàng)新互聯(lián)行業(yè)資訊頻道。