算術運算符

算術運算

• + 加
• - 減
• * 乘
• / 除
• % 取余（相除后的余數）
• ** 取冪（注意 ^ 并不執行該運算，你可能在其他語言中見過這種情形）
• // 相除后向下取整到最接近的整數

關于按位運算符的更多信息請參閱此處。Python 也遵守一般的數學運算順序。

賦值運算符

Python 最佳做法

要了解所有的最佳做法，請參閱 PEP8 指南。

你可以使用 atom 軟件包 linter-python-pep8 在 Atom 文本編輯器中自己的編程環境中使用 pep8，稍后我們會詳細講解這方面的知識。如果你不熟悉文本編輯器，并且在課堂上完成了所有編程任務，暫時就不用擔心這一點。

請遵守以下指南，使其他程序員和你自己日后能輕松地讀懂這些代碼！

正確

print(4 + 5)

錯誤

print(                       4 + 5)

每行代碼應該不超過 80 個字符，雖然在某些使用情況下，99 個字符也可以。此規則是由 IBM 制定的。

這些慣例為何很重要？雖然代碼格式不會影響到運行效果，但是遵守標準樣式指南使代碼更容易閱讀，并且在團隊內的不同開發者之間保持一致。

布爾型運算符、比較運算符和邏輯運算符

布爾數據類型存儲的是值 True 或 False，通常分別表示為 1 或 0。

通常有 6 個比較運算符會獲得布爾值：

比較運算符

你需要熟悉三個邏輯運算符：

要詳細了解 George Bool 如何改變了這個世界，請參閱這篇文章！

字符串
在 python 中，字符串的變量類型顯示為 str。你可以使用雙引號 " 或單引號 ' 定義字符串。如果你要創建的字符串包含其中一種引號，你需要確保代碼不會出錯。

my_string = 'this is a string!'
my_string2 = "this is also a string!!!"

你還可以在字符串中使用 \，以包含其中一種引號：

 this_string = 'Simon\'s skateboard is in the garage.'
 print(this_string)
Simon's skateboard is in the garage.

如果不使用 \，注意我們遇到了以下錯誤：

 this_string = 'Simon's skateboard is in the garage.'
 File "<ipython-input-20-e80562c2a290>", line 1
 this_string = 'Simon's skateboard is in the garage.'                       
 SyntaxError: invalid syntax

顏色高亮部分也表示第二種情形中的字符串有什么錯誤。你還可以對字符串執行其他多種操作。在此視頻中，你看到了一些操作：

first_word = 'Hello'
second_word = 'There'
print(first_word + second_word)

# 打印結果 HelloThere

print(first_word + ' ' + second_word)

# 打印結果 Hello There

print(first_word * 5)

# 打印結果 HelloHelloHelloHelloHello

print(len(first_word))
# 打印結果 5

與你到目前為止見到的其他數據類型不同，你還可以使用字符串索引，稍后我們將詳細講解！暫時先看下面這個小示例。注意，Python 索引以 0 開始——稍后，我們將在這節課詳細講解。

 first_word[0]
 H
 first_word[1]
 e

類型和類型轉換

你到目前為止，已經見過四種數據類型：

整型
浮點型
布爾型
字符串
你在之前的視頻中，簡單了解了 type()，它可以用來檢查你所處理的任何變量的數據類型。

 print(type(4))
 int
 print(type(3.7))
 float
 print(type('this'))
 str
 print(type(True))
 bool

字符串方法

方法就像某些你已經見過的函數：

• len("this")
• type(12)
• print("Hello world")

上述三項都是函數。注意，它們使用了小括號并接受一個參數。

type 和 print 函數可以接收字符串、浮點型、整型和很多其他數據類型的參數，函數 len 也可以接受多種不同數據類型的參數，稍后你將在這節課中詳細了解。

python 中的方法和函數相似，但是它針對的是你已經創建的變量。方法特定于存儲在特定變量中的數據類型。

下圖顯示了任何字符串都可以使用的方法。

每個方法都接受字符串本身作為該方法的第一個參數。但是，它們還可以接收其他參數。我們來看看幾個示例的輸出。

>>> my_string.islower()
True
>>> my_string.count('a')
2
>>> my_string.find('a')
3

可以看出，count 和 find 方法都接受另一個參數。但是，islower 方法不接受參數。如果我們要在變量中存儲浮點數、整數或其他類型的數據，可用的方法可能完全不同！

任何專業人士都無法記住所有方法，因此知道如何通過文檔查詢答案非常重要。掌握扎實的編程基礎使你能夠利用這些基礎知識查詢文檔，并且構建的程序比死記硬背所有 python 可用函數的人士構建的程序強大得多。

列表

你在本視頻中發現，你可以使用方括號創建列表。列表可以包含我們到目前為止所學的任何數據類型并且可以混合到一起。

lst_of_random_things = [1, 3.4, 'a string', True]

這是一個包含 4 個元素的類別。在 python 中，所有有序容器（例如列表）的起始索引都是 0。因此，要從上述列表中獲取第一個值，我們可以編寫以下代碼：

>>> lst_of_random_things[0]
1

似乎你可以使用以下代碼獲取最后一個元素，但實際上不可行：

>>> lst_of_random_things[len(lst_of_random_things)] 
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-34-f88b03e5c60e> in <module>()
----> 1 list[len(list)]
IndexError: list index out of range

但是，你可以通過使索引減一獲取最后一個元素。因此，你可以執行以下操作：

>>> lst_of_random_things[len(lst_of_random_things) - 1] 
True

此外，你可以使用負數從列表的末尾開始編制索引，其中 -1 表示最后一個元素，-2 表示倒數第二個元素，等等。

>>> lst_of_random_things[-1] 
True
>>> lst_of_random_things[-2] 
a string

列表切片

你發現，我們可以使用切片功能從列表中提取多個值。在使用切片功能時，務必注意，下限索引包含在內，上限索引排除在外。

>>> lst_of_random_things = [1, 3.4, 'a string', True]
>>> lst_of_random_things[1:2]
[3.4]

僅返回列表中的 3.4。注意，這與單個元素索引依然不同，因為你通過這種索引獲得了一個列表。冒號表示從冒號左側的起始值開始，到右側的元素（不含）結束。

如果你要從列表的開頭開始，也可以省略起始值。

>>> lst_of_random_things[:2]
[1, 3.4]

或者你要返回到列表結尾的所有值，可以忽略最后一個元素。

>>> lst_of_random_things[1:]
[3.4, 'a string', True]

這種索引和字符串索引完全一樣，返回的值將是字符串。

在列表里還是不在列表里？
你發現，我們還可以使用 in 和 not in 返回一個布爾值，表示某個元素是否存在于列表中，或者某個字符串是否為另一個字符串的子字符串。

>>> 'this' in 'this is a string'
True
>>> 'in' in 'this is a string'
True
>>> 'isa' in 'this is a string'
False
>>> 5 not in [1, 2, 3, 4, 6]
True
>>> 5 in [1, 2, 3, 4, 6]
False

列表可變性和順序

可變性是指對象創建完畢后，我們是否可以更改該對象。如果對象（例如列表或字符串）可以更改，則是可變的。但是，如果無法更改對象以創建全新的對象（例如字符串），則該對象是不可變的。

>>> my_lst = [1, 2, 3, 4, 5]
>>> my_lst[0] = 'one'
>>> print(my_lst)
['one', 2, 3, 4, 5]

正如上述代碼所顯示的，你可以將上述列表中的 1 替換為 'one。這是因為，列表是可變的。

但是，以下代碼不可行：

>>> greeting = "Hello there"
>>> greeting[0] = 'M'

這是因為，字符串是不可變的。意味著如果要更改該字符串，你需要創建一個全新的字符串。

對于你要使用的每種數據類型，你都需要注意兩個事項：

• 可變嗎？
• 有序嗎？

字符串和列表都是有序的。但是，你將在后續部分看到某些數據類型是無序的。對于接下來要遇到的每種數據類型，有必要理解如何設定索引，可變嗎，有序嗎。了解數據結構的這些信息很有用！

此外，你將發現每種數據類型有不同的方法，因此為何使用一種數據類型（而不是另一種）在很大程度上取決于這些特性，以及如何輕松地利用這些特性！

實用的列表函數（第二部分）

join 方法

Join 是一個字符串方法，將字符串列表作為參數，并返回一個由列表元素組成并由分隔符字符串分隔的字符串。

new_str = "\n".join(["fore", "aft", "starboard", "port"])
print(new_str)
輸出:

fore
aft
starboard
port

在此示例中，我們使用字符串 "\n" 作為分隔符，以便每個元素之間都有一個換行符。我們還可以在 .join 中使用其他字符串作為分隔符。以下代碼使用的是連字符。

name = "-".join(["García", "O'Kelly"])
print(name)
輸出:

García-O'Kelly

請務必注意，用英文逗號 (,) 將要連接的列表中的每項分隔開來。忘記分隔的話，不會觸發錯誤，但是會產生意外的結果。

append 方法

實用方法 append 會將元素添加到列表末尾。

letters = ['a', 'b', 'c', 'd']
letters.append('z')
print(letters)
輸出:

['a', 'b', 'c', 'd', 'z']

元組

元組是另一個實用容器。它是一種不可變有序元素數據類型。通常用來存儲相關的信息。請看看下面這個關于緯度和經度的示例：

location = (13.4125, 103.866667)
print("Latitude:", location[0])
print("Longitude:", location[1])

元組和列表相似，它們都存儲一個有序的對象集合，并且可以通過索引訪問這些對象。但是與列表不同的是，元組不可變，你無法向元組中添加項目或從中刪除項目，或者直接對元組排序。

元組還可以用來以緊湊的方式為多個變量賦值。

dimensions = 52, 40, 100
length, width, height = dimensions
print("The dimensions are {} x {} x {}".format(length, width, height))

在定義元組時，小括號是可選的，如果小括號并沒有對解釋代碼有影響，程序員經常會忽略小括號。

在第二行，我們根據元組 dimensions 的內容為三個變量賦了值。這叫做元組解包。你可以通過元組解包將元組中的信息賦值給多個變量，而不用逐個訪問這些信息，并創建多個賦值語句。

如果我們不需要直接使用 dimensions，可以將這兩行代碼簡寫為一行，一次性為三個變量賦值！

length, width, height = 52, 40, 100
print("The dimensions are {} x {} x {}".format(length, width, height))

集合

集合是一個包含唯一元素的可變無序集合數據類型。集合的一個用途是快速刪除列表中的重復項。

numbers = [1, 2, 6, 3, 1, 1, 6]
unique_nums = set(numbers)
print(unique_nums)
輸出為：

{1, 2, 3, 6}

集合和列表一樣支持 in 運算符。和列表相似，你可以使用 add 方法將元素添加到集合中，并使用 pop 方法刪除元素。但是，當你從集合中拿出元素時，會隨機刪除一個元素。注意和列表不同，集合是無序的，因此沒有“最后一個元素”。

fruit = {"apple", "banana", "orange", "grapefruit"}  # define a set

print("watermelon" in fruit)  # check for element

fruit.add("watermelon")  # add an element
print(fruit)

print(fruit.pop())  # remove a random element
print(fruit)
輸出結果為：

False
{'grapefruit', 'orange', 'watermelon', 'banana', 'apple'}
grapefruit
{'orange', 'watermelon', 'banana', 'apple'}

你可以對集合執行的其他操作包括可以對數學集合執行的操作。可以對集合輕松地執行 union、intersection 和 difference 等方法，并且與其他容器相比，速度快了很多。

字典和恒等運算符

字典

字典是可變數據類型，其中存儲的是唯一鍵到值的映射。下面是存儲元素和相應原子序數的字典。

elements = {"hydrogen": 1, "helium": 2, "carbon": 6}

字典的鍵可以是任何不可變類型，例如整數或元組，而不僅僅是字符串。甚至每個鍵都不一定要是相同的類型！我們可以使用方括號并在括號里放入鍵，查詢字典中的值或向字典中插入新值。

print(elements["helium"])  # print the value mapped to "helium"
elements["lithium"] = 3  # insert "lithium" with a value of 3 into the dictionary

我們可以像檢查某個值是否在列表或集合中一樣，使用關鍵字 in 檢查值是否在字典中。字典有一個也很有用的相關方法，叫做 get。get 會在字典中查詢值，但是和方括號不同，如果沒有找到鍵，get 會返回 None（或者你所選的默認值）。

print("carbon" in elements)
print(elements.get("dilithium"))
輸出結果為：

True
None

Carbon 位于該字典中，因此輸出 True。Dilithium 不在字典中，因此 get 返回 None，然后系統輸出 None。如果你預計查詢有時候會失敗，get 可能比普通的方括號查詢更合適，因為錯誤可能會使程序崩潰。

恒等運算符

關鍵字 運算符
is 檢查兩邊是否恒等
is not 檢查兩邊是否不恒等
你可以使用運算符 is 檢查某個鍵是否返回了 None。或者使用 is not 檢查是否沒有返回 None。

n = elements.get("dilithium")
print(n is None)
print(n is not None)
會輸出：

True
False

復合數據結構

我們可以在其他容器中包含容器，以創建復合數據結構。例如，下面的字典將鍵映射到也是字典的值！

elements = {"hydrogen": {"number": 1,
                         "weight": 1.00794,
                         "symbol": "H"},
              "helium": {"number": 2,
                         "weight": 4.002602,
                         "symbol": "He"}}
我們可以如下所示地訪問這個嵌套字典中的元素。

helium = elements["helium"]  # get the helium dictionary
hydrogen_weight = elements["hydrogen"]["weight"]  # get hydrogen's weight