亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

# 指定順序
template = 'Hello {0}, Hello {1}, Hello {2}, Hello {3}.'
result = template.format('World', 'China', 'Beijing', 'imooc')
print(result) # ==> Hello World, Hello China, Hello Beijing, Hello imooc.
# 調整順序
template = 'Hello {3}, Hello {2}, Hello {1}, Hello {0}.'
result = template.format('World', 'China', 'Beijing', 'imooc')
print(result) # ==> Hello imooc, Hello Beijing, Hello China, Hello World.

# 字符串模板
template = 'Hello {}'
# 模板數據內容
world = 'World'
result = template.format(world)
print(result) # ==> Hello World

round(a,b)函數有兩個傳參，第一個a是指需要保留小數的數值，第二個b指保留小數點后幾位

地板除//取的是整數部分，舍棄小數部分

取模運算可以判斷一個數是偶數還是奇數，如果取模運算的結果是0，那么是偶數，否則為奇數

右邊的值賦給等號左邊??那么左邊就是變量，變量可以是不同的數據類型，因為python 是動態語言

0和none的含義不一樣

二進制數只使用數字0、1表示，在Python中，二進制整數使用前綴0b表示，比如：0b0110，0b1100。

十六進制數除了0~9十個數字以外，還使用a、b、c、d、e、f，在Python中，十六進制使用前綴0x，比如：0x12ef，0xde2431af。

0b

0x

把10用e替代,比如：1.23x10^9就是1.23e9，或者12.3e8，0.000012可以寫成1.2e-5

dict提供便捷的pop()方法，允許我們快速刪除元素，pop()方法需要指定需要刪除的元素的key，并返回對應的value。
假設Alice轉校了，需要把Alice的成績刪除，可以這樣寫：

d = {
? ?'Alice': 45,
? ?'Bob': 60,
? ?'Candy': 75,
? ?'David': 86,
? ?'Ellena': 49
}
print(d) # ==> {'Alice': 45, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49}
alice_score= d.pop('Alice')
print(alice_score) # ==> 45
print(d) # ==> {'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49}

需要注意的是，pop()方法的參數是dict中的key，當key不存在時，同樣會引起錯誤。比如在上述操作中，已經把Alice的成績刪除了，假如再次pop('Alice')，將會引發錯誤。

d.pop('Alice')
# 報錯
Traceback (most recent call last):
?File "<stdin>", line 1, in <module>
KeyError: 'Alice'

通過賦值語句就可以把元素添加到dict中去，但是賦值的時候，我們并不確定key是否已經在dict里面了，如果dict里面已經有對應的key了，那將會發生什么呢？

d = {
? ?'Alice': 45,
? ?'Bob': 60,
? ?'Candy': 75,
? ?'David': 86,
? ?'Ellena': 49
}
d['Bob'] = 75
print(d)
# ==> {'Alice': 45, 'Bob': 75, 'Candy': 75, 'David': 86, 'Ellena': 49}

這個時候我們發現，原來Bob的成績是60，現在變成75了，因為d['Bob'] = 75的緣故。
因此我們發現這個賦值語句其實有兩個功能：

當key不存在時，往dict中添加對應的key: value元素。

當key存在時，會更新dict，用新的value替換原來的value。

因此，在使用賦值語句往dict中添加元素時，為了避免不必要的覆蓋問題，我們需要先判斷key是否存在，然后再做更新。

dict和tuple不一樣，dict是可變的，我們隨時可以往dict中添加新的key-value，比如對于上節課的成績dict：

d = {
? ?'Alice': 45,
? ?'Bob': 60,
? ?'Candy': 75,
? ?'David': 86,
? ?'Ellena': 49
}

需要往里面添加Dodo、Mimi的成績時，可以使用賦值語句往里面添加元素：

d['Mimi'] = 72
d['Dodo'] = 88
print(d)

實際上，value可以是任意類型的元素，可以是list、tuple等，假如Mimi近兩次成績分別是72，73，Dodo近兩次的成績分別是88，90，則可以使用賦值語句往dict中添加list元素。

d['Mimi'] = [72, 73]
d['Dodo'] = [88, 90]
print(d)

此后，如果Mimi、Dodo的第三次成績也出來了，分別是75，90，則可以先通過key把對應的value查詢出來，然后再往類型是list的value中添加第三次的成績。

d['Mimi'].append(75)
d['Dodo'].append(90)
print(d)

dict提供通過key找到對應value的功能，通過d[key]的形式，就可以得到對應的value。

d = {
? ?'Alice': 45,
? ?'Bob': 60,
? ?'Candy': 75,
? ?'David': 86,
? ?'Ellena': 49,
? ?'Gaven': 86
}
print(d['Bob']) # ==> 60
print(d['Alice']) # ==> 45

這和list通過下標找到對應位置的元素是類似的。

在dict中，也是一樣的，當對應的key不存在時，也會引發錯誤。

d = {
? ?'Alice': 45,
? ?'Bob': 60,
? ?'Candy': 75,
? ?'David': 86,
? ?'Ellena': 49,
? ?'Gaven': 86
}
print(d['Dodo'])
# 拋出異常
Traceback (most recent call last):
?File "<stdin>", line 1, in <module>
KeyError: 'Dodo'

if 'Alice' in d:
? ?print(d['Alice']) # ==> 45
if 'Dodo' in d: # Dodo不存在，所以不會走下面的邏輯
? ?print(d['Dodo'])

除了使用這種方法，還有一種方法可以通過key來獲取對應的value，這種方法不會引起錯誤，dict本身提供get方法，把key當作參數傳遞給get方法，就可以獲取對應的value，當key不存在時，也不會報錯，而是返回None。

print(d.get('Alice')) # ==> 45
print(d.get('Dodo')) # ==> None

因為通過get方法在代碼實現上更加簡單，且不會引起錯誤，因此更加推薦使用get方法來獲取dict的元素。

在dict中，每一項包含一個key和一個value，key和value是一一對應的，在解決上面的問題中，我們可以使用名字作為key，成績作為value，那么dict的定義如下：

d = {
? ?'Alice': 45,
? ?'Bob': 60,
? ?'Candy': 75,
? ?'David': 86,
? ?'Ellena': 49
}

在定義里，我們使用花括號{}表示這是一個dict，然后key和value之間使用冒號:分割，并且每一組key:value的最后，以逗號,表示這一組的結束。
我們也可以使用以下的方式定義一個dict。

d = dict()
print(d) # ==> {}

不過這種定義方式，默認得到的是一個空dict，需要調用函數往里面添加數據，我們后面會繼續學習。

tuple的元素也可以是tuple，請判斷以下定義T的元素中，有多少個tuple。

T = ((1+2), ?((1+2),), ('a'+'b'), (1, ), (1,2,3,4,5))

參考答案：

3個
第一個元素(1+2)，第三個元素('a'+'b')，計算的結果分別是數字3和字符串ab，不是tuple。

對于tuple，它和list一個最大的不同點就是tuple是不可變的，tuple里面的元素，也是不可替換的。但是這針對的是僅包含基礎數據類型（數字類型、布爾類型、字符串類型）的數據，對于組合數據類型，則不受這個約束。

T = (1, 'CH', [3, 4])

--------

T = (1, 'CH', [3, 4])
L = T[2]
print(L) # ==> [3, 4]
# 嘗試替換L中的元素
L[1] = 40
print(L) # ==> [3, 40]
print(T) # ==> (1, 'CH', [3, 40])

這是因為雖然tuple中的list元素改變了，但是tuple本身指向的list仍然是同一個list，list本身并沒有改變，改變的只是list里面的一個元素，這是tuple所約束不到的范圍。

T = (1, 'CH', [3, 4])
L2 = [3, 40]
# 嘗試替換tuple中的list
T[2] = L2
# 報錯
Traceback (most recent call last):
? File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

如果我們直接替換list，這也是不行的。