算術運算符

算術運算

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

備注: 可以使用 科學記數法來定義很大的數字。4.445e8 等于 4.445 * 10 ** 8，也就是 444500000.0。

?

變量I

mv_population = 74728
mv_population 是變量，負責存儲 74728 的值。該表達式將右側的項目賦值給左側的名稱，實際上和數學等式有所不同，因為74728 不存儲 mv_population 的值。

在任何情況下，無論左側項是什么，在賦值后，都是右側值的變量名稱。一旦將變量值賦值給變量名稱，你便可以通過該名稱訪問這個值。

更改變量
更改變量會如何影響到用該變量定義的另一個變量？我們來看一個示例。

這是關于山景城人口和人口密度的原始數據。

>>> mv_population = 74728
>>> mv_area = 11.995
>>> mv_density = mv_population/mv_area

現在我們重新定義 mv_population 變量：

（注意：后續代碼跟在上面三行代碼后面，而非重新開始）

>>> mv_population = 75000

??思考一下上方的代碼，下面的表達式輸出會是什么？

>>> print(int(mv_density))    

?
??正確答案是 int(mv_density)的值沒有變化。它依然是 6229。

因為當變量被賦值時，賦給了右側的表達式的值，而不是表達式本身。在下面的行中：

>>> mv_density = mv_population/mv_area

Python 實際上計算了右側表達式 mv_population/mv_area 的結果，然后將變量 mv_density 賦為該表達式的值。它立即忘記該公式，僅將結果保存到變量中。

考慮到 mv_population 的變化，為了更新 mv_density 的值。我們需要再次運行下面這行：

>>> mv_density = mv_population/mv_area
>>> print(int(mv_density))    
6252

?

變量II

以下兩個表達式在賦值方面是對等的：

x = 3
y = 4
z = 5

以及

x, y, z = 3, 4, 5

但是，在大多數情況下，上面的表達式并不是很好的賦值方式，因為變量名稱應該要能夠描述所存儲的值。

除了要設定具有描述性的變量名稱之外，在 Python 中命名變量時，還需要注意以下幾個事項：

1. 只能在變量名稱中使用常規字母、數字和下劃線。不能包含空格，并且需要以字母或下劃線開頭。

2. 不能使用保留字或內置標識符，它們在 Python 中具有重要含義，你將在整個這門課程中學到這些知識。python 保留字列表請參閱此處。創建對值清晰描述的名稱可以幫助你避免使用這些保留字。下面是這些保留字的簡要表格。

image.png

3. 在 python 中，變量名稱的命名方式是全部使用小寫字母，并用下劃線區分單詞。

正確

my_height = 58
my_lat = 40
my_long = 105

錯誤

my height = 58
MYLONG = 40
MyLat = 105

雖然最后兩個在 python 中可以運行，但是它們并不是在 python 中命名變量的推薦方式。我們命名變量的方式稱之為snake case，因為我們用下劃線連接單詞。
?

賦值運算符

還可以按照類似的方式使用 *=，但是與下方所示的運算符相比不太常見。

image.png

?
?

整數和浮點數

數字值可以用到兩種 python 數據類型：

• int - 表示整數值
• float - 表示小數或浮點數值

通過以下語法創建具有某個數據類型的值：

x = int(4.7)   # x is now an integer 4
y = float(4)   # y is now a float of 4.0

使用函數 type 檢查數據類型：

>>> print(type(x))
int
>>> print(type(y))
float

因為 0.1 的浮點數（或近似值）實際上比 0.1 稍微大些，當我們將好幾個這樣的值相加時，可以看出在數學上正確的答案與 Python 生成的答案之間有區別。

>>> print(.1 + .1 + .1 == .3)
False

?

PEP8 指南

• 示例1:

正確

print(4 + 5)

錯誤

print(                       4 + 5)

?

• 示例2:

正確

  print(3 * 7)  

錯誤

  print( 3 * 7 )

?

• 示例3:

正確

print(3*7 - 1)

錯誤

print(3 * 7 - 1) 

如何遵守標準樣式指南使代碼更容易閱讀，并且在團隊內的不同開發者之間保持一致。要了解所有的最佳做法，請參閱 PEP8 指南

異常

異常是代碼運行時發生的問題，而語法錯誤是 Python 在運行代碼之前檢查代碼時發現的問題。要了解詳情，請參閱關于錯誤和異常的 Python 教程頁面。

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

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

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

比較運算符

邏輯運算符

?
?

字符串

定義字符串

在 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

?

類型和類型轉換

四種數據類型：

1.整型
2.浮點型
3.布爾型
4.字符串

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

可以更改變量類型以執行各種不同的操作。例如

# ex1
In [1]: "0" + "5"
Out[1]: '05'
# ex2
In [2]: 0 + 5
Out[2]: 5

# ex3
In [3]: "0" + 5
---->  "0" + 5
TypeError: must be str, not int

因此要讓ex3正確執行, 需要將字符0轉換為整型

#ex3
In [3]: int("0") + 5
Out[3]: 5

同理, 對于數字也可以通過str()進行轉換, 來執行字符串操作.

?

字符串方法

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

1.len("this")
2.type(12)
3.print("Hello world")
上述三項都是函數。注意，它們使用了小括號并接受一個參數。

type 和print 函數可以接收字符串、浮點型、整型和很多其他數據類型的參數，函數 len 也可以接受多種不同數據類型的參數

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

image.png

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

>>> my_string = 'rick sanchez'
>>> my_string.islower()
True
>>> my_string.count('a')
1
>>> my_string.find('a')
6
>>> my_string.split()
['rick', 'sanchez']

其他方法

string.replace('old_char','new_char')`
string.capitalize() #一句話中第一個字母大寫

要詳細了解字符串和字符串方法，請參閱字符串方法文檔。

?
?

列表

創建列表

使用方括號創建列表。列表可以包含任何數據類型并且可以混合到一起。

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'

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

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

• 可變嗎？
• 有序嗎？

字符串和列表都是有序的。
?

列表方法

• len()返回列表中的元素數量。
• max() 返回列表中的最大元素。最大元素的判斷依據是列表中的對象類型。
  數字列表中的最大元素是最大的數字。
  字符串列表中的最大元素是按照字母順序排序時排在最后一位的元素。
  因為 max() 函數的定義依據是大于比較運算符。如果列表包含不同的無法比較類型的元素，則 max() 的結果是 undefined。
• min() 返回列表中的最小元素。它是 max() 函數的對立面，返回列表中的最小元素。
• sorted() 返回一個從最小到最大排序的列表副本，并使原始列表保持不變。

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)
length, width, height = 52, 40, 100

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

元組索引

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

元組解包

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

可變性&有序性總結

image.png

?

集合

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

?

定義集合

#method 1
numbers = [1, 2, 6, 3, 1, 1, 6]
unique_nums = set(numbers)

#method 2
fruit = {"apple", "banana", "orange", "grapefruit"} 

?

集合方法

集合和列表一樣支持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 會返回 None（或者你所選的默認值）。

print("carbon" in elements)
print(elements.get("dilithium"))

輸出結果為：

True
None

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

?

插入新值

使用方括號并在括號里放入鍵, 對其進行賦值.

week = {}
week['Monday'] = 1

刪除值

del(week['Monday'] )

?

恒等運算符

你可以使用運算符 is 檢查某個鍵是否返回了 None。或者使用 is not 檢查是否沒有返回 None。

n = elements.get("dilithium")
print(n is None)
print(n is not None)

會輸出：

True
False

思考: 以下代碼的輸出是什么？

a = [1, 2, 3]
b = a
c = [1, 2, 3]

print(a == b)
print(a is b)
print(a == c)
print(a is c)

結果應該為:

True
True
True
False

解析: 列表 a 和列表 b 是對等和相同的。列表 c 等同于 a（因此等同于 b），因為它們具有相同的內容。但是 a 和 c（同樣 b 也是）指向兩個不同的對象，即它們不是相同的對象。這就是檢查是否相等與恒等的區別。

復合數據結構

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

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

練習

image.png

image.png

image.png