首先，什麼是Python？根據它的創建者Guido van Rossum，Python是：
“高級編程語言，其核心設計理念是代碼可讀性和語法，它允許程序員用幾行代碼表達概念。”
對我來說，學習Python的第一個原因是它實際上是一種簡單的編程語言。用它來編碼和表達我的想法真的很自然。
另一個原因是我們可以通過多種方式使用Python編寫代碼：數據科學，Web開發和機器學習都在這裡發揮作用。Quora，Pinterest和Spotify都使用Python進行後端Web開發。
基礎
1.變量
您可以將變量視為存儲值的單詞。就這麼簡單。在Python中，定義變量併為其設置值非常容易。想象一下，你想將數字1存儲在一個名為“one”的變量中。讓我們這樣做：
one = 1
這有多簡單？您只是將值1賦給變量“one”。
two =2
some_number = 10000
您可以給任何其他變量賦值。如上表所示，變量“ two”存儲數字2，“ some_number ”存儲10,000。
除了數字之外，我們還可以使用booleans （True / False），strings，float和許多其他數據類型。
# booleans
true_boolean = True
false_boolean = False
# string
my_name = "Python"
# float
book_price = 15.80
2.控制流程：條件語句
“ If ”使用表達式來評估語句是True還是False。如果為True，則執行“if”語句中的內容。例如：
if True:
print("Hello Python If")
if 2 > 1:
print("2大於1")
2大於1，因此執行“ print ”（輸出）代碼。如果“ if ”表達式為false，則將執行“ else ”語句。
if 1 > 2:
print("1大於2")
else:
print("1小於2")
1小於2，因此將執行“ else ”語句中的代碼。您還可以使用“ elif ”語句：
if 1 > 2:
print("1大於2")
elif 2 > 1:
print("1小於2")
else:
print("1等於 2")
3.循環/迭代器
在Python中，我們可以以不同的形式進行迭代。我將談論兩個：while 和for。
while循環：當語句為正確的時候，該塊中的代碼會被執行。因此，此代碼將輸出從1到10的數字。
num = 1
while num <= 10:
print(num)
num += 1
while循環需要一個“ 循環條件“。如果它保持為True，它將會繼續迭代。在這個例子中，當num是11的時，循環條件為False。循環停止。
用另一個基礎的代碼來更好地理解它：
loop_condition = True
while loop_condition:
print("Loop Condition keeps: %s" %(loop_condition))
loop_condition = False
該循環條件是True如此它保持迭代-直到我們將其設置為False。
對於循環：將變量“ num ”應用於塊，“ for ”語句將為您迭代它。此代碼將輸出與while代碼相同的代碼：從1到10。
for i in range(1, 11):
print(i)
這很簡單。範圍從第一個元素開始，直到第11個元素（1是第一個元素，10是第10個元素）。
4.列表：集合| 數組| 數據結構
假設您想將整數1存儲在變量中，或者你現在要存儲2,3,4,5 ......
我是否有另一種方法可以存儲我想要的所有整數，但不是數百萬個變量？答案是肯定有- 確實存在另一種存儲它們的方法。
List是一個集合，可用於存儲值列表（如您想要的這些整數）。所以我們使用：
my_integers = [ 1，2，3，4，5 ]
這很簡單。我們創建了一個數組並將其存儲在my_integer上。但也許你在問：“我如何從這個陣列中獲取一個值？”好問題。List有一個叫做索引的概念。第一個元素獲得索引0（0）。第二個得到1，依此類推。為了更清楚，我們可以用它的索引表示數組和每個元素。我可以畫它：
使用Python語法，它也很容易理解：
my_integers = [9, 3, 7, 5, 0]
print(my_integers[0]) # 9
print(my_integers[1]) # 3
print(my_integers[4]) # 0
想象一下，你不想存儲整數。您只想存儲字符串，例如姓名列表。看起來像這樣：
relatives_names = ["Aries","Leo","Virgo","Aquarius","Pisces"]
print(relatives_names[4]) # Pisces
它的工作方式與整數相同。我們剛學會了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參數。
關於列表已經說得夠多了。我們來談談另一種數據結構。
5.Dictionary（字典）：鍵值數據結構
現在我們知道列表是用整數編號索引的。但是，如果我們不想使用整數作為索引呢？我們可以使用的一些數據結構是數字，字符串或其他類型的索引。
讓我們瞭解字典數據結構。字典是鍵值對的集合。如下所示：
dictionary_example = {"key1": "value1","key2": "value2","key3": "value3"}
key鍵值是指向該值的索引。我們如何訪問字典的值？你猜對了 - 用key。如下：
dictionary_Py = {"name": "Python","nickname": "Py","nationality": "China"}
print("My name is %s" %(dictionary_Py["name"])) # My name is Python
print("But you can call me %s" %(dictionary_Py["nickname"])) # But you can call me Py
print("And by the way I'm %s" %(dictionary_Py["nationality"])) # And by the way I'm China
我編寫了一關於我的字典。我的名字，暱稱和國籍。這些屬性是字典鍵。
在學習如何使用索引訪問列表時，我們還使用索引(字典上下文中的鍵)訪問字典中存儲的值。在本例中，我使用字典中存儲的所有值輸出了一個關於我的短語。字典的另一個很酷的地方是，我們可以使用任何值。在我創建的字典中，我想添加關鍵字“年齡”和我的實際整數年齡：
dictionary_Py = {"name": "Python","nickname": "Py","nationality": "China","age": 28}
print("My name is %s" %(dictionary_Py["name"])) # My name is Python
print("But you can call me %s" %(dictionary_Py["nickname"])) # But you can call me Py
print("And by the way I'm %i and %s" %(dictionary_Py["age"], dictionary_Py["nationality"])) # And by the way I'm China
這裡我們有一個鍵值對（年齡：28），使用string作為鍵，integer作為值。
正如我們對列表所做的那樣，讓我們學習如何向字典中添加元素。指向值的鍵是字典的重要組成部分。當我們在談論添加元素的時候也是如此：
dictionary_Py = {"name": "Python","nickname": "Py","nationality": "China"}
dictionary_Py['age'] = 28
print(dictionary_Py) # {'nationality': 'China', 'age': 28, 'nickname': 'Py', 'name': 'Python'}
我們只需要給字典鍵賦一個值。很簡單，對吧？
6.迭代：循環數據結構
正如我們在Python基礎中所學到的，列表迭代非常簡單。我們的Python開發人員通常使用For循環。例如：
bookshelf = ["The Effective Engineer","The 4 hours work week","Zero to One","Lean Startup","Hooked"]
for book in bookshelf:
print(book)
因此對於書架上的每一本書，我們都可以輸出出來。非常簡單直觀。這就是Python。
對於hash（哈希）數據結構，我們也可以使用for循環，我們應用key ：
dictionary = { "some_key": "some_value" }
for key in dictionary:
print("%s --> %s" %(key, dictionary[key]))
# some_key --> some_value
這是一個如何使用它的示例。對於字典中的每個鍵，我們輸出鍵及其相應的值。
另一種方法是使用items的方法。
dictionary = { "some_key": "some_value" }
for key, value in dictionary.items():
print("%s --> %s" %(key, value))
# some_key --> some_value
我們將這兩個參數命名為key和value，但是沒有必要這樣做，我們可以給他們取任何名字。如下所示：
dictionary_Py = {"name": "Python","nickname": "Py","nationality": "China","age": 28}
for attribute, value in dictionary_Py.items():
print("My %s is %s" %(attribute, value))
# My name is Python
# My nickname is Py
# My nationality is China
# My age is 28
我們可以看到我們使用屬性作為字典鍵值的參數，並且它可以正常工作。
7.Classes（類）和Objects（對象）
很簡單的理論：
對象是真實世界對象的一種表示，如汽車、狗或自行車。這些對象共享兩個主要特徵：數據和行為。
汽車有數據，如車輪數量，車門數量和座位數量。它們還表現出行為：它們可以加速，停止，顯示剩餘多少燃料，以及許多其他東西。
在面向對象編程中，我們將數據定義為屬性，將行為定義為方法。
數據→屬性和行為→方法
類是創建單個對象的藍圖。在現實世界中，我們經常發現許多具有相同類型的對象。例如汽車：所有相同的品牌和型號（都有發動機，車輪，車門等）。每輛車都是使用相同的藍圖構建的，並且具有相同的組件。
Python面向對象編程
Python作為面向對象的編程語言，具有以下概念：類和對象。
類是藍圖，是對象的模型。
因此，類只是一個模型，或者定義屬性和行為的一種方法（正如我們在理論部分所討論的那樣）。例如，vehicle（車輛）類具有其自己的屬性，來定義對象是什麼。車輪的數量，油箱的類型，座位數量和最大速度都是車輛的屬性。
考慮到這一點，讓我們看一下類的 Python語法：
class Vehicle:
pass
我們用類聲明定義類。很簡單。
對象是類的實例。我們通過命名類來創建實例。
car = Vehicle()
print(car)
# <__main__.Vehicle instance at 0x7fb1de6c2638>
這裡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對象時，我們可以定義這些屬性。想象一下，我們喜歡特斯拉S型車，我們想要創造出這種東西。它有四個輪子，使用電能，有五個座位的空間，最大速度為250公里/小時。讓我們創建這個對象：
tesla_model_s = Vehicle(4, 'electric', 5, 250)
四輪+電動“油箱類型”+五個座位+ 250km /小時最高速度。
所有屬性都設置好了。但是我們如何訪問這些屬性的值呢?我們向對象發送一條消息詢問它們。我們稱之為方法。它是對象的行為。我們來實現它：
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。我們稱之為getter和setter。因為第一個獲取屬性值，第二個為屬性設置一個新值。
在Python中，我們可以使用@property（decorators）來定義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
這與定義方法略有不同。這些方法作為屬性。例如，當我們設置新的輪數時，我們不會將two作為參數應用，而是將值2設置為number_of_wheels。這是編寫python 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
8.封裝：隱藏信息
封裝是一種限制直接訪問對象的數據和方法的機制。但同時，它也簡化了對數據（對象的方法）的操作。
“封裝可用於隱藏數據成員和成員函數。在這個定義下，封裝意味著對象的內部表示通常隱藏在對象定義之外的視圖中。”
對象的所有內部表示都是從外部隱藏的。只有對象可以與其內部數據進行交互。首先，我們需要了解public和non-public實例變量和方法是如何工作的。
8.1.Public Instance Variables（公共實例變量）
對於Python類，我們可以在構造函數方法中初始化一個公共實例變量。例如：
在構造函數方法中：
class Person:
def __init__(self, first_name):
self.first_name = first_name
這裡我們將first_name值作為參數應用於public instance variable。
Py = Person('PY')
print(Py.first_name) # PY
內部類：
class Person:
first_name = 'PY'
在這裡，我們不需要將first_name參數作為參數應用，並且所有實例對象都有一個用Py初始化的類屬性。
Py = Person()
print(Py.first_name) # PY
現在我們已經瞭解了可以使用公共實例變量和類屬性。關於公共部分的另一個有趣的事情是，我們可以管理變量值。我們的對象可以管理它的變量值：獲取和設置變量值。
記住Person類，我們想將另一個值設置為它的first_name變量：
class Person:
def __init__(self, first_name):
self.first_name = first_name
Py = Person('PY')
Py.first_name = 'Aries'
print(Py.first_name) # Aries
我們只是將另一個值（Aries）設置為first_name實例變量並更新了該值。由於它是一個公共變量，我們可以做到這一點。
8.2.Non-public Instance Variable（非公共實例變量）
我們在這裡不使用術語“私有”，因為在Python中沒有真正私有的屬性（沒有通常不必要的工作）。
作為公共實例變量，我們可以在構造函數方法或類中定義非公共實例變量。語法上的區別是：對於非公共實例變量，在變量名之前使用下劃線（_）。
“除非從對象內部訪問，否則不能訪問的‘私有’實例變量在Python中不存在。然而，有一個慣例是大多數Python代碼都遵循：以下劃線（例如_spam）前綴的名稱應被視為API的非公共部分（無論是函數，方法還是數據成員）“
如下所示：
class Person:
def __init__(self, first_name, email):
self.first_name = first_name
self._email = email
你看到email變量了嗎？這就是我們定義的方式non-public variable ：
Py = Person('PY', '[email protected]')
print(Py._email) # [email protected]
我們可以訪問和更新它。Non-public variables只是一個慣例，應該作為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
現在我們可以使用這些方法更新和訪問非公共變量。如下所示：
Py = Person('PY', '[email protected]')
print(Py.email()) # [email protected]
# Py._email = '[email protected]' -- treat as a non-public part of the class API
print(Py.email()) # [email protected]
Py.update_email('[email protected]')
print(Py.email()) # [email protected]
- 我們用first_name PY和email [email protected] 啟動了一個新對象
- 通過使用方法訪問非公共變量來輸出電子郵件
- 試圖在我們的類上設置一個新的email
- 我們需要將非公共變量視為API的非公共部分
- 使用實例方法更新非公共變量
- 成功！我們可以使用helper方法在我們的類中更新它
8.3.public methods（公共方法）
有了public methods，我們也可以在類之外使用它們：
class Person:
def __init__(self, first_name, age):
self.first_name = first_name
self._age = age
def show_age(self):
return self._age
我們來測試一下：
Py = Person('Py', 28)
print(Py.show_age()) # 28
我們可以毫無問題地使用它。
8.4.Non-public Method（非公共方法）
但是non-public methods我們無法做到。讓我們實現相同的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
現在，我們試著用我們的對象調用這個非公共方法：
Py = Person('PY', 28)
print(Py._show_age()) # 28
我們可以訪問和更新它。Non-public methods只是一個慣例，應該被視為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
Py = Person('PY', 28)
print(Py.show_age()) # 28
在這裡，我們有一個_get_age非公共方法和一個show_age 公共方法。show_age可以通過我們的對象使用（在類之外），而_get_age只能在類定義中使用（在show_age方法中）。但同樣：這是一種慣例。
8.5.封裝總結
通過封裝，我們可以確保對象的內部表示從外部隱藏。
9.繼承：行為和特徵
某些對象有一些共同點：它們的行為和特徵。
例如，我從父親那裡繼承了一些特徵和行為。我繼承了他的眼睛和頭髮作為特徵，以及他作為行為的煩躁和內向。
在面向對象的編程中，類可以從另一個類繼承公共特徵（數據）和行為（方法）。
讓我們看看另一個例子，並在Python中實現它。
想象一輛車。車輪數量，座位數量和最大速度都是汽車的屬性。我們可以說電動Car類從常規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中，我們將父類作為參數應用於子類。電動Car類可以繼承我們的常規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的基礎知識：
- Python變量的工作原理
- Python條件語句如何工作
- Python循環語句（while＆for）如何工作
- 如何使用列表：集合| 數組
- 字典鍵值集合
- 我們如何迭代這些數據結構
- 對象和類
- 屬性作為對象的數據
- 方法作為對象的行為
- 使用Python getter和setter以及property decorator
- 封裝：隱藏信息
- 繼承：行為和特徵
您已經完成了這篇關於Python的基礎內容講解！希望這些可以對您起到一定的幫助作用！