『無為則無心』Python序列 — 21、Python字典及其常用操作

1、字典的應用場景

思考1：如果有多個資料，例如：'Tom', '男', 20，如何快速儲存？

答：列表

list1 = ['Tom', '男', 20]

思考2：如何查詢到資料'Tom'？

答：查詢到下標為0的資料即可。

list1[0]

思考3：如果將來資料順序發生變化，如下所示，還能用list1[0]訪問到資料'Tom'嗎？。

list1 = ['男', 20, 'Tom']

答：不能，資料'Tom'此時下標為2。

思考4：資料順序發生變化，每個資料的下標也會隨之變化，如何保證資料順序變化前後能使用同一的標準查詢資料呢？

答：字典，字典裡面的資料是以鍵值對形式出現，字典資料和資料順序沒有關係，即字典不支援下標，後期無論資料如何變化，只需要按照對應的鍵的名字查詢資料即可。

2、字典的概念

字典屬於一種新的資料結構，稱為對映（mapping）。
字典不再是序列，無法通過為止索引完成元素值的獲取，只能通過鍵索引實現。
字典也是Python中唯一內建的對映型別。
字典的作用和列表類似，都是用來儲存物件的容器。
列表儲存資料的效能很好，但是查詢資料的不是很方便（要麼知道下標，要麼就要一個一個遍歷）。
在字典中每一個元素都有一個唯一的名字，通過這個唯一的名字可以快速的查詢到指定的元素。
在查詢元素時，字典的效率是非常快的。
在字典中可以儲存多個物件，每個物件都會有一個唯一的名字。
- 這個唯一的名字，我們稱其為鍵（key），
  通過key可以快速的查詢value。
  字典的鍵可以是任意的不可變物件（int、str、bool、tuple ...），但是一般我們都會使用str。
  字典的鍵是不能重複的，如果出現重複的後邊的會替換到前邊的。
- 這個物件，我們稱其為值（value），字典的值可以是任意物件。
- 所以字典，我們也稱為叫做鍵值對（key-value）結構。
- 每個字典中都可以有多個鍵值對，而每一個鍵值對我們稱其為一項（item）。

3、建立字典的語法

字典特點：

符號為大括號。
資料為鍵值對形式出現。
各個鍵值對之間用逗號隔開。

# 1.建立有資料字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(type(dict1))  # <class 'dict'>

# 2.建立空字典
# 方式1
dict2 = {}
print(type(dict2))  # <class 'dict'>
# 方式2，通過dict()函式
dict3 = dict()
print(type(dict3))  # <class 'dict'>

# 3.使用dict()函式來建立有元素的字典
# 每一個引數都是一個鍵值對，引數名就是鍵，引數名就是值
# （這種方式建立的字典，key都是字串）
d = dict(name='孫悟空', age=18, gender='男')
print(d) # {'name': '孫悟空', 'age': 18, 'gender': '男'}
print(type(d)) # <class 'dict'>

注意：一般稱冒號前面的為鍵(key)，簡稱k；冒號後面的為值(value)，簡稱v。

4、字典常見操作

（1）字典的增加操作

寫法：字典序列[key] = 值。

注意：如果key存在則修改這個key對應的值；如果key不存在則新增此鍵值對。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

# 1.修改字典中name的值。
dict1['name'] = 'Rose'
# 結果：{'name': 'Rose', 'age': 20, 'gender': '男'}
print(dict1)

# 2.新增id屬性
dict1['id'] = 110
# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
print(dict1)

注意：字典為可變型別。

（2）字典的刪除操作

@1、del()方法或 del函式

del()方法或 del函式：刪除字典或刪除字典中指定鍵值對。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

# 1.刪除字典中指定的鍵值對
# 結果：{'name': 'Tom', 'age': 20}
del dict1['gender']
print(dict1)

# 2.通過del刪除整個字典
# 結果：NameError: name 'dict1' is not defined
del(dict1)
print(dict1)

# 3.所刪除的key不包含在字典中，會拋異常
# 結果：KeyError: 'genders'
del dict1['genders']
print(dict1)

@2、clear()方法

clear()方法：清空字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1.clear()
print(dict1)  # {}

@3、popitem()方法

popitem()方法隨機刪除字典中的一個鍵/值對，一般都會刪除最後一個鍵值對。

刪除之後，它會將刪除的key-value作為返回值返回，

返回的是一個元組，元組中有兩個元素，第一個元素是刪除的key，第二個是刪除的value。

"""
1.在字典中刪除一個鍵值對。
輸出結果：
result =  ('c', 3)
{'a': 1, 'b': 2}
"""
d = {'a': 1, 'b': 2, 'c': 3}
result = d.popitem()
print("result = ", result)
print(d)

# 2.當使用popitem()刪除一個空字典時，會丟擲異常。
# 結果：KeyError: 'popitem(): dictionary is empty'
d = {}
d.popitem()

@4、pop(key[, default])方法

"""
1.pop(key[, default])方法，
根據key刪除字典中的key-value,
會將被刪除的value返回！

輸出結果：
result =  1
{'b': 2, 'c': 3}
"""
d = {'a': 1, 'b': 2, 'c': 3}
result = d.pop('a')
print("result = ", result)
print(d)


"""
2.如果刪除的key，在字典中不存在，會丟擲異常。

"""
# 結果：KeyError: 'f'
d = {'a': 1, 'b': 2, 'c': 3}
result = d.pop('f') # 異常

"""
3.如果指定了預設值，再刪除不存在的key時，不會報錯，
而是直接返回預設值。
輸出結果：
result =  這是預設值
{'a': 1, 'b': 2, 'c': 3}
"""
d = {'a': 1, 'b': 2, 'c': 3}
result = d.pop('z','這是預設值')
print("result = ", result)
print(d)

（3）字典的修改操作

@1、通過key修改字典

寫法：字典序列[key] = 值

注意：如果key存在則修改這個key對應的值，如果key不存在則新增此鍵值對。

dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}

# 修改
# 結果：{'name': 'Lily', 'age': 20, 'gender': '男'}
dict1['name'] = 'Lily'
print(dict1)

# 增加
# 結果：{'name': 'Lily', 'age': 20, 'gender': '男', 'id': 110}
dict1['id'] = 110
print(dict1)

@2、setdefault(key[, default])方法

"""
setdefault(key[, default]) 可以用來向字典中新增key-value,
如果key已經存在於字典中，則返回key的值，不會對字典做任何操作,
如果key不存在，則向字典中新增這個key，並設定value，返回預設值。
"""
# 1.存在key，不會對字典做任何操作,返回key的值
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
result = dict1.setdefault('name','豬八戒')
print('result =',result) # result = Tom
print(dict1) # {'name': 'Tom', 'age': 20, 'gender': '男'}

# 2.不存在key，新增值，返回key的預設值
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
result = dict1.setdefault('id','豬八戒')
print('result =',result) # result = 豬八戒
print(dict1) # {'name': 'Tom', 'age': 20, 'gender': '男', 'id': '豬八戒'}

@3、update([other])方法

"""
將其他的字典中的key-value新增到當前字典中
如果有重複的key，則後邊的會替換到當前的
"""
# 結果：{'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
d = {'a': 1, 'b': 2, 'c': 3}
d2 = {'d': 4, 'e': 5, 'f': 6, 'a': 7}
d.update(d2)
print(d)

（4）字典的查詢操作

@1、key值查詢

key必須加引號，否則按變數識別。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 1.key存在返回對應的值
print(dict1['name'])  # Tom

# 2.字典中沒有對應的key
# 結果KeyError: 'id'
print(dict1['id'])  # 報錯

如果當前查詢的key存在，則返回對應的值；否則則報錯。

@2、get()方法

該方法用來根據鍵來獲取字典中的值。

語法：

字典序列.get(key, 預設值)

注意：如果當前查詢的key不存在則返回第二個引數(預設值)，如果省略第二個引數，則返回None。

快速體驗：

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 1.如果key存在，返回對應的值
print(dict1.get('name'))  # Tom

# 2.如果key不存在，返回預設值。
print(dict1.get('id', 110))  # 110

# 3.如果key不存在，也沒有設定預設值，則返回None。
print(dict1.get('id'))  # None

@3、keys()方法

示例：

# 查詢字典中所有的key，返回一個序列，包含字典中所有的key。
# 是一個可迭代的序列。（就是支援for遍歷）
# 結果：dict_keys(['name', 'age', 'gender'])
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys())

遍歷字典的key：

"""
# dict1.keys()得到可遍歷的物件
輸出結果： 
name
age
gender
"""
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
    print(key)

@4、values()方法

示例：

# 查詢字典中所有的value值，返回一個序列，包含字典中所有的value值。
# 是一個可迭代的序列。
# 結果：dict_values(['Tom', 20, '男'])
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values())

遍歷字典的value：

"""
# dict1.values()得到可遍歷的物件
輸出結果： 
Tom
20
男
"""
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
    print(value)

@5、items()方法

示例：

# 查詢字典中所有的鍵值對，返回一個序列，包含字典中所有的鍵值對（項）。
# 是一個可迭代的序列。
# 可迭代物件裡面的資料是元組（有的也叫雙值子序列），
# 元組中資料1是字典的key，元組中資料2是字典key對應的值。

# 結果：dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items())

遍歷字典的元素：

"""
# dict1.items()得到可遍歷的物件，其中的元素是一個元組。
輸出結果： 
('name', 'Tom')
('age', 20)
('gender', '男')
"""
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
    print(item)

遍歷字典的鍵值對：

也就是將得到的資料進行一個拆包動作。

"""
xx.items(): 返回可迭代物件，內部的元素是元組，
而元組有2個資料，將元組中的第一個資料賦值給第一個變數，第二個資料賦值給第二個變數。
也就是元組資料1是字典的key，元組資料2是字典的value，
這就是所謂的拆包動作。（可以看元祖中將的序列的拆包）

輸出結果： 
name = Tom
age = 20
gender = 男
"""

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
    print(f'{key} = {value}')

（5）`copy()`複製

和列表中的用法一樣，這裡補充說明：

copy()方法用於對字典進行淺複製，複製以後的物件，和原物件是獨立，修改一個不會影響另一個。

但注意，淺複製會簡單複製物件內部的值，如果內部值也是一個可變物件，這個可變物件不會被複制。

#基本用法和列表一樣。（可以看列表）

"""
# 字典的value可以儲存的還是字典，
這個value值的字典用copy()方法的時候，是不進行復制的，
在記憶體中還是一份的，所以修改其中一個字典的value，
另一個也會改變。

輸出結果：
d =  {'a': {'name': '豬八戒', 'age': 18}, 'b': 2, 'c': 3}
d2 =  {'a': {'name': '豬八戒', 'age': 18}, 'b': 2, 'c': 3}
"""
d = {'a': {'name': '孫悟空', 'age': 18}, 'b': 2, 'c': 3}
d2 = d.copy()
d2['a']['name'] = '豬八戒'
print("d = ", d)
print("d2 = ", d2)