-
取模運算意思就是判斷奇偶，取最后余數，余數為0是偶數，余數為1是奇數；用%表示取模
底板除的意思就是抹掉小數點后的數字，取整，用//表示
小數點位數用round（）表示
查看全部 -
合法變量名： num查看全部
-
變量不能用數字開頭；
變量名=數據
查看全部 -
整數就是數字1，2，3等等整數；
浮點數就是有小數點的數字，比如0.1，0.2，0.44等；
字符串指的就是文本文件一樣；
布爾值對應的就只有“對”或“錯”；真假
同時注意“與非或”邏輯運算；
查看全部 -
1，查找速度快
?
dict的第一個特點是查找速度快，無論dict有10個元素還是10萬個元素，查找速度都一樣。而list的查找速度隨著元素增加而逐漸下降。
?
不過dict的查找速度快不是沒有代價的，dict的缺點是占用內存大，還會浪費很多內容，list正好相反，占用內存小，但是查找速度慢。
?
?
2，有序與無序
?
在Python3.5之前，dict中的元素是無序的，也就是dict中元素的插入順序和打印順序未必一致
?
在Python3.6、Python3.7版本中，可以得到有序的結果。
?
?
3，key不可變
?
對于基礎數據類型，字符串、數字等，這些都是不可變的，可以作為dict的key，而對于復雜數據類型，經過前面的學習，我們知道tuple是不可變的，list是可變的，因此tuple可以作為dict的key，但是list不可以作為dict的key，否則將會報錯。
?
key = (1, 2, 3) # 以tuple作為key
d[key] = True
key = [1, 2, 3]
d[key] = True
# 報錯
?
?
?
注意：key不能重復——由于dict是按 key 查找，所以，在一個dict中，key不能重復。
?
?
?
4，Python遍歷dict
?
通過直接print(d)，我們打印出來的是完整的一個dict；有時候，我們需要把dict中滿足一定條件的元素打印出來，比如成績超過60的，在這種情況下，我們需要則需要遍歷dict（這種時候需要使用for循環），并通過條件判斷把滿足條件的打印出來。
?
遍歷dict有兩種方法——
①key的for循環，判斷value是否滿足輸出條件：遍歷dict的所有key，并通過key獲得對應的value
?
d = {
??? 'Alice': 45,
??? 'Bob': 60,
??? 'Candy': 75,
??? 'David': 86,
??? 'Ellena': 49
}
for key in d: ??????# 遍歷d的key
??? value = d[key]
??? if value > 60:
??????? print(key, value)
?
?
?
?
?
?
②key和value的for循環，采用items()方法調用：通過dict提供的 items() 方法，items()方法會返回dict中所有的元素，每個元素包含key和value。
?
d = {
??? 'Alice': 45,
??? 'Bob': 60,
??? 'Candy': 75,
??? 'David': 86,
??? 'Ellena': 49
}
for key,value in d.items():
??? if value > 60:
??????? print(key,value)
?
?
任務
同學的近三次成績如下，請把每個同學的每次成績依次輸出。
?
①
d = {'Alice': [50, 61, 66],
???? 'Bob': [80, 61, 66],
???? 'Candy': [88, 75, 90]}
?
for key in d:??? #每個key（同學）
??? scores=d[key]
??? i=1
??? for score in scores:??? #每個value（三次成績）
??????? print(key,i,score)????? #每次成績
??????? i+=1
?
運行成功
('Bob', 1, 80)
('Bob', 2, 61)
('Bob', 3, 66)
('Alice', 1, 50)
('Alice', 2, 61)
('Alice', 3, 66)
('Candy', 1, 88)
('Candy', 2, 75)
('Candy', 3, 90)
?
?
②
d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}
print(len(d))
?
運行成功
3
?
?
③
#coding=utf-8
d = {
???? 'Alice': [50, 61, 66],
???? 'Bob': [80, 61, 66],
???? 'Candy': [88, 75, 90]
}
?
template = "{}的第{}次的成績為{}"
?
for eachItem in d.items():? ?#eachItem是以列表形式保存，元素中間是以逗號“,”隔開的，例如['Bob',[80,61,66]]
??? print(eachItem)
?
?? ?for i in range(len(eachItem[1])):??? #i自動默認值為0 ——>等同于? for i in range(0,3):
??????? a=range(len(eachItem[1]))??? #計算eachItem列表中的，value值的位數（從0開始計算）
??????? print(a)
??????? print(template.format(eachItem[0], i + 1, eachItem[1][i]))
?
?
?
#coding=utf-8
d = {
???? 'Alice': [50, 61, 66],
???? 'Bob': [80, 61, 66],
???? 'Candy': [88, 75, 90]
}
?
template = "{}的第{}次的成績為{}"
?
for eachItem in d.items():
??? print(eachItem)
?
??? for i in range(len(eachItem[1])):??? #? 每一次循環后，i自動遞增1
??????? a=range(len(eachItem[1]))
??????? print(a)
??????? print(template.format(eachItem[0], i+1, eachItem[1][i]))??? #print中的i+1，對于i的值不構成影響，除了按照print打印出來，其余的無影響，不會保存為i的新值。
??????? print i
?
?
?
注意：
①for循環中的i默認遞增1——在python中，for i in range()語句下，i是自動遞增1，不需要使用i=i+1語句即可達到循環一次遞增1的效果。
?
②python中，i自動默認值為0：可以不需要對i進行賦值定義
?
③len(somethingname)：計算sonethingname這個數據類型的位置個數，從1開始計數 ——>
?
④Range(len(sonethingname))：定義len()的位置范圍，從0開始 ——>
?
?
?
?
?
?for i in len(eachItem[1]): 語法錯誤
?
for i in range(len(eachItem[1])): 語法正確
?查看全部 -
?
dict提供便捷的 pop() 方法，允許我們快速刪除元素，pop()方法需要指定需要刪除的元素的key，并返回對應的value。pop()方法的參數是dict中的key。
?
?
假設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}
?
?
當key不存在時，同樣會引起錯誤
?
?
任務
在dict中，使用keys()方法，可以返回dict的所有key，在刪除某個元素時，可以通過這個方法先判斷某個元素是否存在，請改造前面的程序，使得即使key不存在時，刪除也不會拋異常。
?
d = {????
??? 'Alice': 45,????
??? 'Bob': 60,????
??? 'Candy': 75,????
??? 'David': 86,????
??? 'Ellena': 49 }
name = 'Alice'
if name in d.keys():????
??? d.pop(name)
??? print(d)
else:????
??? print('{} not in d'.format(name))
?
?
?
?
?
?
查看全部 -
?
dict的更新方法：使用賦值語句，dictname[keyname]=new value
?
賦值語句其實有兩個功能：
1.當key不存在時，往dict中添加對應的key: value元素。
2.當key存在時，會更新dict，用新的value替換原來的value。
?
注意——
在使用賦值語句往dict中添加元素時，為了避免不必要的覆蓋問題，我們需要先判斷key是否存在，然后再做更新。
?
?
d = {
??? 'Alice': 45,
??? 'Bob': 60,
??? 'Candy': 75,
??? 'David': 86,
??? 'Ellena': 49
}
if 'Alice' in d:
??? ori_marks = d['Alice']
??? print('ori_marks:{}'.format(ori_marks))
??? d['Alice'] = 60
??? print('new_marks:{}'.format(d['Alice']))
else:
??? print('nothing to do')
?
?
?
?
查看全部 -
dict和tuple不一樣，dict是可變的，我們隨時可以往dict中添加新的key-value。
?
①使用賦值語句往里面添加key元素：d['new key']=new value
?
注意——value可以是任意類型的元素，可以是list、tuple等。d['new key']=[new value1,new value2] （list 類型），或者d['new key']=（new v1，new v2）（tuple類型）
?
?
?
比如對于上節課的成績dict：
d = {
??? 'Alice': 45,
??? 'Bob': 60,
??? 'Candy': 75,
??? 'David': 86,
??? 'Ellena': 49
}
?
需要往里面添加Dodo、Mimi的成績時，可以使用賦值語句往里面添加元素：
d['Mimi'] = 72
d['Dodo'] = 88
print(d)
?
假如Mimi近兩次成績分別是72，73，Dodo近兩次的成績分別是88，90，則可以使用賦值語句往dict中添加list元素。
d['Mimi'] = [72, 73]
d['Dodo'] = [88, 90]
print(d)
?
?
②使用append()語句往里面添加value元素：dictname[keyname].append('new value')
?
如果Mimi、Dodo的第三次成績也出來了，分別是75，90，則可以先通過key把對應的value查詢出來，然后再往類型是list的value中添加第三次的成績。
d['Mimi'].append(75)
d['Dodo'].append(90)
print(d)
?
?
?
?
任務
已有同學的某次成績dict如下：
?
d = {
??? 'Alice': [45],
??? 'Bob': [60],
??? 'Candy': [75],
}Alice、Bob、Candy的最近三次的成績分別是[50, 61, 66]，[80, 61, 66]，[88, 75, 90]，請更新dict，使得dict可以保存同學多次的成績。
?
代碼如下：
d = {
??? 'Alice': [45],
??? 'Bob': [60],
??? 'Candy': [75]
}?????? ???#原始dict數據組的數據
?
A=[[50, 61, 66],[80, 61, 66],[88, 75, 90]]?? ?#要新增加的數據，分別對應Alice、Bob、Candy
i=0
?
for key in d.keys():??? #追蹤到每個同學上，通過for循環進行by同學錄入成績
??? B=A[i]
? ??for grade in B: ????#通過for循環，將每個同學的三次成績，分次錄入增加，而不是三次一起錄入增加，可以避免輸出出現雙重[[]]
???? ???d[key].append(grade)
??? i+=1
???
print(d)
?
?
輸出結果：{'Bob': [60, 50, 61, 66], 'Alice': [45, 80, 61, 66], 'Candy': [75, 88, 75, 90]}
?
?
雙重[[]]——沒有將成績分次錄入
?
?
?
?
查看全部 -
?
創建dict數據組：可以創建一個dict，保存key和value的對應關系（名字和成績）。
?
讀取dict元素：
①下標[ ]讀取——dictname['key1']：直接讀取dictname數據組里面的key1，會返回所對應的value1
?
d = {
??? 'Alice': 45,
??? 'Bob': 60,
??? 'Candy': 75,
??? 'David': 86,
??? 'Ellena': 49,
??? 'Gaven': 86
}
print(d['Bob']) # ==> 60在dict中，當對應的key不存在時，也會引發錯誤。——>? 在需要通過key找到value時，一定要先判斷key存不存在。
?
②get函數調用讀?。篸ictname.get('key')，返回key所對應的value值。dict本身提供get方法，把key當作參數傳遞給get方法，就可以獲取對應的value。
當搜索的key不存在時，自動返回none，不會引發錯誤。
print(d.get('Alice')) # ==> 45
print(d.get('Dodo')) # ==> None
?
?
字典的名Key和值value可以自動從字典中獲取——
①key：調用keys()函數
for key in dictname.keys()
?
②value：調用value()函數
for key in dictname.keys()
?
d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}
for i in d.keys():
??? print(i)? ??#逐次打印出key名
for j in d.values():
??? print(j)??? #逐次打印出value值
?
?
?
任務
根據如下dict，打印出Alice, Bob, Candy, Mimi, David的成績，當同學不存在時，打印None。
?
# coding=utf-8
d = {
??? 'Alice': 45,
??? 'Bob': 60,
??? 'Candy': 75,
??? 'David': 86,
??? 'Ellena': 49
}
?
for i in d.keys():
? ??j=d.get(i)
??? print('{}同學的成績是{}'.format(i,j))
?
?
?
?
?
?
查看全部 -
?
List 和 tuple 可以用來表示順序集合，例如，班里同學的名字，或者考試的成績。
?
名字：
['Alice', 'Bob', 'Candy', 'David', 'Ellena'] # List
('Alice', 'Bob', 'Candy', 'David', 'Ellena') # tuple成績:
[45, 60, 75, 86, 49] # list
(45, 60, 75, 86, 49) # tuple?
?
①兩個列表之間的映射——如果同學名字的列表和同學成績的列表是一一對應的，那么通過下標，我們也可以找到每個同學的成績。
?
#coding=utf-8
?
names=['Alice', 'Bob', 'Candy', 'David', 'Ellena']
grades=[45, 60, 75, 86, 49]
i=0
?
for name in names:
? ??grade=grades[i]
??? i+=1
??? print('name={},grade={}'.format(name,grade))
?
?
映射的弊端：使用兩個list，始終有些麻煩的，尤其是需要變換一個列表的順序后，另外一個列表也需要做同樣的變換，否則就可能出現對應不上的問題。
?
?
?
②dict類型：專門保存兩者的映射——每一項包含一個key和一個value，key和value是一一對應的。
Eg. 用dict可以方便的保存“名字”->“成績”的映射。
?
dict用法：使用花括號 {} 表示這是一個dict，然后key和value之間使用冒號 : 分割，并且每一組 key:value 的最后，以逗號,表示這一組的結束。
?
d = {
??? 'Alice': 45,
??? 'Bob': 60,
??? 'Candy': 75,
??? 'David': 86,
??? 'Ellena': 49
}?
?
?
③空dict：先設置空dict，需要調用函數往里面添加數據
d = dict()
print(d) # ==> {}
?
?
注意：dict有序無序問題——
在Python3.5之前，dict中的元素是無序的，也就是dict中元素的插入順序和打印順序未必一致。
在Python3.6的版本以后，dict是有序的，但是一般而言，為了避免不必要的誤解，一般在需要有序的dict時，我們會使用一種叫做Ordereddict的字典，來確保有序。
?
?
dict的增加元素方法——d{'key1'}=value1
?
任務
新來的Gaven同學成績是86，請編寫一個dict，把Gaven同學的成績也加進去。
?
d = {
??? 'Alice': 45,
??? 'Bob': 60,
??? 'Candy': 75,
??? 'David': 86,
??? 'Ellena': 49
}
d['Gaven']=86
print(d)
?
?
?
?
查看全部 -
針對的是僅包含基礎數據類型（數字類型、布爾類型、字符串類型）的數據——對于tuple，它和list一個最大的不同點就是tuple是不可變的，tuple里面的元素，也是不可替換的。
對于組合數據類型——不受這個約束。
?
?
T = (1, 'CH', [3, 4])
這里T有三個元素，第一個元素是數字類型，第二個元素是字符串類型，第三個元素是列表類型的，我們嘗試修改第三個元素的數據。
?
程序：
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])
元組T中的第三個元素已經成功被改變了
?
指向性：T--T[2]--L--L[1]——因為雖然tuple中的list元素改變了，但是tuple本身指向的list仍然是同一個list，list本身并沒有改變，改變的只是list里面的一個元素，這是tuple所約束不到的范圍。
?
?
?
如果我們直接替換list，這也是不行的。
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
?
?
總結：
1，tuple只能夠管理到自己的元素不被改變，但是元素內的列表內的值變化不是受控制的。
2，對于組合數據類型數據，tuple依然可變
3，元組、列表的元素是復合數據類型的，將該元素對外復制時實際是將指向該數據的指針付給別的變量，當對別的變量做出修改時，原數據也會改變
?
?
?
?
查看全部 -
?
tuple和list一樣，可以包含 0 個、1個和任意多個元素。
?
①包含 0 個元素的 tuple：也就是空tuple，直接用()表示。
T = ()
print(T) # ==> ()
?
②創建包含一個元素的tuple：在單元素之后要加個逗號“，”
T = (1,)
print(T) # ==> (1,)
?
?
?
如果單元素之后沒有加逗號“，”，則會導致輸出內容沒有tuple的()括號符號——
原因：改變優先級我們是通過 () 來實現的，這和元組的定義有沖突。這就解釋了只有一個元素的元組，在不加逗號情況下，被默認為是四則運算優先符號()，運算后結果是1，打印出來得到一個數字的結果了
T = (1)
print(T) # ==> 1
?
?
③對于多個元素的tuple：則加和不加這個逗號，效果是一樣的
?
?
?
任務
tuple的元素也可以是tuple，請判斷以下定義T的元素中，有多少個tuple。
T = ((1+2),? ((1+2),), ('a'+'b'), (1, ), (1,2,3,4,5))
?
程序：
T = ((1+2),? ((1+2),), ('a'+'b'), (1, ), (1,2,3,4,5))
for i in T:
??? print(i)
根據輸出結果可以判斷有幾個tuple。（最后在加上整個的tuple，也就是T）
?
解釋：
(1+2)：相當于(3)，輸出是3，不是tuple。——>應該是(3,),反推也就是(1+2,)，是tuple
?((1+2),)：相當于(3,)，輸出(3,)
“a” + “b” = “ab”：("ab")不是元組，所以（"a"+"b"）不是元組，而（“ab”,）這個是元組
?
?
?
?
?
查看全部 -
Python的發展歷史
查看全部 -
由于tuple一旦定義之后便不可修改，所以在實際編程中，tuple經常用于存放固定不變的數據。
因此在使用上，tuple提供了便捷的方法可以訪問tuple中的數據。
?
①統計某元素個數——count()方法： tuplename.count(data number)
count()方法用來統計tuple中某個元素出現的次數。
對于不存在的元素，count方法不會報錯，而是返回0，這是合理的，因為元組里面有0個不存在的元素。
?
T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(1)) # ==> 3
print(T.count(5)) # ==> 1print(T.count(10)) # ==> 0
?
②統計指定元素下標——index()方法：tuplename.index(data number)
index()方法可以返回指定元素的下標，當一個元素多次重復出現時，則返回第一次出現的下標位置。
對于不存在的元素，使用index()方法Python會報錯。
?
T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(1) # ==> 0 # 多次出現，返回第一次出現的位置?
?
?
?
?
?
查看全部 -
元組(tuple)：和list一樣，也是一個有序容器。在元組中，同樣可以包含0個或者多個元素，并且也支持索引訪問、切片等操作。
?
定義元組的方式：是使用小括號 ( ) 將元組內的元素括起來。
用法：
①定義：tuplename=(a,b,c,d)
②索引訪問：T[ num ]
③切片訪問：T[num1 : num2]
?
?
T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
# 通過下標的方式訪問元素
print(T[0]) # ==> Alice
print(T[4]) # ==> Ellena
# 切片
print(T[1:3]) # ==> ('Bob', 'Candy')?
?
?
非元組容器轉換為元組——元組數據類型可以把不是元組的容器轉換為元組，比如將列表轉換成元組。如：T=tuple(listname)
元組轉換為非元組——對于列表數據類型，也可以把元組轉換成列表。如：L=list(tuplename)
?
?
T=(0,1,2,3,4,5,6,7,8,9)
print(T)
L=list(T)??? #把tuple類型的T數據，轉換為list類型的數據
print(L)
?
?
?
?
【非常重要！】元組(tuple)的特性：tuple是固定不變的，在運行上tuple的性能是list的數倍。
?
?
tuple和list的差異——tuple是固定不變的，一旦變成tuple，tuple中的每一個元素都不可被改變，同時也不能再往tuple中添加數據，而list是可以增/減/替換。
?
?
?
?
?
查看全部
舉報