Python字典和集合
1.什麼是字典
- Python內置的數據結構之一，與列表一樣是一個可變序列
- 以鍵值對的方式存儲數據，字典是一個無序的序列
- 在存儲數據時要經過hash(key)的計算，計算的結果就是存儲的位置，因此字典的鍵值對順序並不是按照存儲時的先後順序決定的，而是經過計算得到的存儲位置。
- 字典中的鍵必須時不可變序列，否則當鍵改變時，hash計算的結果就會發生變化，導致存儲位置發生變化。因此鍵必須要使用不可變序列
- 字典的實現原理
- 與查新華字典類似，差字典是先根據部首或者拼音查找相應的頁碼，Python中的字典是根據 key去查找value的所在位置
2.字典的創建方式
#字典創建的兩種方式 #第一種，使用花括弧 dict_1 = {'num':'20210101','name':'Liming','sex':'male'} print(dict_1) #第二種，使用內置函數dict() # 2.1 通過其他字典創建 dict_2 = dict(dict_1) print(dict_2) print(dict_2 is dict_2) # True # 2.2 通過關鍵字參數創建 dict_3 = dict(num = "20210101",name = "Liming",sex = 'male') print(dict_3) print(dict_1 == dict_3) #True print(dict_1 is dict_3) #False # 2.3 通過鍵值對的序列創建 dict_4 = dict([('num',"20210101"),('name',"Liming"),('sex',"male")]) print(dict_3) #2.4 通過dict和zip結合創建 dict_5 = dict(zip(['num','name','sex'],['20210101','Liming','male'])) print(dict_5) if dict_1 == dict_2 == dict_3 == dict_4 == dict_5: #判斷字典的值是否相同 print("創建字典的5種方式相同") else: print("創建字典的5種方式不同")
- 字典種的鍵是唯一的，創建字典時若出現「鍵」相同的情況，則後定義的「鍵-值」對將覆蓋先定義的「鍵-值」對。
x = {'a':1,'b':2,"b":3}
print(x)
#運行結果
{'a': 1, 'b': 3}
- fromkeys()方法創建字典：當所有的鍵對應同一個值的時候，可以使用fromkeys創建字典
- dict.fromkeys(seq[,value])：
- seq:為字典「鍵」的值列表
- value：為設置鍵序列(seq)的值，省略時默認為None
dict_1 = dict.fromkeys(['zhangsan','wangwu']) print(dict_1) dict_2 = dict.fromkeys(['zhang_san','wang_wu'],18) print(dict_2) dict_3 = dict.fromkeys(['zhang_san','wang_wu'],b) print(dict_3) #從下面四行程式碼可以看出，當他們值為可變序列並且引用地址相同時，類似於淺copy dict_3['wang_wu'].pop() print(dict_3) dict_3['wang_wu'].append(10) print(dict_3) #運行結果 {'zhangsan': None, 'wangwu': None} {'zhang_san': 18, 'wang_wu': 18} {'zhang_san': [18], 'wang_wu': [18]} {'zhang_san': [], 'wang_wu': []} {'zhang_san': [10], 'wang_wu': [10]}
3.字典的訪問
a.根據鍵訪問值
- 字典中每個元素表示一種映射關係，將提供的「鍵『作為下標可以訪問對應的值
- 如果字典中不存在這個」鍵「，則會拋出異常
#根據鍵訪問值 dict_1 = {"name":"張飛","age":18,"sex":"male"} print(dict_1["name"]) print(dict_1["sex"]) #print(dict_1["x"]) 指定的鍵不存在，拋出異常
b.使用get（）方法訪問值
- 在訪問字典時，若不確定字典中是否由某個鍵，可通過get（）方法進行獲取。
- 若該鍵存在，則返回對應的值
- 若該鍵不存在，則返回默認值
- 語法格式
- dict.get([key[,default = None])
- key:要查找的鍵
- default：默認值，默認為None，可自行設置需要輸出的默認值。如果指定的鍵不存在，則返回默認值，當default為空時，返回None
#使用get()方法訪問值 dict_1 = {"name":"張飛","age":18,"sex":"male"} print(dict_1.get("name")) print(dict_1.get("x")) #返回None print(dict_1.get("x",18)) #當鍵不存在時，輸出設置的默認值，並不會把鍵x存入dect_1 print(dict_1.get("age",19)) #當鍵存在時，輸出age原本的值
4.in 和 not in 在字典中的使用
- 判斷鍵是否在字典中
#in和not in在字典中的使用：判斷鍵是否在字典中 dict_1 = {"name":"張飛","age":18,"sex":"male"} print("name" in dict_1) #True print("張飛" in dict_1) #False print("張飛" not in dict_1) #True
5.修改和添加字典中的元素
- 當以指定鍵為下標為字典元素賦值時，有兩種含義：
- 若該鍵存在字典中，則表示修改該鍵對應的值
- 若該鍵不存在字典中，則表示添加一個新的鍵值對，也就是添加一個新元素到字典中
dict_1 = {"name":"張飛","age":18}
print(dict_1)
dict_1["name"] = "李四" #name鍵存在字典dict_1中，所以此處為修改name的值
print(dict_1)
dict_1["sex"] = "male" #sex鍵不存在字典dict_1中，所以此處為添加新的鍵值對
print(dict_1)
#輸出結果
{'name': '張飛', 'age': 18}
{'name': '李四', 'age': 18}
{'name': '李四', 'age': 18, 'sex': 'male'}
6.刪除字典中的元素 del命令 clear()方法 pop()方法 popitem()方法
- del命令：根據」鍵「刪除字典中的元素
dict_1 = {"name":"張飛","age":18,"sex":"male"}
del dict_1["name"]
print(dict_1)
#運行結果
{'age': 18, 'sex': 'male'}
- clear()方法：用於清除字典中所有元素，其語法格式如下：
dict_1 = {"name":"張飛","age":18,"sex":"male"}
dict_1.clear()
print(dict_1)
#運行結果
{}
- pop()方法：用於獲取指定」鍵「的值，並將這個鍵值對從字典中移除，並返回該鍵的值。
- dict.pop(key[,default])
- key:要被刪除的鍵
- default：默認值，當字典中沒有要被刪除的key時，該方法返回指定的默認值
dict_1 = {"name":"張飛","age":18,"sex":"male"}
print(dict_1.pop("age")) #刪除鍵age與其值，pop（）方法的返回值為，刪除的該鍵的值
print(dict_1)
print(dict_1.pop('age',17))
print(dict_1)
print(dict_1.pop('name',"里斯"))
print(dict_1)
- popitem()方法：用於隨機獲取一個鍵值對，將其刪除，並以元組的方式返回被刪除的鍵值對
- dict.popitem():該方法無參數
dict_1 = {"name":"張飛","age":18,"sex":"male"}
x = dict_1.popitem()
print(x,type(x))
print(dict_1)
#運行結果
('sex', 'male') <class 'tuple'>
{'name': '張飛', 'age': 18}
7.更新字典
- 使用update()方法：可以將新字典的鍵值對，一次性全部添加到當前字典中
- 如果兩個字典存在相同的鍵，則以新字典中的值為準，更新當前字典
- dict.updata(dict2)
- dict:當前字典
- dict2：新字典
dict_1 = {"name":"張飛","age":18}
dict_2 = {"name":"李四","sex":"male"}
dict_1.update(dict_2)
print(dict_1)
print(dict_2)
#運行結果
{'name': '李四', 'age': 18, 'sex': 'male'}
{'name': '李四', 'sex': 'male'}
8.獲取字典視圖的三個方法
- key（）方法
#keys()方法：獲取字典中所有的key dict_1 = {"name":"張飛","age":18,"sex":"male"} key_1 = dict_1.keys() print(key_1,type(key_1)) #可以看出獲取到了字典所有的鍵，並存放在了一個貌似列表的dict_keys視圖中 key_2 = list(key_1) #將對象key_1視圖變成列表,並不改變原來的key_1視圖 print(key_1) print(key_2) #運行結果 dict_keys(['name', 'age', 'sex']) <class 'dict_keys'> dict_keys(['name', 'age', 'sex']) ['name', 'age', 'sex']
- values()方法
#values()方法：獲取字典中所有的value dict_1 = {"name":"張飛","age":18,"sex":"male"} value_1 = dict_1.values() print(value_1,type(value_1)) #可以看出獲取到了字典所有的值，並存放在了一個貌似列表的dict_values視圖中 value_2 = list(value_1) print(value_1) print(value_2) #運行結果 dict_values(['張飛', 18, 'male']) <class 'dict_values'> dict_values(['張飛', 18, 'male']) ['張飛', 18, 'male']
- items(）方法
#items()方法：獲取字典中所有的鍵值對 dict_1 = {"name":"張飛","age":18,"sex":"male"} items_1 = dict_1.items() #可以看出獲取到了字典所有的鍵值對，並將鍵值對存放在了元組中，再把元組存放在列表中，視圖類型為：dict_items print(items_1,type(items_1)) items_2 = list(items_1) #將視圖轉換成列表 print(items_2) items_3 = tuple(items_2) #將列錶轉換成元組 print(items_2) print(items_3) #運行結果 dict_items([('name', '張飛'), ('age', 18), ('sex', 'male')]) <class 'dict_items'> [('name', '張飛'), ('age', 18), ('sex', 'male')] [('name', '張飛'), ('age', 18), ('sex', 'male')] (('name', '張飛'), ('age', 18), ('sex', 'male'))
9.遍歷字典
-
使用for循環遍歷，列表、元組和集合的組合時
·當變數x為一個時，x會直接獲取列表（元組）的值
·當變數x,y···的個數剛好與列表（元組）的個數相同時，則直接將值依次賦給變數
注意：只有在使用列表和元組和集合的兩兩組合時才能這樣使用。
""" 使用for循環遍歷，列表和元組的組合時， ·當變數x為一個時，x會直接獲取列表（元組）的值 ·當變數x,y···的個數剛好與列表（元組）的個數相同時，則直接將值依次賦給變數 """ a = [('Mary', 'C',"d"),('Jone', 'java',"d"),('Lily', 'Python',"d"),('Lily', 'Python',"d")] for x in a: print(x) #列表裡面存儲的元組，只有一個變數x，所以將元組直接賦值給x print("============================================") for x,y,z in a: #列表裡面存儲的元組，每個元組裡面存儲了3個元素，剛好可以用三個變數xyz接收這三個元素 print(x,y,z) print("============================================") a = (['Mary', 'C',"d"],['Jone', 'java',"d"],['Lily', 'Python',"d"],['Lily', 'Python',"d"]) for x in a: #元組裡面存儲的列表，只有一個變數x，所以將元組直接賦值給x print(x) print("============================================") for x,y,z in a: #元組裡面存儲的列表，每個列表裡面存儲了3個元素，剛好可以用三個變數xyz接收這三個元素 print(x,y,z) #運行結果 ('Mary', 'C', 'd') ('Jone', 'java', 'd') ('Lily', 'Python', 'd') ('Lily', 'Python', 'd') ============================================ Mary C d Jone java d Lily Python d Lily Python d ============================================ ['Mary', 'C', 'd'] ['Jone', 'java', 'd'] ['Lily', 'Python', 'd'] ['Lily', 'Python', 'd'] ============================================ Mary C d Jone java d Lily Python d Lily Python d
a = {('Mary', 'C',"A"),('Jone', 'java',"B"),('Lily', 'Python',"C"),('Lily', 'Python',"D")}
for x in a: #集合裡面存儲的元組，只有一個變數x，所以將元組直接賦值給x
print(x)
for x,y,z in a: #集合裡面存儲的元組，每個元組裡面存儲了3個元素，剛好可以用三個變數xyz接收這三個元素
print(x,y,z)
#運行結果
('Mary', 'C', 'A')
('Lily', 'Python', 'D')
('Jone', 'java', 'B')
('Lily', 'Python', 'C')
Mary C A
Lily Python D
Jone java B
Lily Python C
-
遍歷字典中所有的鍵值對
- 使用items()方法，該方法以列表的形式返回可遍歷的鍵值對元組
stu_class = { 'Mary': 'C', 'Jone': 'java', 'Lily': 'Python', 'Lilo': 'Python' } for name,cla in stu_class.items(): print(name,"選修的課程為：",cla) #運行結果 Mary 選修的課程為： C Jone 選修的課程為： java Lily 選修的課程為： Python Lilo 選修的課程為： Python
-
遍歷字典中所有的鍵
- 當不需要字典中的值時，可使用keys()方法，只遍歷字典中的鍵，該方法以列表返回一個字典中所有的鍵
stu_class = { 'Mary': 'C', 'Jone': 'java', 'Lily': 'Python', 'Lilo': 'Python' } for name in stu_class.keys(): print(name) #運行結果 Mary Jone Lily Lilo
-
遍歷字典中所有的值
- 當只關心字典所包含的值時，可以使用values()方法，該方法以列表形式返回字典中所有的值
stu_class = { 'Mary': 'C', 'Jone': 'java', 'Lily': 'Python', 'Lilo': 'Python' } for cla in stu_class.values(): print(cla) #運行結果 C java Python Python
10.字典的特點
- 字典中所有的元素都是一個鍵值對（key – value）,key不允許重複，但是value可以重複
- 字典中的元素是無序的
- 字典中的key是不可變對象（不可變序列）
- 字典頁可以根據需要動態伸縮
- 字典會浪費較大的記憶體，是一種使用空間換時間的數據
11.複製字典
- 直接賦值：對象的引用
- 淺複製（copy()方法）：拷貝父對象，引用對象內部的子對象
- 深複製（deepcopy()方法）:copy模組的deepcopy()方法，完全複製父對象及其子對象
dict1 = {'user':'runoob','num':[123]}
dict2 = dict1 #引用對象
dict3 = dict1.copy() #淺複製，深複製父對象，子對象不複製，還是引用
import copy
dict4 = copy.deepcopy(dict1) #深複製，完全複製父對象和子對象
print(1,dict1,id(dict1)) #1 {'user': 'runoob', 'num': [123]} 1630766832896
dict1['user'] = 'root'
print(1,dict1,id(dict1)) #1 {'user': 'root', 'num': [123, 23]} 1630766832896
print(2,dict2,id(dict2)) #2 {'user': 'root', 'num': [123, 23]} 1630766832896
print(3,dict3,id(dict3)) #3 {'user': 'runoob', 'num': [123, 23]} 1630766833088
print(4,dict4,id(dict4)) #4 {'user': 'runoob', 'num': [123]} 1630767214080
Python集合（set）
1.什麼是集合
- python語言提供的內置數據結構
- 與列表和字典一樣，都屬於可變序列
- 集合是沒有value的字典
- 集合類型與其他類型最大的區別在於，它不包含重複元素
2.集合創建
#集合創建方式一：使用{} set_1 = {"Python","Hello",90} print(set_1) set_2 = {1,1,2,3,4,4,"Python","Python"} #集合中的元素不允許重複 print(set_2) set_3 = {1,2.2,(1,2,3,4),"Python"} print(set_3) #set_4 = {1,2.2,[1,2,3,4]} # 程式碼報錯：集合中的元素不允許為 可變數據類型（可變序列） #集合創建方式二：使用內置函數 set():將字元出、列表、元組、range()等對象轉化成集合 set_4 = set("python") print(set_4) set_5 = set([1,2,3,4,5]) print(set_5) set_6 = set((1,2,"Hello")) print(set_6) set_7 = set(range(5)) print(set_7) set_8 = set() #創建空集合 print(set_8) set_9 = {} print(type(set_9)) # <class 'dict'> :所以創建空集合的時候，不能直接使用{}
3.集合的判斷操作
- in 或者 not in : 判斷元素是否在集合中
set_1 = {10,20,30,40,50}
print(10 in set_1) #True
print(100 in set_1) #False
print(20 not in set_1) #False
print(100 not in set_1) #True
4.集合添加元素 add()方法 update()方法
set_1.add(x)方法：如果數據項x不在結合set_1中，將x添加到set_1中 （一次添加一個元素，元素不重複的前提下）
set_1.update(T)方法：合併結合T中的元素到當前集合set_1中，並自動去除重複元素 （至少添加一個元素，元素不重複的前提下）
#集合添加元素 set_1 = {1,2.2,"Python"} set_2 = {(1,2,True,"Hello"),2.2,"Python","China"} set_1.add((1,2,True,"Hello")) print(set_1) set_1.update(set_2) print(set_1) set_1.update([10,20,30]) #可以添加集合中的元素 print(set_1) set_1.update((40,50,60)) #可以添加元組中過的元素 print(set_1) #運行結果 {1, 2.2, (1, 2, True, 'Hello'), 'Python'} {1, 2.2, 'China', (1, 2, True, 'Hello'), 'Python'} {1, 2.2, 'China', 10, (1, 2, True, 'Hello'), 20, 'Python', 30} {1, 2.2, 'China', 40, 10, (1, 2, True, 'Hello'), 50, 20, 'Python', 60, 30}
5.集合刪除元素 remove()方法 discard()方法 pop()方法 clear()方法
S.remove(x)方法：如果x在集合S中，移除該元素；如果x不存在則拋出異常
S.discard(x)方法：如果x在集合S中，移除該元素；如果x不存在不會報錯
set_1 = {1,(1,2,True,"Hello"),2.2,"Python"}
set_1.remove(1)
print(set_1)
# set_1.remove(1) #集合中無元素1，執行此程式碼會拋出異常
set_1.discard(2.2)
print(set_1)
set_1.discard(2.2) #集合中無元素2.2，不過執行此程式碼不會拋出異常
print(set_1)
#運行結果
{(1, 2, True, 'Hello'), 2.2, 'Python'}
{(1, 2, True, 'Hello'), 'Python'}
{(1, 2, True, 'Hello'), 'Python'}
S.pop()方法：隨機刪除並返回集合中過的一個元素，如果集合為空則拋出異常
S.clear()方法：清空集合
set_1 = {1,(1,2,True,"Hello"),2.2,"Python"}
print(set_1.pop())
print(set_1)
set_1.clear()
print(set_1)
#set_1.pop() #集合為空，執行此行程式碼，會拋出異常
#運行結果
1
{2.2, 'Python', (1, 2, True, 'Hello')}
set()
6.集合間的關係
- 兩個集合是否相等 == 、 != 、 is 、not is
set_1 = {10,20,30,40}
set_2 = {40,30,10,20}
print(set_1 == set_2) #True 比較集合的值是否相等
print(set_1 is set_2) #False 比較集合的引用地址是否相等
- 一個集合是否是另一個集合的子集
- 可以調用方法 issubset() 判斷
- B是A的子集
A = {1,2,3,4,5,6}
B = {1,2,3,4}
print(B.issubset(A)) #True B是A的子集
- 一個集合是否是另一個集合的超集
- 可以調用方法 issuperset() 判斷
- A是B的子集
A = {1,2,3,4,5,6}
B = {1,2,3,4}
print(A.issuperset(B)) #True A是B的超集
- 兩個集合是否沒有交集
- 可以調用方法 isdisjoint() 判斷
A = {1,2,3,4,5,6}
B = {1,2,3,4}
print(A.isdisjoint(B)) #False 判斷A和B是否沒有交集
B = {7,8,9,10}
print(A.isdisjoint(B)) #True 判斷A和B是否沒有交集
7.集合的數據關係
pass
