本文整體梳理了 Python 的基本語法與使用方法，并重點介紹了對機器學(xué)習(xí)十分重要且常見的語法，如基本的條件、循環(huán)語句，基本的列表和字典等數(shù)據(jù)結(jié)構(gòu)，此外還介紹了函數(shù)的構(gòu)建和對象與類的聲明。這些在使用 Python 執(zhí)行機器學(xué)習(xí)任務(wù)中十分常見，它可以為我們搭建一個基本的使用框架。

首先，什么是 Python?根據(jù) Python 創(chuàng)建者 Guido van Rossum 所言，Python 是一種高級編程語言，其設(shè)計的核心理念是代碼的易讀性，以及允許編程者通過若干行代碼輕松表達想法創(chuàng)意。實際上，我選擇學(xué)習(xí) Python 的首要原因是其編程的優(yōu)美性，用它編碼和表達想法非常自然。

Python 是一個高層次的結(jié)合了解釋性、編譯性、互動性和面向?qū)ο蟮哪_本語言。Python 的設(shè)計具有很強的可讀性，相比其他語言經(jīng)常使用英文關(guān)鍵字，其他語言的一些標點符號，它具有比其他語言更有特色語法結(jié)構(gòu)。

另一個原因是 Python 的編寫使用方式有多種，數(shù)據(jù)科學(xué)、網(wǎng)頁開發(fā)、機器學(xué)習(xí)皆可使用 Python。Quora、Pinterest 和 Spotify 都使用 Python 作為其后端開發(fā)語言。

一、基礎(chǔ)篇

變量

簡單來講，我們可以把變量看作是存儲一個值的詞。

one = 1 

在 Python 中定義一個變量并為其賦值非常簡單。想象一下你在變量「one」中存儲 1，即是：

這是多么簡單，我們只要把 1 賦值給變量「one」。

two = 2  
some_number = 10000 

并且你可以把任意值賦給任意變量。如上所見，把整數(shù) 2 賦值給變量「two」，把 10,000 賦值給變量「some_number」。除了整數(shù)，我們也可以賦值布爾運算、字符串、浮點數(shù)以及其他數(shù)據(jù)形式。

# booleans  
true_boolean = True  
false_boolean = False 
  
# string  
my_name = "Leandro Tk" 
  
# float  
book_price = 15.80 

控制流：條件語句

「If」語句通過表達式評估一個語句是真或假。如果是真，則向下執(zhí)行「If」條件中的子語句。比如：

if True:  
 print("Hello Python If") 
  
if 2 > 1:  
 print("2 is greater than 1") 

2 比 1 大，因此「print」代碼被執(zhí)行。如果「If」表達式是假的，則「else」下的子語句將被執(zhí)行。

if 1 > 2: 
print ( "1 is greater than 2" ) 
else: 
print ( "1 is not greater than 2" ) 

你也可以使用一個「elif」語句以添加一個執(zhí)行條件。

elif 2 > 1: 
print ( "1 is equal to 2" ) 

循環(huán)/迭代器

在 Python 中，我們可有不同形式的迭代。我將討論兩個：while 與 for。

While 循環(huán)：當(dāng)該語句為真，以下代碼將被執(zhí)行，并打印從 1 到 10 的數(shù)字。

num = 1 
 
while num <= 10: 
   print(num)  
   num += 1 

While 循環(huán)需要一個「循環(huán)條件」。如果它為真，則繼續(xù)迭代。在以上實例中，當(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ù)迭代，直到它為假。對于 For 循環(huán)：你可以把變量「num」應(yīng)用需要循環(huán)的代碼塊中，而「for」語句會為你迭代它。該代碼的打印與 while 代碼相同：從 1 到 10。

看，如此簡單。范圍從 1 直到第 11 個元素(10 是第 10 個元素)。此外，如果我們直接確定一個數(shù)，那么 For 循環(huán)將從零開始一直迭代到該數(shù)字(不包括)。例如以下 For 循環(huán)將輸出 0 到 9：

for i in range(1, 11): 
 print(i) 

二、列表：數(shù)組數(shù)據(jù)結(jié)構(gòu)

列表是一個數(shù)組或集合，它可用于存儲一系列值(比如那些你想要的整數(shù))。因此讓我們用一下它：

my_integers = [1, 2, 3, 4, 5] 

如上我們創(chuàng)建了一個數(shù)組并賦值到 my_integers 變量中。而我們可以通過索引取該數(shù)組中的值，如下所示，數(shù)組***個元素的索引為 0，第二個元素的索引為 1，依次類推。

使用以下語句可能更好理解：

my_integers = [5, 7, 1, 3, 4] 
print(my_integers[0]) # 5 
print(my_integers[1]) # 7  
print(my_integers[4]) # 4 

同樣我們列表元素的類型也可以是字符型，如下我們創(chuàng)建了一個元素為字符的列表：

relatives_names = [  
 "Toshiaki",  
 "Juliana",  
 "Yuji",  
 "Bruno",  
 "Kaio"  
]  
 
print(relatives_names[4]) # Kaio 

以上我們了解了列表的定義和索引使用方法，以下我們將了解如何添加一個元素到列表數(shù)據(jù)結(jié)構(gòu)中。添加元素到列表最常見的方法是 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 方法非常簡單，我們只需要對需要添加的元素應(yīng)用該方法就能將其添加到列表的末尾。

三、字典：鍵-值數(shù)據(jù)結(jié)構(gòu)

我們已經(jīng)知道列表是通過整數(shù)索引來獲取某個元素，而若我們不希望使用整數(shù)作為索引，那么就可以使用字典數(shù)據(jù)結(jié)構(gòu)。通過這種數(shù)據(jù)結(jié)構(gòu)，我們可以使用數(shù)值型、字符型或其它類型的索引。字典的每個鍵值 (key=>value) 對用冒號 (:) 分割，每個對之間用逗號 (,) 分割，整個字典包括在花括號 ({})中。如下，字典(Dictionary)是鍵(Key)與值(Value)的集合：

dictionary_example = {  
 "key1": "value1", 
 "key2": "value2", 
 "key3": "value3" 
} 

其中鍵是指向?qū)?yīng)值的索引，我們需要使用鍵而訪問對應(yīng)的元素值：

{  
 "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)建了一個字典，其中定義了四個鍵與對應(yīng)的值，print 函數(shù)內(nèi)使用了字典的鍵以獲取對應(yīng)的值。此外，字典的值可以使用任何類型的數(shù)據(jù)，如下我們添加了一個鍵為字符型，值為數(shù)值型的鍵-值對。

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 

下面我們需要了解如何添加元素到字典中，其實字典的本質(zhì)就是指向特定值的關(guān)鍵字的集合。因此我們可以直接將某個值賦予到字典某個關(guān)鍵字(可以不存在)中而修改或添加鍵值對。

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)同樣十分簡單，我們可以循環(huán)地修改或輸出某個列表。如下，我們常用 For 循環(huán)依次提取列表中的元素：

bookshelf = [  
 "The Effective Engineer",  
 "The 4 hours work week", 
 "Zero to One", 
 "Lean Startup", 
 "Hooked" 
] 
 
for book in bookshelf:  
   print(book) 

對于哈希數(shù)據(jù)結(jié)構(gòu)，我們同樣可以使用字典中的鍵和 For 循環(huán)依次讀取鍵與對應(yīng)的值：

dictionary = { "some_key": "some_value" } 
 
for key in dictionary:  
   print("%s --> %s" %(key, dictionary[key])) 
 
# some_key --> some_value 

使用 iteritems 方法同樣可以實現(xiàn)相同的效果：

dictionary = { "some_key": "some_value" } 
 
for key, value in dictionary.items(): 
   print("%s --> %s" %(key, value)) 
  
# some_key --> some_value 

我們命名了兩個參數(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 

四、類與對象

對象(Object)表征的是真實世界中的目標，如狗、貓和自行車等，一般對象有兩個特征，即數(shù)據(jù)(Data)與行為(Behavior)。對象「車輛」有一些數(shù)據(jù)，如車輪的數(shù)量、車門的數(shù)量與作為容量等，它同樣還有一些行為，例如車輛可以加速、剎車、展示燃油使用量等。

在面向?qū)ο蟮木幊讨?，我們將?shù)據(jù)表示為屬性，將行為表示為方法。

• 類(Class)是創(chuàng)建獨立對象的藍圖。在現(xiàn)實世界中，我們經(jīng)常發(fā)現(xiàn)很多相同類型的對象。例如車輛，同型號的車輛都有引擎、車輪、座位等組件，而每一輛車都是根據(jù)相同的設(shè)計圖構(gòu)建且有相同的組件。
• 因此，對象是對客觀事物的抽象，類是對對象的抽象。對象是類的實例，類是對象的模板。
• Python 是一種面向?qū)ο蟮某绦蛘Z言，因此它也有類(Class)與對象(Object)這兩個概念。在了解 Python 面向?qū)ο缶幊痰陌咐?，我們需要先熟悉面向?qū)ο缶幊痰囊恍┗靖拍睿?/li>
• 類 (Class)：用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。
• 類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數(shù)體之外。類變量通常不作為實例變量使用。
• 數(shù)據(jù)成員：類變量或者實例變量用于處理類及其實例對象的相關(guān)的數(shù)據(jù)。
• 方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋(override)，也稱為方法的重寫。
• 實例變量：定義在方法中的變量，只作用于當(dāng)前實例的類。
• 繼承：即一個派生類(derived class)繼承基類(base class)的字段和方法。繼承也允許把一個派生類的對象作為一個基類對象對待。例如，一個「狗」類的對象派生自「動物」類，這是模擬"是一個(is-a)"關(guān)系(狗是一種動物)。
• 實例化：創(chuàng)建一個類的實例，類的具體對象。
• 方法：類中定義的函數(shù)。
• 對象：通過類定義的數(shù)據(jù)結(jié)構(gòu)實例。對象包括兩個數(shù)據(jù)成員(類變量和實例變量)和方法。

下面首先查看通過聲明定義類的語句：

class Vehicle: 
   pass 

目標是類的實例，我們可以使用類的名稱創(chuàng)建一個實例：

car = Vehicle()  
print(car) # <__main__.Vehicle instance at 0x7fb1de6c2638> 

如上，car 為 Vehicle 類的一個對象或?qū)嵗?/p>

若我們的 vehicle 類有四個屬性，即車輪數(shù)、儲能類型、座位容量和***時速，那么我們在創(chuàng)建 vehicle 類時可以設(shè)置這些屬性。下面，我們定義了初始化類時所接受的數(shù)據(jù)。self 代表類的實例，self 在定義類的方法時是必須有的，雖然在調(diào)用時不必傳入相應(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 類的實例時就會調(diào)用該方法來定義這些屬性。若我們希望能創(chuàng)建 Tesla Model S 這一個對象，根據(jù)其有四個車輪、電力驅(qū)動、四座容量和***時速為 250km/hour 的特征，我們能創(chuàng)建對象：

tesla_model_s = Vehicle(4, 'electric', 5, 250 

現(xiàn)在所有的屬性已經(jīng)設(shè)定了，那么我們該如何訪問這些屬性值?我們將發(fā)送信息到對象的過程稱為方法，即對象的行為：

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 

以上語句實現(xiàn)了兩個方法，number_of_wheels 和 set_number_of_wheels。我們可以稱為 getter & setter，因為***個方法獲取了屬性值，而第二個方法將為該屬性設(shè)置一個新的值。在類的內(nèi)部，使用 def 關(guān)鍵字可以為類定義一個方法，與一般函數(shù)定義不同，類方法必須包含參數(shù) self，且為***個參數(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)我們設(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)用該方法時，它將返回字符串「VRRRRUUUUM」。

tesla_model_s = Vehicle(4, 'electric', 5, 250)  
tesla_model_s.make_noise() # VRUUUUUUUM 

五、封裝：隱藏信息

封裝是一種限制直接訪問目標屬性和方法的機制，但同時它又有利于對數(shù)據(jù)(對象的方法)進行操作。

封裝是一種將抽象性函數(shù)接口的實現(xiàn)細節(jié)部分包裝、隱藏起來的方法。同時，它也是一種防止外界調(diào)用端，去訪問對象內(nèi)部實現(xiàn)細節(jié)的手段，這個手段是由編程語言本身來提供的。

對象所有的內(nèi)部表征對于外部來說都是隱藏的，只有對象能直接與內(nèi)部數(shù)據(jù)交互。首先，我們需要理解公開(public)和私有(non-public)實例變量和方法。

1. 公開實例變量

對于 Python 的類，我們可以使用 constructor 方法初始化公開實例變量：

class Person: 
   def __init__(self, first_name): 
       self.first_name = first_name 

下面我們應(yīng)用 first_name 的值作為公開實例變量的變元。

tk = Person('TK') 
print(tk.first_name) # => TK 

在類別內(nèi)：

class Person: 
   first_name = 'TK' 

現(xiàn)在我們不需要再對 first_name 賦值，所有賦值到 tk 的目標都將有類的屬性：

tk = Person()print(tk.first_name) # => TK 

現(xiàn)在我們已經(jīng)學(xué)會如何使用公開實例變量和類屬性。除此之外，我們還能管理公開部分的變量值，即對象可以管理其變量的值：Get 和 Set 變量值。保留 Person 類，我們希望能給 first_name 變量賦另外一個值：

tk = Person('TK') 
tk.first_name = 'Kaio' 
print(tk.first_name) # => Kaio 

如上我們將另外一個值(kaio)賦予了 first_name 實例變量，因為它又是一個公開變量，所以會更新變量值。

2. 私有實例變量

和公開實例變量一樣，我們可以使用 constructor 方法或在類的內(nèi)部聲明而定義一個私有實例變量。語法上的不同在于私有實例變量在變量名前面加一個下劃線：

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 

我們可以訪問并且更新它，私有變量僅是一個約定，即他們需要被視為 API 非公開的部分。所以我們可以使用方法在類的定義中完成操作，例如使用兩種方法展示私有實例的值與更新實例的值：

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)在我們可以使用方法更新或訪問私有變量。

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 類并賦值，然后通過定義的方法訪問并打印私有變量的值。如我們直接賦值給私有變量新的值，那么打印出來還是原有的值，我們只能通過在類里面定義的方法進行操作而更新私有變量。

3. 公開方法

對于公開方法(public methods)，我們同樣能在類以外的地方調(diào)用，以下定義了一個類與方法：

class Person: 
   def __init__(self, first_name, age):  
       self.first_name = first_name  
       self._age = age  
 
   def show_age(self):  
       return self._age 

讓我們測試一下該方法：

tk = Person('TK', 25)  
print(tk.show_age()) # => 25 

4. 私有方法

但是對于私有方法來說，并不能這樣操作。若我們定義相同的類，且使用下劃線定義 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)用對象的私有方法：

tk = Person('TK', 25)  
print(tk._show_age()) # => 25 

我們也能訪問并更新它，私有方法應(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 和公開方法 show_age。show_age 方法可以在類的外部調(diào)用，而_get_age 只能在類內(nèi)部使用。

封裝小結(jié)

通過程序封裝，我們確保了對象的內(nèi)部表征對外是隱藏的。而面向?qū)ο蟮木幊處淼闹饕锰幹皇谴a的重用，實現(xiàn)這種重用的方法之一是通過繼承機制。繼承完全可以理解成類之間的類型和子類型關(guān)系。

若我們有一輛車，且知道車輪數(shù)、座位容量和***時速，那么一輛電動車類就繼承常規(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 

更新類中的一個對象：

my_car = Car(4, 5, 250) 
print(my_car.number_of_wheels) 
print(my_car.seating_capacity)  
print(my_car.maximum_velocity) 

初始化對象后，Python 可以將父類(parent class)作為參數(shù)應(yīng)用到子類(child class)中。因此電動車類可以從汽車類繼承對象。

class ElectricCar(Car): 
   def __init__(self, number_of_wheels, seating_capacity, maximum_velocity): 
       Car.__init__(self, number_of_wheels, seating_capacity, maximum_velocity) 

我們不需要實現(xiàn)其他方法，因為電動汽車類已經(jīng)從汽車類繼承了對象：

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 

原文：https://medium.freecodecamp.org/learning-python-from-zero-to-hero-120ea540b567

【本文是51CTO專欄機構(gòu)“機器之心”的原創(chuàng)譯文，微信公眾號“機器之心( id: almosthuman2014)”】

戳這里，看該作者更多好文