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

目錄

• 1、字典的應用場景
• 2、字典的概念
• 3、創建字典的語法
• 4、字典常見操作
  • （1）字典的增加操作
  • （2）字典的刪除操作
  • （3）字典的修改操作
  • （4）字典的查找操作
  • （5）copy()復制

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)