從變量到封裝：一文帶你為機(jī)器學(xué)習(xí)打下堅(jiān)實(shí)的Python基礎(chǔ)
首先，什么是 Python?根據(jù) Python 創(chuàng)建者 Guido van Rossum 所言，Python 是一個(gè)：高級(jí)編程語(yǔ)言，其設(shè)計(jì)的核心理念是代碼的易讀性，以及允許編程者通過(guò)若干行代碼輕松表達(dá)想法創(chuàng)意。實(shí)際上，我選擇學(xué)習(xí) Python 的首要原因是其編程的優(yōu)美性，用它編碼和表達(dá)想法非常自然。
Python 是一個(gè)高層次的結(jié)合了解釋性、編譯性、互動(dòng)性和面向?qū)ο蟮哪_本語(yǔ)言。Python 的設(shè)計(jì)具有很強(qiáng)的可讀性，相比其他語(yǔ)言經(jīng)常使用英文關(guān)鍵字，其他語(yǔ)言的一些標(biāo)點(diǎn)符號(hào)，它具有比其他語(yǔ)言更有特色語(yǔ)法結(jié)構(gòu)。
另一個(gè)原因是 Python 的編寫(xiě)使用方式有多種，數(shù)據(jù)科學(xué)、網(wǎng)頁(yè)開(kāi)發(fā)、機(jī)器學(xué)習(xí)皆可使用 Python。Quora、Pinterest 和 Spotify 都使用 Python 作為其后端開(kāi)發(fā)語(yǔ)言。
基礎(chǔ)篇
變量
簡(jiǎn)單來(lái)講，我們可以把變量看作是存儲(chǔ)一個(gè)值的詞。
在 Python 中定義一個(gè)變量并為其賦值非常簡(jiǎn)單。想象一下你在變量「one」中存儲(chǔ) 1，即是：
- one = 1
這是多么簡(jiǎn)單，我們只要把 1 賦值給變量「one」。
- two = 2
- some_number = 10000
并且你可以把任意值賦給任意變量。如上所見(jiàn)，把整數(shù) 2 賦值給變量「two」，把 10,000 賦值給變量「some_number」。除了整數(shù)，我們也可以賦值布爾運(yùn)算、字符串、浮點(diǎn)數(shù)以及其他數(shù)據(jù)形式。
- # booleans
- true_boolean = True
- false_boolean = False
- # string
- my_name = "Leandro Tk"
- # float
- book_price = 15.80
控制流：條件語(yǔ)句
「If」語(yǔ)句通過(guò)表達(dá)式評(píng)估一個(gè)語(yǔ)句是真或假。如果是真，則向下執(zhí)行「If」條件中的子語(yǔ)句。比如：
- if True:
- print("Hello Python If")
- if 2 > 1:
- print("2 is greater than 1")
2 比 1 大，因此「print」代碼被執(zhí)行。如果「If」表達(dá)式是假的，則「else」下的子語(yǔ)句將被執(zhí)行。
- if 1 > 2:
- print("1 is greater than 2")
- else:
- print("1 is not greater than 2")
你也可以使用一個(gè)「elif」語(yǔ)句以添加一個(gè)執(zhí)行條件。
- if 1 > 2:
- print("1 is greater than 2")
- elif 2 > 1:
- print("1 is not greater than 2")
- else:
- print("1 is equal to 2")
循環(huán)/迭代器
在 Python 中，我們可有不同形式的迭代。我將討論兩個(gè)：while 與 for。
While 循環(huán)：當(dāng)該語(yǔ)句為真，以下代碼將被執(zhí)行，并打印從 1 到 10 的數(shù)字。
- num = 1
- while num <= 10:
- print(num)
- num += 1
While 循環(huán)需要一個(gè)「循環(huán)條件」。如果它為真，則繼續(xù)迭代。在以上實(shí)例中，當(dāng) num 為 11，則循環(huán)條件為假，我們結(jié)束循環(huán)。
以下代碼有助于更好地理解它：
- loop_condition = True
- while loop_condition:
- print("Loop Condition keeps: %s" %(loop_condition))
- loop_condition = False
循環(huán)條件為真，則繼續(xù)迭代，直到它為假。對(duì)于 For 循環(huán)：你可以把變量「num」應(yīng)用需要循環(huán)的代碼塊中，而「for」語(yǔ)句會(huì)為你迭代它。該代碼的打印與 while 代碼相同：從 1 到 10。
- for i in range(1, 11):
- print(i)
看，如此簡(jiǎn)單。范圍從 1 直到第 11 個(gè)元素(10 是第 10 個(gè)元素)。此外，如果我們直接確定一個(gè)數(shù)，那么 For 循環(huán)將從零開(kāi)始一直迭代到該數(shù)字(不包括)。例如以下 For 循環(huán)將輸出 0 到 9：
- for i in range(10):
- print(i)
列表：數(shù)組數(shù)據(jù)結(jié)構(gòu)
列表是一個(gè)數(shù)組或集合，它可用于存儲(chǔ)一系列值(比如那些你想要的整數(shù))。因此讓我們用一下它：
- my_integers = [1, 2, 3, 4, 5]
如上我們創(chuàng)建了一個(gè)數(shù)組并賦值到 my_integers 變量中。而我們可以通過(guò)索引取該數(shù)組中的值，如下所示，數(shù)組***個(gè)元素的索引為 0，第二個(gè)元素的索引為 1，依次類推。
使用以下語(yǔ)句可能更好理解：
- my_integers = [5, 7, 1, 3, 4]
- print(my_integers[0]) # 5
- print(my_integers[1]) # 7
- print(my_integers[4]) # 4
同樣我們列表元素的類型也可以是字符型，如下我們創(chuàng)建了一個(gè)元素為字符的列表：
- relatives_names = [
- "Toshiaki",
- "Juliana",
- "Yuji",
- "Bruno",
- "Kaio"
- ]
- print(relatives_names[4]) # Kaio
以上我們了解了列表的定義和索引使用方法，以下我們將了解如何添加一個(gè)元素到列表數(shù)據(jù)結(jié)構(gòu)中。添加元素到列表最常見(jiàn)的方法是 append：
- bookshelf = []
- bookshelf.append("The Effective Engineer")
- bookshelf.append("The 4 Hour Work Week")
- print(bookshelf[0]) # The Effective Engineer
- print(bookshelf[1]) # The 4 Hour Work Week
append 方法非常簡(jiǎn)單，我們只需要對(duì)需要添加的元素應(yīng)用該方法就能將其添加到列表的末尾。
字典：鍵-值數(shù)據(jù)結(jié)構(gòu)
我們已經(jīng)知道列表是通過(guò)整數(shù)索引來(lái)獲取某個(gè)元素，而若我們不希望使用整數(shù)作為索引，那么就可以使用字典數(shù)據(jù)結(jié)構(gòu)。通過(guò)這種數(shù)據(jù)結(jié)構(gòu)，我們可以使用數(shù)值型、字符型或其它類型的索引。字典的每個(gè)鍵值 (key=>value) 對(duì)用冒號(hào) (**:**) 分割，每個(gè)對(duì)之間用逗號(hào) (**,**) 分割，整個(gè)字典包括在花括號(hào) (**{})**中。如下，字典(Dictionary)是鍵(Key)與值(Value)的集合：
- dictionary_example = {
- "key1": "value1",
- "key2": "value2",
- "key3": "value3"
- }
其中鍵是指向?qū)?yīng)值的索引，我們需要使用鍵而訪問(wèn)對(duì)應(yīng)的元素值：
- dictionary_tk = {
- "name": "Leandro",
- "nickname": "Tk",
- "nationality": "Brazilian"
- }
- print("My name is %s" %(dictionary_tk["name"])) # My name is Leandro
- print("But you can call me %s" %(dictionary_tk["nickname"])) # But you can call me Tk
- print("And by the way I'm %s" %(dictionary_tk["nationality"])) # And by the way I'm Brazilian
以上創(chuàng)建了一個(gè)字典，其中定義了四個(gè)鍵與對(duì)應(yīng)的值，print 函數(shù)內(nèi)使用了字典的鍵以獲取對(duì)應(yīng)的值。此外，字典的值可以使用任何類型的數(shù)據(jù)，如下我們添加了一個(gè)鍵為字符型，值為數(shù)值型的鍵-值對(duì)。
- dictionary_tk = {
- "name": "Leandro",
- "nickname": "Tk",
- "nationality": "Brazilian",
- "age": 24
- }
- print("My name is %s" %(dictionary_tk["name"])) # My name is Leandro
- print("But you can call me %s" %(dictionary_tk["nickname"])) # But you can call me Tk
- print("And by the way I'm %i and %s" %(dictionary_tk["age"], dictionary_tk["nationality"])) # And by the way I'm Brazilian
下面我們需要了解如何添加元素到字典中，其實(shí)字典的本質(zhì)就是指向特定值的關(guān)鍵字的集合。因此我們可以直接將某個(gè)值賦予到字典某個(gè)關(guān)鍵字(可以不存在)中而修改或添加鍵值對(duì)。
- dictionary_tk = {
- "name": "Leandro",
- "nickname": "Tk",
- "nationality": "Brazilian"
- }
dictionary_tk['age'] = 24
print(dictionary_tk) # {'nationality': 'Brazilian', 'age': 24, 'nickname': 'Tk', 'name': 'Leandro'}
迭代：數(shù)據(jù)結(jié)構(gòu)中的循環(huán)
列表循環(huán)同樣十分簡(jiǎn)單，我們可以循環(huán)地修改或輸出某個(gè)列表。如下，我們常用 For 循環(huán)依次提取列表中的元素：
- bookshelf = [
- "The Effective Engineer",
- "The 4 hours work week",
- "Zero to One",
- "Lean Startup",
- "Hooked"
- ]
- for book in bookshelf:
- print(book)
對(duì)于哈希數(shù)據(jù)結(jié)構(gòu)，我們同樣可以使用字典中的鍵和 For 循環(huán)依次讀取鍵與對(duì)應(yīng)的值：
- dictionary = { "some_key": "some_value" }
- for key in dictionary:
- print("%s --> %s" %(key, dictionary[key]))
- # some_key --> some_value
使用 iteritems 方法同樣可以實(shí)現(xiàn)相同的效果：
- dictionary = { "some_key": "some_value" }
- for key, value in dictionary.items():
- print("%s --> %s" %(key, value))
- # some_key --> some_value
我們命名了兩個(gè)參數(shù) key 和 value，但我們同樣可以命名為其它的，如下我們使用 attribute 和 value 作為字典鍵值的參數(shù)，它同樣有效：
- dictionary_tk = {
- "name": "Leandro",
- "nickname": "Tk",
- "nationality": "Brazilian",
- "age": 24
- }
- for attribute, value in dictionary_tk.items():
- print("My %s is %s" %(attribute, value))
- # My name is Leandro
- # My nickname is Tk
- # My nationality is Brazilian
- # My age is 24
進(jìn)階篇
類與對(duì)象
對(duì)象(Object)表征的是真實(shí)世界中的目標(biāo)，如狗、貓和自行車等，一般對(duì)象有兩個(gè)特征，即數(shù)據(jù)(Data)與行為(Behavior)。對(duì)象「車輛」有一些數(shù)據(jù)，如車輪的數(shù)量、車門(mén)的數(shù)量與作為容量等，它同樣還有一些行為，例如車輛可以加速、剎車、展示燃油使用量等。
在面向?qū)ο蟮木幊讨校覀儗?shù)據(jù)表示為屬性，將行為表示為方法。
類(Class)是創(chuàng)建獨(dú)立對(duì)象的藍(lán)圖。在現(xiàn)實(shí)世界中，我們經(jīng)常發(fā)現(xiàn)很多相同類型的對(duì)象。例如車輛，同型號(hào)的車輛都有引擎、車輪、座位等組件，而每一輛車都是根據(jù)相同的設(shè)計(jì)圖構(gòu)建且有相同的組件。
因此，對(duì)象是對(duì)客觀事物的抽象，類是對(duì)對(duì)象的抽象。對(duì)象是類的實(shí)例，類是對(duì)象的模板。
Python 是一種面向?qū)ο蟮某绦蛘Z(yǔ)言，因此它也有類(Class)與對(duì)象(Object)這兩個(gè)概念。在了解 Python 面向?qū)ο缶幊痰陌咐?，我們需要先熟悉面向?qū)ο缶幊痰囊恍┗靖拍睿?/p>
- 類 (Class)：用來(lái)描述具有相同的屬性和方法的對(duì)象的集合。它定義了該集合中每個(gè)對(duì)象所共有的屬性和方法。對(duì)象是類的實(shí)例。
- 類變量：類變量在整個(gè)實(shí)例化的對(duì)象中是公用的。類變量定義在類中且在函數(shù)體之外。類變量通常不作為實(shí)例變量使用。
- 數(shù)據(jù)成員：類變量或者實(shí)例變量用于處理類及其實(shí)例對(duì)象的相關(guān)的數(shù)據(jù)。
- 方法重寫(xiě)：如果從父類繼承的方法不能滿足子類的需求，可以對(duì)其進(jìn)行改寫(xiě)，這個(gè)過(guò)程叫方法的覆蓋(override)，也稱為方法的重寫(xiě)。
- 實(shí)例變量：定義在方法中的變量，只作用于當(dāng)前實(shí)例的類。
- 繼承：即一個(gè)派生類(derived class)繼承基類(base class)的字段和方法。繼承也允許把一個(gè)派生類的對(duì)象作為一個(gè)基類對(duì)象對(duì)待。例如，一個(gè)「狗」類的對(duì)象派生自「動(dòng)物」類，這是模擬”是一個(gè)(is-a)”關(guān)系(狗是一種動(dòng)物)。
- 實(shí)例化：創(chuàng)建一個(gè)類的實(shí)例，類的具體對(duì)象。
- 方法：類中定義的函數(shù)。
- 對(duì)象：通過(guò)類定義的數(shù)據(jù)結(jié)構(gòu)實(shí)例。對(duì)象包括兩個(gè)數(shù)據(jù)成員(類變量和實(shí)例變量)和方法。
下面首先查看通過(guò)聲明定義類的語(yǔ)句：
- class Vehicle:
- pass
目標(biāo)是類的實(shí)例，我們可以使用類的名稱創(chuàng)建一個(gè)實(shí)例：
- car = Vehicle()
- print(car) # <__main__.Vehicle instance at 0x7fb1de6c2638>
如上，car 為 Vehicle 類的一個(gè)對(duì)象或?qū)嵗?/p>
若我們的 vehicle 類有四個(gè)屬性，即車輪數(shù)、儲(chǔ)能類型、座位容量和***時(shí)速，那么我們?cè)趧?chuàng)建 vehicle 類時(shí)可以設(shè)置這些屬性。下面，我們定義了初始化類時(shí)所接受的數(shù)據(jù)。self 代表類的實(shí)例，self 在定義類的方法時(shí)是必須有的，雖然在調(diào)用時(shí)不必傳入相應(yīng)的參數(shù)。
- class Vehicle:
- def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
- self.number_of_wheels = number_of_wheels
- self.type_of_tank = type_of_tank
- self.seating_capacity = seating_capacity
- self.maximum_velocity = maximum_velocity
__init__() 方法是一種特殊的方法，被稱為類的構(gòu)造函數(shù)或初始化方法，當(dāng)創(chuàng)建 vehicle 類的實(shí)例時(shí)就會(huì)調(diào)用該方法來(lái)定義這些屬性。若我們希望能創(chuàng)建 Tesla Model S 這一個(gè)對(duì)象，根據(jù)其有四個(gè)車輪、電力驅(qū)動(dòng)、四座容量和***時(shí)速為 250km/hour 的特征，我們能創(chuàng)建對(duì)象：
- tesla_model_s = Vehicle(4, 'electric', 5, 250)
現(xiàn)在所有的屬性已經(jīng)設(shè)定了，那么我們?cè)撊绾卧L問(wèn)這些屬性值?我們將發(fā)送信息到對(duì)象的過(guò)程稱為方法，即對(duì)象的行為：
- class Vehicle:
- def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
- self.number_of_wheels = number_of_wheels
- self.type_of_tank = type_of_tank
- self.seating_capacity = seating_capacity
- self.maximum_velocity = maximum_velocity
- def number_of_wheels(self):
- return self.number_of_wheels
- def set_number_of_wheels(self, number):
- self.number_of_wheels = number
以上語(yǔ)句實(shí)現(xiàn)了兩個(gè)方法，number_of_wheels 和 set_number_of_wheels。我們可以稱為 getter & setter，因?yàn)?**個(gè)方法獲取了屬性值，而第二個(gè)方法將為該屬性設(shè)置一個(gè)新的值。在類的內(nèi)部，使用 def 關(guān)鍵字可以為類定義一個(gè)方法，與一般函數(shù)定義不同，類方法必須包含參數(shù) self，且為***個(gè)參數(shù)。
在 Python 中，我們能使用 @property (decorators) 定義 getter & setter：
- class Vehicle:
- def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
- self.number_of_wheels = number_of_wheels
- self.type_of_tank = type_of_tank
- self.seating_capacity = seating_capacity
- self.maximum_velocity = maximum_velocity
- @property
- def number_of_wheels(self):
- return self.number_of_wheels
- @number_of_wheels.setter
- def number_of_wheels(self, number):
- self.number_of_wheels = number
同樣我們能使用這些方法作為屬性：
- tesla_model_s = Vehicle(4, 'electric', 5, 250)
- print(tesla_model_s.number_of_wheels) # 4
- tesla_model_s.number_of_wheels = 2 # setting number of wheels to 2
- print(tesla_model_s.number_of_wheels) # 2
這和定義方法有一些不同，這些方法作為了一種屬性。如上當(dāng)我們?cè)O(shè)定新的車輪數(shù)量，我們不需要將「2」作為參數(shù)設(shè)定，而是將 number_of_wheels 數(shù)值設(shè)定為 2。
我們還能使用方法做一些其他的操作，例如方法「make_noise」可以設(shè)置為：
- class Vehicle:
- def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
- self.number_of_wheels = number_of_wheels
- self.type_of_tank = type_of_tank
- self.seating_capacity = seating_capacity
- self.maximum_velocity = maximum_velocity
- def make_noise(self):
- print('VRUUUUUUUM')
當(dāng)我們調(diào)用該方法時(shí)，它將返回字符串「VRRRRUUUUM」。
- tesla_model_s = Vehicle(4, 'electric', 5, 250)
- tesla_model_s.make_noise() # VRUUUUUUUM
封裝：隱藏信息
封裝是一種限制直接訪問(wèn)目標(biāo)屬性和方法的機(jī)制，但同時(shí)它又有利于對(duì)數(shù)據(jù)(對(duì)象的方法)進(jìn)行操作。
封裝是一種將抽象性函數(shù)接口的實(shí)現(xiàn)細(xì)節(jié)部分包裝、隱藏起來(lái)的方法。同時(shí)，它也是一種防止外界調(diào)用端，去訪問(wèn)對(duì)象內(nèi)部實(shí)現(xiàn)細(xì)節(jié)的手段，這個(gè)手段是由編程語(yǔ)言本身來(lái)提供的。
對(duì)象所有的內(nèi)部表征對(duì)于外部來(lái)說(shuō)都是隱藏的，只有對(duì)象能直接與內(nèi)部數(shù)據(jù)交互。首先，我們需要理解公開(kāi)(public)和私有(non-public)實(shí)例變量和方法。
公開(kāi)實(shí)例變量
對(duì)于 Python 的類，我們可以使用 constructor 方法初始化公開(kāi)實(shí)例變量：
- class Person:
- def __init__(self, first_name):
- self.first_name = first_name
下面我們應(yīng)用 first_name 的值作為公開(kāi)實(shí)例變量的變?cè)?/p>
- tk = Person('TK')
- print(tk.first_name) # => TK
在類別內(nèi)：
- class Person:
- first_name = 'TK'
現(xiàn)在我們不需要再對(duì) first_name 賦值，所有賦值到 tk 的目標(biāo)都將有類的屬性：
- tk = Person()
- print(tk.first_name) # => TK
現(xiàn)在我們已經(jīng)學(xué)會(huì)如何使用公開(kāi)實(shí)例變量和類屬性。除此之外，我們還能管理公開(kāi)部分的變量值，即對(duì)象可以管理其變量的值：Get 和 Set 變量值。保留 Person 類，我們希望能給 first_name 變量賦另外一個(gè)值：
- tk = Person('TK')
- tk.first_name = 'Kaio'
- print(tk.first_name) # => Kaio
如上我們將另外一個(gè)值(kaio)賦予了 first_name 實(shí)例變量，因?yàn)樗质且粋€(gè)公開(kāi)變量，所以會(huì)更新變量值。
私有實(shí)例變量
和公開(kāi)實(shí)例變量一樣，我們可以使用 constructor 方法或在類的內(nèi)部聲明而定義一個(gè)私有實(shí)例變量。語(yǔ)法上的不同在于私有實(shí)例變量在變量名前面加一個(gè)下劃線：
- class Person:
- def __init__(self, first_name, email):
- self.first_name = first_name
- self._email = email
上述定義的 email 變量就是私有變量。
- tk = Person('TK', 'tk@mail.com')
- print(tk._email) # tk@mail.com
我們可以訪問(wèn)并且更新它，私有變量?jī)H是一個(gè)約定，即他們需要被視為 API 非公開(kāi)的部分。所以我們可以使用方法在類的定義中完成操作，例如使用兩種方法展示私有實(shí)例的值與更新實(shí)例的值：
- class Person:
- def __init__(self, first_name, email):
- self.first_name = first_name
- self._email = email
- def update_email(self, new_email):
- self._email = new_email
- def email(self):
- return self._email
現(xiàn)在我們可以使用方法更新或訪問(wèn)私有變量。
- tk = Person('TK', 'tk@mail.com')
- print(tk.email()) # => tk@mail.com
- tk._email = 'new_tk@mail.com'
- print(tk.email()) # => tk@mail.com
- tk.update_email('new_tk@mail.com')
- print(tk.email()) # => new_tk@mail.com
我們先初始化 Person 類并賦值，然后通過(guò)定義的方法訪問(wèn)并打印私有變量的值。如我們直接賦值給私有變量新的值，那么打印出來(lái)還是原有的值，我們只能通過(guò)在類里面定義的方法進(jìn)行操作而更新私有變量。
公開(kāi)方法
對(duì)于公開(kāi)方法(public methods)，我們同樣能在類以外的地方調(diào)用，以下定義了一個(gè)類與方法：
- class Person:
- def __init__(self, first_name, age):
- self.first_name = first_name
- self._age = age
- def show_age(self):
- return self._age
讓我們測(cè)試一下該方法：
- tk = Person('TK', 25)
- print(tk.show_age()) # => 25
私有方法
但是對(duì)于私有方法來(lái)說(shuō)，并不能這樣操作。若我們定義相同的類，且使用下劃線定義 show_age 為私有方法：
- class Person:
- def __init__(self, first_name, age):
- self.first_name = first_name
- self._age = age
- def _show_age(self):
- return self._age
我們同樣能調(diào)用對(duì)象的私有方法：
- tk = Person('TK', 25)
- print(tk._show_age()) # => 25
我們也能訪問(wèn)并更新它，私有方法應(yīng)該要看作 API 的私有部分。下面的案例可以展示了如何使用它：
- class Person:
- def __init__(self, first_name, age):
- self.first_name = first_name
- self._age = age
- def show_age(self):
- return self._get_age()
- def _get_age(self):
- return self._age
- tk = Person('TK', 25)
- print(tk.show_age()) # => 25
如上我們聲明了私有方法_get_age 和公開(kāi)方法 show_age。show_age 方法可以在類的外部調(diào)用，而_get_age 只能在類內(nèi)部使用。
封裝小結(jié)
通過(guò)程序封裝，我們確保了對(duì)象的內(nèi)部表征對(duì)外是隱藏的。而面向?qū)ο蟮木幊處?lái)的主要好處之一是代碼的重用，實(shí)現(xiàn)這種重用的方法之一是通過(guò)繼承機(jī)制。繼承完全可以理解成類之間的類型和子類型關(guān)系。
若我們有一輛車，且知道車輪數(shù)、座位容量和***時(shí)速，那么一輛電動(dòng)車類就繼承常規(guī)汽車類中的相同屬性。
- class Car:
- def __init__(self, number_of_wheels, seating_capacity, maximum_velocity):
- self.number_of_wheels = number_of_wheels
- self.seating_capacity = seating_capacity
- self.maximum_velocity = maximum_velocity
更新類中的一個(gè)對(duì)象：
- my_car = Car(4, 5, 250)
- print(my_car.number_of_wheels)
- print(my_car.seating_capacity)
- print(my_car.maximum_velocity)
初始化對(duì)象后，Python 可以將父類(parent class)作為參數(shù)應(yīng)用到子類(child class)中。因此電動(dòng)車類可以從汽車類繼承對(duì)象。
- class ElectricCar(Car):
- def __init__(self, number_of_wheels, seating_capacity, maximum_velocity):
- Car.__init__(self, number_of_wheels, seating_capacity, maximum_velocity)
我們不需要實(shí)現(xiàn)其他方法，因?yàn)殡妱?dòng)汽車類已經(jīng)從汽車類繼承了對(duì)象：
- my_electric_car = ElectricCar(4, 5, 250)
- print(my_electric_car.number_of_wheels) # => 4
- print(my_electric_car.seating_capacity) # => 5
- print(my_electric_car.maximum_velocity) # => 250
