Python 教程：從零到大師

來自：pythoncaff.com，譯者： Summer  

連結：https://pythoncaff.com/topics/104/python-tutorials-from-zero-to-master-suitable-for-experienced-developers

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

首先, 什麼是Python? 用python作者Guido van Rossum自己的話來說，Python是這樣的一門語言：

“它是一門高階程式語言, 它的核心設計理念是讓所有程式碼變得更易閱讀，並給開發者們提供一種“僅僅幾行程式碼就能編寫程式設計邏輯”的語法。

那麼，對我來說，讓我學習Python的第一個理由，就是它漂亮而優雅，能夠順暢自然地實現我的想法。

另一個理由，就是Python支援多種程式設計領域，如：

• 資料科學

• web開發

• 機器學習
  比如，Quora、Pinterest、Spotify，這些專案，都是使用python開發他們的後端。

那麼，接下來，就開始學習Python吧！

基礎

1. 變數

可以把變數簡單理解為一個儲存值的單詞。

講道理，變數是什麼就不用特地解釋了…大家都懂。

在Python裡面，定義變數、給變數賦值都非常簡單。比如你想把數字1儲存到一個變數裡面，而這個變數名叫one，那麼，你只需要這樣：

one = 1

非常簡單吧? 舉一反三，完全可以自由發揮，就像下麵，把2賦值給two，把10000賦值給some_number：

two = 2
some_number = 10000

當然，除了整型以外，我們也可以設定布林型別、字串、單精度，以及一些其他資料型別。如下：

# booleans
true_boolean = True
false_boolean = False

# string
my_name = "Leandro Tk"

# float
book_price = 15.80

2.流程控制: 分支陳述句

if，這個陳述句用來判斷是否符合條件，它的後面緊跟著邏輯運算式，運算式最後的值為True或False，如果是true，則執行if裡面的陳述句。如下：

if True:
  print("Hello Python If")

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

因為2大於1，條件成立，所以print陳述句就會被執行
當然，如果不滿足條件，那麼else就派上用場了！
如果，if後面跟著的邏輯運算式最終值是false，則會執行else裡面的程式，如下：

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

你也可以使用elif，是else if的縮寫，但千萬別寫錯~

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

3. 迴圈 / 迭代器

在Python中，我們有多種迭代的方式，我在這裡說兩種：

While 迴圈: 當邏輯運算式為true的時候，while下縮排的程式碼塊就會被迴圈執行. 所以下麵的程式碼片段，將會從1列印到10。

num = 1

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

上面這種迴圈方式，需要一個迴圈條件，如果迴圈條件是true，就會繼續進行迭代，在上面的例子中，當num變成11的時候，迴圈條件就會等於False“

再看看下麵的基礎程式碼塊，以便於理解:

loop_condition = True

while loop_condition:
    print("Loop Condition keeps: %s" %(loop_condition))
    loop_condition = False

只要迴圈條件為True，就會被一直迴圈執行，直到迴圈條件變成False

For迴圈: 與其他語言一樣，這用於計次迴圈，它迴圈的次數，取決於後面那個range方法。

range，代表從在迴圈裡，它用於表示從x到n，如下，就是從1到11，第三個引數可空，意思是每次遞進的加數，預設每迴圈一次給i加1，填2的話，就給i加2

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

串列: 集合 | 陣列 | 資料結構

想象一下，你想把整數1儲存在一個變數中。 但也許現在你想要儲存 2 和 3，4，5 。。。

我是否有另一種方法來儲存我想要的所有整數，但不是以百萬計的變數？ 你猜對了 —— 確實有另一種方法來儲存它們。

List 是一個可以用來儲存一列值的集合（比如你想要的這些整數）。 那麼讓我們使用它：

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

這真的很簡單，我們建立了一個陣列並將其儲存到 my_integer 裡。

但是也許你在問： 『 我怎樣才能從這個串列中獲得值？ 』

很好的問題。 List 有一個叫做索引的概念。 第一個元素獲取索引 0 （零）。 第二個取 1 ，依此類推。 明白了吧。

為了使其更清楚，我們可以用它的索引來表示陣列和每個元素。 我可以畫出來：

使用 Python 語法，它也很容易理解：

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

想象一下現在你不想儲存整數了。你只是想儲存字串，就像你親戚名字的串列一樣。 看起來像這樣：

relatives_names = [
  "Toshiaki",
  "Juliana",
  "Yuji",
  "Bruno",
  "Kaio"
]

print(relatives_names[4]) # Kaio

它的工作方式與整數相同，漂亮。

我們剛剛瞭解到 Lists 索引是如何工作的。 但是我仍然需要告訴你如何將一個元素新增到 List 資料結構（一個專案到串列）。

新增一個值到 List 最常見的方法是 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  非常的簡單。您只需要將元素（例如『 The Effective Engineer 』）作為『 append 』引數應用即可。

那麼，關於 Lists 到這裡就結束了，讓我們來談談另一個資料結構。

字典: 鍵-值 資料結構

現在我們知道 Lists 使用整數來索引. 但是如果我們不想使用整數來索引呢? 一些其他的資料結構可以使用數字，字串或者其他的型別來做索引.

讓我們來學習 Dictionary 資料結構. Dictionary 是一個鍵值對集合. 它長下麵這樣:

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

鍵用來索引到值. 那麼我們如何訪問 Dictionary的值呢? 你猜對啦 — 使用鍵. 試一下吧:

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

我建立了一個關於我的 Dictionary. 我的名字, 暱稱和國籍. 這些屬性是Dictionary 的鍵.

我們知道訪問 List 使用下標, 我們在這也使用下標 (  Dictionary 中的鍵的內容) 來訪問存在 Dictionary中的值.

在例子中, 我打印出了存在 Dictionary中的所有關於我的短語. 非常簡單滴~?

另一件關於 Dictionary非常帥氣的事情就是我們可以使用任何東西來做為字典的值.在我建立的Dictionary中, 我想新增鍵為 “age” 且值為我的整數年齡進去:

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

這裡我們有一個鍵 (age) 值 (24) 對 使用字串來作為鍵，整數來作為值.

像我們學習 Lists一樣,讓我們來學習如何在 Dictionary中新增元素.在Dictionary中， 一個鍵指向一個值是很重要的. 這就是為什麼我們在新增元素的時候討論它:

dictionary_tk = {
  "name": "Leandro",
  "nickname": "Tk",
  "nationality": "Brazilian"
}

dictionary_tk['age'] = 24

print(dictionary_tk) # {'nationality': 'Brazilian', 'age': 24, 'nickname': 'Tk', 'name': 'Leandro'}

我們只需要指定一個值到 Dictionary的鍵上. 一點也不複雜，484啊?

迭代：迴圈Python中的資料結構

當我們在學習 Python基礎時, 會發現串列的迭代是一件十分簡單的事情 ，通常我們Python開發者會使用For來迴圈迭代它. 現在讓我們嘗試一下:

bookshelf = [
  "The Effective Engineer",
  "The 4 hours work week",
  "Zero to One",
  "Lean Startup",
  "Hooked"
]

for book in bookshelf:
    print(book)

如你所見我們已經對書架中的書進行了for操作，我們輸出列印了其中的書（當然你可以在迴圈中對它們做任何事情）。簡單而又直觀，這就是Python。

同樣對於雜湊型別的資料結構，比如像是Python中的字典，我們同樣也可以對其使用for迴圈進行迭代操作，但是此時我們則需要用到key：

dictionary = { "some_key": "some_value" }

for key in dictionary:
    print("%s --> %s" %(key, dictionary[key]))

# some_key --> some_value

這是一個迴圈字典型別變數的小例子，對於dictionary變數我們使用for迴圈操作其中的key，接著我們列印輸出他的key以及其相對應匹配的value值。

當然我們還有另外一種方法去實現它，就是去使用iteritems：

dictionary = { "some_key": "some_value" }

for key, value in dictionary.items():
    print("%s --> %s" %(key, value))

# some_key --> some_value

你看我們已經命名了兩個引數key,value，但這並不是必須的，你甚至可以給它們起任何一個名字^.^，讓我們來看一下：

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

哈哈，可以看到我們已經使用了attribute作為了Dictionary的key引數，程式碼執行十分正確。贊！

型別與物件

一點基礎理論:

物件代表現實世界中像轎車、狗、腳踏車這些事物。物件具有資料和行為兩個主要特徵。

在面向物件程式設計中，我們把資料當作屬性，把行為當作方法。即：

資料 → 屬性 和 行為 → 方法

型別是創造單個物件實體的藍本。在現實世界中，我們經常發現很多物件實體擁有相同的型別，比如轎車。他們都具有相同的構造和模型（具有發動機，輪子，門等等）。每輛車都是根據同一張設計圖製作的，並且具有相同的組成部分。

Python 的面向物件程式設計樣式：ON

Python，作為一門面向物件程式設計的語言，具有類和物件的概念。

類是藍圖，物件是模型。

同樣，一個類，它只是一個模型，或者一種定義屬性和行為的方法（正如我們在理論部分所討論的）。例如，車輛類有自己的屬性，定義什麼是車輛。車輪的數量、能源的型別、座位容量和最大速度都是車輛的屬性。
考慮到這一點，讓我們看看類的Python語法：

class Vehicle:
    pass

我們用一個類宣告來定義類 ，僅此而已。很簡單，不是嗎？

物件是一個類的實體，我們用命名類來建立一個實體。

car = Vehicle()
print(car) # <__main__.vehicle instance="" at=""/>

這裡 ‘car’ 是 ‘Vehicle’ 類的一個物件（或者說實體）。

記住，我們的 ‘Vehicle’ 類有四個屬性：輪子數量，能源型別，座位容量，和最大速度。我們建立一個 ‘Vehicle’ 物件時設定所有這些屬性 。所以在這裡，我們定義我們的類初始化時要接收資料時：

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’方法。我們稱它為構造方法。所以建立 ‘vehicle’ 物件時可以定義這些屬性。假設我們喜歡Tesla Model S，我們要建立這種物件。它有4個輪子，使用電能，有5個座位，最大時速250km/h (155mph）

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

4個“輪子”+電能“能源”+5個“座位”+250km/h“最大速度”。

所有屬性都設定完成了。但是我們如何獲取這些屬性值？我們傳送一個訊息到物件來問他們。 我們稱之為方法. 方法是物件的行為. 讓我們來實現它：

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

這裡建立了兩個方法: number_of_wheels 和 set_number_of_wheels. 我們稱它為 獲取 & 設定. 因為第一個獲取了屬性值,然後第二個設定了一個新的屬性值。

Python 中，我們可以用 “@property” (“decorator”) 去定義 “getters” 和 “setters”。請看以下程式碼：

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

這個與定義方法有些許不同。這些方法的工作機制與屬性不同。例如，當我們設定輪子數量時，我們需要把2賦值給一個變數，只需要設定 “number_of_wheels” 的值為2。這是一種寫 “pythonic”、 ”getter“、“setter” 程式碼的方法。

而且同時我們也可以使用其他方法，比如 “make_noise” 方法。請看下麵的例子。

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

當我們呼叫這個方法時，它傳回字串 ”VRRRRUUUUM“。

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

封裝：資訊隱藏

封裝是一種限制直接訪問物件資料和方法的機制。但是它加快了物件方法中資料的訪問。

“封裝可以在定義中隱藏資料和函式成員，意味著從外部隱藏了物件定義中的內部描述“— Wikipedia

物件從外部隱藏了其內部描述。只有物件可以與它的內部資料進行互動。

首先，我們需要瞭解 “public” 和 “non-public” 變數實體的工作機制。

Public 變數實體

對於一個 Python 型別，我們可以使用構造方法初始化一個公共變數實體。我們看這個：

透過構造方法:

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

這裡我們使用 “first_name” 的值作為一個引數傳遞給公共變數實體。

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

在類中：

class Person:
    first_name = 'TK'

這裡，我們不需要使用 “first_name” 作為一個引數，所有的物件實體都有一個用 “TK” 初始化的類屬性。

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

漂亮。我們已經學習到可以使用公共變數實體和型別屬性。另一件關於 “public” 部分有趣的事情是我們可以管理它的變數的值。我的意思是什麼呢？我們的物件可以管理它的變數值：獲取和設定變數值。

記住 “Person” 類，我們想要設定另一個值給它的 “first_name” 變數：

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

好了，我們剛剛設定了另一個值（”kaio”）給物件變數 “first_name”，並且它更新了它的值。就是這麼簡單，因為這個 “public” 變數，我們可以這樣做。

Non-public 變數實體

“在這裡，我們不用‘私有‘來形容 ，因為在Python中沒有真正“私有”的屬性（避免了一般情況下不必要的工作）。”— PEP 8

和公共變數實體一樣，我們可以在建構式或類內部定義非公共變數實體。語法上的差異是： 對於非公共變數實體，我們在變數名前加一道下劃線(_)。

“在Python中，無法從內部訪問‘私有’變數實體的物件是不存在的。但是，大多數Python程式碼遵循一個慣例：一個名字前有一道下劃線的物件應該被認為是API中非公共的部分，例如_spam，無論它是一個函式、方法或是資料成員。” — Python Software Foundation

這是一個例子：

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中非公共的部分來對待。

在類內部，我們通常使用方法來操作“非公共變數”，讓我們實現兩個方法（email和update_email）來理解。

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

現在，我們可以透過這些方法來訪問、更新非公共變數。

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

1. 我們以first_name TK 和 email tk@mail.com 初始化一個Person物件。

2. 透過方法訪問非公共變數 email，並打印出來。

3. 從類外部直接設定一個新的email。

4. 我們應該把非公共變數作為API中非公共的部分來對待。

5. 透過實體方法更新非公共變數 email。

6. 成功！我們可以透過預設的方法來更新它。

公共方法

透過 公共方法, 我們也可以在我們類的外部使用這些方法了：

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

贊——用起來沒有任何問題。

非公共方法

但是透過 非公共方法 我們卻無法做到這一點。 我們先來實現一個同樣的 Person 類，不過這回我們加個下劃線(_)來定義一個 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

那麼現在，我們來試著透過我們的物件呼叫這個 非公共方法：

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

我們可以訪問並且更新它。 非公共方法 只是一類約定俗成的規定，並且應當被看做介面中的非公共部分。

關於我們該怎麼使用它，這有個例子：

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可以由我們的物件呼叫（在類的外部）而_get_age只能在我們類定義的內部使用(內部show_age方法)。但是再次強調下，這隻是個約定俗成的規定。

封裝總結

透過封裝我們可以從外部隱藏物件的內部表示。

繼承：行為和特徵

某些物件具有共同點：如行為和特徵。

例如，我從我父親那裡繼承了一些特徵和行為。我繼承了他的眼睛和頭髮作為特徵，繼承了他的急躁和內向作為行為。

在面向物件程式設計中，類能夠從其他類中繼承特徵（資料）和行為（方法）。

讓我們看另外一個例子。

假定一輛車。輪子的數量、載客量和最高時速是車的所有屬性。那麼我們可以認為ElectricCar類從這個Car類中繼承了這些屬性。

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

我們的Car類實現之後:

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

一旦初始化後，我們可以使用所有已建立的實體變數。很好。

在Python中我們可以將父類作為子類定義時的引數。一個ElectricCar類能從之前的Car類中繼承。

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

簡單如上。我們不需要實現任何其他的方法，因為這個類已經有了（繼承自Car類）。讓我們確認一下：

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

漂亮。

就到這裡！

關於Python基礎，我們學會了很多：

• 變數

• 分支陳述句

• 迴圈語法

• 串列：集合 | 陣列

• 字典：鍵值對的集合

• 如何迭代這些資料結構

• 物件和類

• 用屬性作為物件的資料

• 用方法作為物件的行為

• getters、setters 和 property 裝飾器

• 封裝：資訊隱藏

• 繼承：行為和特徵

恭喜！你完成了Python的這段密集的內容。

堅持學習，堅持程式設計，祝你玩得開心！

---

●編號493，輸入編號直達本文

●輸入m獲取文章目錄

推薦↓↓↓

Web開發

更多推薦《18個技術類微信公眾號》

涵蓋：程式人生、演演算法與資料結構、駭客技術與網路安全、大資料技術、前端開發、Java、Python、Web開發、安卓開發、iOS開發、C/C++、.NET、Linux、資料庫、運維等。

贊賞

長按二維碼向我轉賬

受蘋果公司新規定影響，微信 iOS 版的贊賞功能被關閉，可透過二維碼轉賬支援公眾號。

閱讀原文


微信掃一掃
使用小程式
即將開啟”“小程式
取消
開啟