[[333719]]

Python很容易學習。 但是，它具有某些難以理解的方面，例如類和對象的世界。 在本文中，您將學習：

• 在Python中，一切都是對象
• 如何創建自己的類和對象
• 什么是繼承，以及如何利用它來發揮自己的優勢

通過使Python對象神秘化，您對語言的理解將大大增加!

對象

對象在Python中起著核心作用。 讓我們來看看如何加深對主題的理解。

引擎蓋下

您可能知道內置的len函數。 它返回您給它的對象的長度。 但是，數字五的長度是多少? 讓我們問一下Python：

>>> len(5)

Traceback (most recent call last): File "", line 1, in TypeError: object of type 'int' has no len()

我喜歡錯誤，因為它們說明了Python在內部的工作方式。 在這種情況下，Python告訴我們5是一個對象，并且沒有len()。

在Python中，一切都是對象。 字符串，布爾值，數字甚至函數都是對象。

我們可以使用內置函數dir()檢查REPL中的對象。 當我們在數字5上嘗試dir時，它將顯示出一個包含在任何數字對象中的函數的大列表：

>>> dir(5)

['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', ...'__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

為了清楚起見，我將列表略去了一些。

該列表以這些帶有下劃線的怪異命名函數開頭，例如__add__。 這些方法稱為魔術方法或dunder(雙下劃線的縮寫)方法。

如果仔細觀察，您會發現int類型的對象沒有__len__ dunder方法。 這就是Python的len()函數如何知道數字沒有長度的原因。 len()所做的全部工作就是在提供它的對象上調用__len __()方法。 這也是為什么Python抱怨" int"類型的對象沒有len()的原因。

我在這里隨便介紹了方法一詞。 讓我更正式地定義它：

當函數是對象的一部分時，我們稱其為方法。

因此，如果字符串確實有長度，那么它必須具有__len__方法，對嗎? 找出答案吧!

>>> dir("test")

['__add__', '__class__','__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

是的，那里。 由于這是一種方法，因此我們也可以調用它：

>>> "test".__len__()

4

這等效于len(" test")，但不夠優雅。 所以不要這樣做，只是為了說明這些東西是如何工作的。

dir()還向我們展示了其他一些不太神奇的方法。 隨意嘗試一些，例如islower：

>>> "test".islower()

True

此方法檢查整個字符串是否為小寫，因此Python返回布爾值True。 其中一些方法需要一個或多個參數，例如replace：

>>> 'abcd'.replace('a', 'b')

'bbcd'

它將所有出現的" a"替換為" b"。

什么是對象

現在我們已經使用了對象，并且知道Python中的所有內容都是對象，是時候定義什么是對象了：

對象是數據(變量)的集合以及對該數據進行操作的方法

對象和面向對象的編程是在1990年代初期流行的概念。 像C這樣的早期計算機語言沒有對象的概念。 但是，事實證明，對象是人類易于理解的范例-可用于對許多現實情況進行建模。

如今，大多數(如果不是全部)新語言都具有對象的概念。 因此，您將要學習的內容在概念上也將適用于其他語言。

由于對象是Python語言的基礎，因此您也可以自己創建對象，這是合乎邏輯的。 為此，我們需要首先定義一個類。

類

如果要創建自己的對象類型，則首先需要定義它具有的方法和可以容納的數據。 該藍圖稱為類。

類是對象的藍圖

所有對象都基于一個類。 創建對象時，我們將其稱為"創建類的實例"。 字符串，數字甚至布爾值也是類的實例。 讓我們探索一下內置函數類型：

>>> type('a')

>>> type(1)

type(True)

顯然，有一些類叫做str，int和bool。 這些是Python的一些本機類，但我們也可以構建自己的類!

如果沒有汽車的類比，那么沒有一部教程是完整的，因此讓我們創建一個代表汽車的類。 輸入的內容很多，您必須重新開始每個錯誤。 隨時嘗試，但是如果您想走捷徑，我了解。 只需將以下內容復制并粘貼到您的Python REPL中：

 

class Car:  
    speed = 0  
    started = False  
 
    def start(self):  
    self.started = True  
        print("Car started, let's ride!") 
     
    def increase_speed(self, delta):  
    if self.started:  
        self.speed = self.speed + delta  
            print('Vrooooom!')  
        else:  
        print("You need to start the car first")  
 
    def stop(self):  
    self.speed = 0  
        print('Halting') 

不用擔心，我們將逐步進行介紹，但首先創建并使用Car類型的對象：

>>> car = Car()

>>> car.increase_speed(10)

You need to start the car first

>>> car.start()

Car started, let's ride!

>>> car.increase_speed(40)

Vrooooom!

>>> _

對象始終是類的實例。 一類可以有許多實例。 我們只是使用Car()創建了Car類的實例，并將其分配給可變car。 創建實例就像調用函數一樣-稍后將了解原因。

接下來，我們在汽車對象上調用一種方法：嘗試在尚未啟動時提高其速度。 糟糕! 只有在啟動汽車后，我們才能提高速度并享受它發出的噪音。

現在，讓我們逐步了解一下汽車課：

• 使用class語句后跟類名(Car)定義類。 我們從冒號開始縮進代碼塊。
• 我們定義了兩個變量，速度和開始。 這是此類的所有實例將具有的數據。
• 接下來，我們定義了對變量進行操作的三種方法。

在這些方法的定義中，我們遇到了一些奇怪的事情：它們都有一個名為self的參數作為它們的第一個參數。

什么是Self?

老實說，如果您問我，這是Python不太優雅的語言構造之一。

還記得我們在調用car對象上的方法時，例如car.start()嗎? 即使start被定義為類中的start(self)，我們也不必傳遞self變量。

這是正在發生的事情：

• 當我們在對象上調用方法時，Python會自動填充第一個變量，我們習慣將其稱為self
• 第一個變量是對對象本身的引用，因此它的名稱
• 我們可以使用此變量來引用該對象的其他實例變量和函數，例如self.speed和self.start()。

因此，僅在類定義內部，我們才使用self來引用屬于實例的變量。 要修改屬于我們課程一部分的開始變量，我們使用self.started而不是僅僅啟動。

通過使用self，我們可以很清楚地了解到我們正在對該實例進行操作的變量，而不是在對象外部定義且碰巧具有相同名稱的其他變量。

從一個類創建多個對象

由于類只是一個藍圖，因此您可以使用它來創建多個對象，就像可以制造多個外觀相同的汽車一樣。 它們的行為都相似，但是它們都有自己的數據，這些數據不會在對象之間共享：

>>> car1 = Car()

>>> car2 = Car()

>>> id(car1)

139771129539104

>>> id(car2)

139771129539160

我們在這里創建了兩個car對象car1和car2，并使用內置方法id()來獲取它們的id。 Python中的每個對象都有一個唯一的標識符，因此我們只是證明我們從同一類創建了兩個不同的對象。 我們可以獨立使用它們：

>>> car1.start()

Car started, let's ride!

>>> car1.increase_speed(10)

'Vrooom!'

>>> car1.speed

10

>>> car2.speed

0

我們剛剛啟動了car1并提高了速度，而car2仍然暫停。 檢查速度可以確認這是狀態不同的不同汽車!

構造函數

從類創建對象時，看起來我們正在調用一個函數：

car = Car()

但這不只是看起來像我們在調用函數，實際上是在調用函數! 我們不必定義的此方法稱為構造函數。 它構造并初始化對象。 默認情況下，每個類都有一個名為__init__的類，即使我們自己沒有定義它。 這與繼承有關，您將很快了解。

您是否曾經使用過str()函數將對象轉換為類? 還是int()函數將字符串轉換為數字?

>>> 'a' + str(1)

'a1'

>>> int('2') + 2

4

您實際上在這里所做的就是通過調用str和int類的構造函數來創建類型為str和int的新對象。

我們也可以重寫__init__方法，以通過接受參數來賦予它更多的功能。 讓我們使用自定義構造函數重新定義Car類：

 

class Car:  
    def __init__(self, started = False, speed = 0):  
    self.started = started  
        self.speed = speed  
 
    def start(self):  
    self.started = True  
        print("Car started, let's ride!")  
 
    def increase_speed(self, delta):  
    if self.started:  
        self.speed = self.speed + delta  
            print("Vrooooom!")  
        else:  
        print("You need to start the car first")  
     
    def stop(self):  
    self.speed = 0 

我們的自定義構造函數已使用默認值命名參數，因此我們可以通過多種方式創建Car類的實例：

>>> c1 = Car()

>>> c2 = Car(True)

>>> c3 = Car(True, 50)

>>> c4 = Car(started=True, speed=40)

您可能已經注意到，我們現在可以創建未啟動但仍要提高速度的新車。 現在，讓我們就這樣了。

繼承

在編程中，最好重用盡可能多的代碼。 這種做法甚至有一個很好的縮寫，叫做DRY：不要重復自己。

類可以幫助您避免重復代碼，因為您可以編寫一次類并根據該類創建許多對象。 但是，它們還以另一種方式(稱為繼承)幫助您。 類可以繼承其他類的屬性和函數，因此您不必重復自己的工作。

舉例來說，我們希望Car類繼承Vehicle類的一些基礎知識。 并且，在定義的同時，還定義了Motorcycle類。 從示意圖上看，它看起來像這樣：

 

 

> Inheritance — image by author

我們已經看到繼承在起作用。 還記得我曾告訴您，即使您沒有定義一個類，每個類都有一個構造函數(init)嗎? 這是因為每個類都繼承自Python中最基礎的類，即object：

>>> dir(object)

['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

當我告訴您" Python中的一切都是對象"時，我的意思就是一切。 這包括類，并且您可以看到我們也可以在類上使用dir()。 它表明該對象具有__init__方法。 不錯，不是嗎?

繼承映射到許多現實情況。 根據上圖，我們來看看繼承的作用。 我們將從通用的Vehicle類開始：

 

class Vehicle:  
    def __init__(self, started = False, speed = 0):  
    self.started = started  
        self.speed = speed  
 
    def start(self):  
    self.started = True  
        print("Started, let's ride!")  
 
    def stop(self):  
    self.speed = 0  
 
    def increase_speed(self, delta):  
    if self.started:  
        self.speed = self.speed + delta  
            print("Vrooooom!")  
        else:  
        print("You need to start me first") 

現在，我們可以使用繼承重新定義我們的Car類：

 

class Car(Vehicle):  
    trunk_open = False  
 
    def open_trunk(self):  
    trunk_open = True  
    def close_trunk(self):  
    trunk_open = False 

我們的汽車繼承了Vehicle類的所有方法和變量，但添加了一個額外的變量和兩個方法來操作后備箱。

覆蓋init方法

有時您想覆蓋init函數。 為了演示，我們可以創建一個Motorcycle類。 大多數摩托車都有中央支架。 我們將添加將其放入或初始化的功能：

 

class Motorcycle(Vehicle):  
    def __init__(self, center_stand_out = False):  
    self.center_stand_out = center_stand_out  
        super().__init__() 

當您重寫構造函數時，根本不會調用父類(我們從中繼承)的構造函數。 如果仍然需要該功能，則必須自己調用它。 這是通過super()完成的：它返回對父類的引用，因此我們可以調用父類的構造函數。

在這種情況下，我們增加了中置支架的功能，但刪除了在構造函數中設置速度和啟動狀態的選項。 如果需要，您也可以添加速度和啟動狀態選項，并將其傳遞給Vehicle構造函數。

覆蓋其他方法

就像__init__一樣，我們也可以覆蓋其他方法。 例如，如果您要實施不啟動的摩托車，則可以覆蓋啟動方法：

 

class Motorcycle(Vehicle):  
    def __init__(self, center_stand_out = False):  
    self.center_stand_out = center_stand_out  
        super().__init__()  
 
    def start(self):  
    print("Sorry, out of fuel!") 

感謝您的閱讀。 如果您想了解有關Python的更多信息，請確保在https://python3.guide上查看我的詳盡指南。