字典

【1758872】的博客發表於2024-09-27

1.1、建立字典

1.1.1、建立字典的幾種方式

1.1.1.1、使用大括號建立

dict001 = {'a': 1, 'b': 2, 'c': 3}

1.1.1.2、使用 dict() 函式建立

# 使用dict的構造方法，引數為關鍵字引數
dict001 = dict(a=1, b=2, c=3)  # {'a': 1, 'b': 2, 'c': 3}
# 使用dict的構造方法，引數為巢狀元組的list，注意：傳入的list結構是有要求的，list的每個元素都是一個兩個元素的tuple
tuple_list =[("name", "jack"), ("age", 30)]
dict002 = dict(tuple_list)  # {'name': 'jack', 'age': 30}
# 使用dict的構造方法，引數為 zip() 函式的返回值
dict003 = dict(zip("abc",[1,2,3]))  # {'a': 1, 'b': 2, 'c': 3}
# 使用字典解析式
dict004 = {char : char* 2 for char in "ABCD"}  # {'A': 'AA', 'B': 'BB', 'C': 'CC', 'D': 'DD'}

1.1.1.3、使用字典的 fromkeys() 函式初始化一個字典

# 說明：fromkeys()是dict類的一個staticmethod（靜態方法）
seq = ('x', 'y', 'z')
# 建立一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應的初始值，預設為None，例如指定初始值為10
dict003 = dict.fromkeys(seq, 10)

1.1.1.4、建立一個有序的字典

在 Python 3.7 版本之前，字典是無序的，及輸入dict001={'a':1,'b':2,'c':3}，列印的可能是dict001={'b':2,'c':3,'a':1}，但在 Python 3.7 及以上的版本中，保留了字典的插入順序，及如何輸入的就會如何輸出，值得注意的是在進行字典比較時，比較的是裡面的內容，內容一樣，則返回True

dict001={'a':1,'b':2,'c':3}
dict002={'b':2,'c':3,'a':1}
print(dict001==dict002)  # True

而真正建立有序的字典則需要用到collections模組中的OrderedDict，內容一樣，但順序不同，則會返回False。

from collections import OrderedDict

# 建立一個空的有序字典
my_ordered_dict = OrderedDict()

d001 = OrderedDict()
d001['a'] = 1
d001['b'] = 2
d001['c'] = 3
print(d001)  # OrderedDict({'a': 1, 'b': 2, 'c': 3})

d002 = OrderedDict()
d002['a'] = 1
d002['c'] = 3
d002['b'] = 2
print(d002)  # OrderedDict({'a': 1, 'c': 3, 'b': 2})
print(d001==d002) # False

d003 = OrderedDict()
d003['a'] = 1
d003['b'] = 2
d003['c'] = 3
print(d001==d003) # True

1.1.1.5、字典的淺複製和深複製

淺複製：

hold_list = [1,2,3]
old_dict = {"num":hold_list}
new_dict = old_dict.copy()
print(id(old_dict["num"]))  # 2141756678856
print(id(new_dict["num"]))  # 2141756678856
# 淺複製：old_dict與new_dict持有的是同一個hold_list物件，注意看id值

深複製：

from copy import deepcopy

hold_list = [1,2]
old_dict = {"num":hold_list}
new_dict = deepcopy(old_dict)
print(id(old_dict["num"]))  # 2141787030152
print(id(new_dict["num"]))  # 2141787012040
# 深複製：new_dict持有的也是一個新建立的host_list物件，注意看id值

1.2、字典的新增操作

1.2.1、使用中括號的方式

dict001 = {'楊過': '小龍女'}
# 說明：中括號指定key，賦值一個value，key不存在，則是新增元素（如果key已存在，則是修改key對應的value）
dict001['郭靖'] = '黃蓉'
print(dict001)  # {'楊過': '小龍女', '郭靖': '黃蓉'}

1.2.2、使用update()方法

dict001 = {'楊過': '小龍女', 'country': 'china'}

# 引數為字典物件，使用dict的update方法，key不存在則是新增元素（key存在則是修改value）
dict001.update({'郭靖': '黃蓉'})
print(dict001)  # {'楊過': '小龍女', 'country': 'china', '郭靖': '黃蓉'}
dict001.update({'country': '中國'})
print(dict001)  # {'楊過': '小龍女', 'country': '中國', '郭靖': '黃蓉'}

# 引數為關鍵字引數，注意：關鍵字引數形式，key物件只能是字串物件
dict001.update(temp="哈哈", help="呵呵")
print(dict001)  # {'楊過': '小龍女', 'country': '中國', '郭靖': '黃蓉', 'temp': '哈哈', 'help': '呵呵'}

# 引數為字典解包方式
my_temp_dict = {'楊過': '陸無雙', 'age':18}
dict001.update(**my_temp_dict)  # 等同於：dict001.update(楊過='陸無雙', age=18) 
print(dict001)  # {'楊過': '陸無雙', 'country': '中國', '郭靖': '黃蓉', 'temp': '哈哈', 'help': '呵呵', 'age': 18}

1.3、字典的刪除操作

1.3.1、使用 del 進行刪除

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
# 刪除 "郭靖": "黃蓉" 這對元素，如果給的鍵不存在，會報錯
del dict001['郭靖']

1.3.2、使用 pop() 方法進行刪除

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
# pop()刪除不存在的鍵，會返回自定義的值 哈哈，如果沒有給出該值，則會報錯
variable001 = dict001.pop("郭靖")
print(variable001)  # 黃蓉
variable002 = dict001.pop("張三", "哈哈")
print(variable002) # 哈哈

1.3.3、使用 popitem() 方法進行刪除

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
# 返回並刪除字典中的最後一位鍵值對，如果字典已經為空，卻呼叫了此方法，就報出 KeyError 
variable = dict001.popitem()  # ('周伯通', '瑛姑')

1.3.4、清空和刪除字典

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
dict001.clear()  # 清空整個字典
del dict001  # 刪除整個字典

1.4、字典的獲取操作

1.4.1、透過KEY獲取對應的值

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
# 使用這種方式獲取，如果key不存在則會報錯
variable = dict001["郭靖"]

1.4.2、透過get()方式進行獲取

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
# 返回指定鍵對應的值,沒有就返回 哈哈
variable = dict001.get("郭靖", "哈哈")

1.4.3、setdefault() 方法既可以獲取又可以新增

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
# 設定值，Key存在,返回Key對應的值，Key不存在，就新增到字典，並返回剛設定的值
variable = dict001.setdefault("apple", '蘋果')

1.4.4、獲取所有的Key

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
# 返回迭代器 dict_keys(['郭靖', '張無忌', '楊過', '周伯通'])
variable = dict001.keys()
# 可以用list直接轉換成列表 ['郭靖', '張無忌', '楊過', '周伯通']
keys = list(variable)

1.4.5、獲取所有的Value

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
# 返回迭代器 dict_values(['黃蓉', '趙敏', '小龍女', '瑛姑'])
variable = dict001.values()
# 可以用list直接轉換成列表 ['黃蓉', '趙敏', '小龍女', '瑛姑']
values = list(variable)

1.4.6、獲取所有的鍵值對列表

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
# 返回迭代器 dict_items([('郭靖', '黃蓉'), ('張無忌', '趙敏'), ('楊過', '小龍女'), ('周伯通', '瑛姑')])
variable = dict001.items()
# 可以用list直接轉換成列表 [('郭靖', '黃蓉'), ('張無忌', '趙敏'), ('楊過', '小龍女'), ('周伯通', '瑛姑')]
keyValue = list(variable)

1.4.7、批次獲取指定鍵對應的值

需求：給出一個key列表，獲取對應的值

1.4.7.1、使用高階函式的方式（推薦）

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
key_list = ["楊過", "郭靖"]
values = list(map(dict001.get, key_list))

1.4.7.2、使用列表推導式的方式

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
key_list = ["楊過", "郭靖"]
values = [dict001.get(key) for key in key_list]

1.5、字典的合併和遍歷

1.5.1、合併字典

在 Python 2 中，使用 update（）合併兩個字典，Python 3 變得更加簡單。下面指令碼中，兩個字典被合併。在相交（key相同）的情況下，使用第二個字典中的值。

1.5.1.1、pyton3中合併字典的方式（推薦）

dict001 = {'apple':9,'banana':6}
dict002 = {'banana':4,'orange':8}
dict003 = {**dict001,**dict002}
print(dict003) # 輸出：{'apple':9,'banana':4,'orange':8}

1.5.1.2、藉助字典的 dict(d1, d2) 方法合併(推薦)

dict001 = {'a': 1, 'b': 2, 'c': 3}
dict002 = {'aa': 11, 'bb': 22, 'cc': 33}
print(dict(**dict001, **dict002)) # 輸出：{'a': 1, 'aa': 11, 'c': 3, 'b': 2, 'bb': 22, 'cc': 33}

1.5.1.3、藉助字典的update()方法合併

dict001 = {'a': 1, 'b': 2, 'c': 3}
dict002 = {'aa': 11, 'bb': 22, 'cc': 33, 'a': 100}
dict003 = {}
dict003.update(dict001)
dict003.update(dict002)
print(dict003) # 輸出：{'a': 100, 'b': 2, 'c': 3, 'aa': 11, 'bb': 22, 'cc': 33}

1.5.1.4、藉助字典的常規處理方法合併（不推薦）

dict001 = {'a': 1, 'b': 2, 'c': 3}
dict002 = {'aa': 11, 'bb': 22, 'cc': 33}
dict002 = {}
for k, v in dict001.items():
    dict003[k] = v
for k, v in dict002.items():
    dict003[k] = v
print(dict003) # 輸出：{'a': 1, 'aa': 11, 'c': 3, 'b': 2, 'bb': 22, 'cc': 33}

1.5.2、遍歷字典

1.5.2.1、遍歷所有的鍵

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
# 注意：直接遍歷字典就是遍歷所有的鍵
for key in dict001:
    print(key)

1.5.2.2、遍歷所有的值

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
for value in dict001.values():
    print(value)

1.5.2.3、遍歷所有的鍵值對兒

dict001 = {"郭靖": "黃蓉", "張無忌": "趙敏", "楊過": "小龍女", "周伯通": "瑛姑"}
# 遍歷鍵和值：
for key, value in dict001.items():
    print(key, value)

1.6、字典排序

在Python中，字典本身是無序的，直到Python3.7版本，字典在迭代時會保持插入順序。如果你需要根據鍵（key）或值（value）對字典中的項進行排序，可以使用內建的sorted()函式，它返回一個排序後的列表。

1.6.1、按照字典中的鍵給字典排序

dict001 = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
# reverse=True表示降序，預設False，升序排序，注意：這會得到一個新字典，原字典dict001沒有改變
variable = dict(sorted(dict001.items(), key=lambda x: x[0], reverse=True))

1.6.2、按照字典中的值給字典排序

dict001 = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
# reverse=True表示降序，預設False，升序排序，注意：這會得到一個新字典，原字典dict001沒有改變
variable = dict(sorted(dict001.items(), key=lambda x: x[1], reverse=True))

1.6.3、使用 OrderedDict() 進行排序

from collections import OrderedDict
# 根據值排序並建立OrderedDict
sorted_dict = OrderedDict(sorted(my_dict.items(), key=lambda item: item[1]))

1.7、字典的常見需求

1.7.1、字典格式的字串轉為字典

import ast

# 注意：user實際上是一個字串
user = '{"name" : "john", "gender" : "male", "age": 28}'
# 使用 ast 模組的literal_eval() 方法可以將其轉變為字典物件
user_dict1 = ast.literal_eval(user)

1.7.2、將字典轉成json字串

import json

dict001 = {"name" : "john", "gender" : "male", "age": 28}
# dumps用於將字典轉化成json格式的字串，dumps這一過程又被稱為序列化。
variable = json.dumps(dict001, indent=4, sort_keys=True)

dump()函式用於將一個python物件（需要是json可序列化的）儲存到相應的json檔案中，dump()沒有返回值。

import json
 
dict001 = {"name" : "john", "gender" : "male", "age": 28}
with open("test.json", "w") as f:
    json.dump(dict001, f)

1.7.3、字典求交集

需求：把兩個字典中相同的鍵值對兒拿出來組成一個新字典

dict001 = {"郭靖": "黃蓉", "楊過": "小龍女", "tom": "jack", "光頭強": "熊大"}
dict002 = {"郭靖": "黃蓉", "楊過": "小龍女", "Bob": "ros", "光頭強": "熊二"}
variable = {k: dict001[k] for k in dict001 if k in dict002 and dict001[k] == dict002[k]}

1.7.4、鍵同值不同

需求：找出字典1中和字典2中鍵相同但值不同，或者字典1中存在但字典2中不存在的鍵值對

dict001 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'f': 8}
dict002 = {'a': 1, 'b': 2, 'c': 4, 'd': 5, 'e': 6}
 
def compare_dict(dict001, dict002):
    """
    找出字典1中和字典2中鍵相同但值不同，或者字典1中存在但字典2中不存在的鍵值對
    """
    res = {}
    for alike_key in dict001:
        z = dict001.get(alike_key) == dict002.get(alike_key)
        if not z:
            print('相同的鍵:', alike_key)
            print('字典1的值：', dict001.get(alike_key), '字典2的值：', dict002.get(alike_key))
            k1 = "dict001_{}".format(str(alike_key))
            k2 = "dict002_{}".format(str(alike_key))
            res[k1] = dict001.get(alike_key)
            res[k2] = dict002.get(alike_key)
 
    return res

codevs 4189 字典【字典樹】
2018-09-03
dev
InnoDB資料字典--字典表載入
2018-04-06
字串形式的列表，字典轉列表，字典
2024-03-26
字串
Swift，字典
2017-09-13
Swift
字典案例
2024-04-01
四、字典
2024-07-27
字典樹
2024-08-22
iOS 字典轉陣列，陣列轉字典
2018-10-23
iOS陣列
Oracle 資料字典和資料字典檢視
2011-07-29
Oracle
資料字典
2015-07-16
黑客字典II
2002-08-19
黑客
調整字典
2024-04-02
字典樹(Trie)
2024-07-09
python-字典-如何取出字典中的所有值
2020-12-02
Python
什麼是字典？Python字典是可變的嗎？
2023-02-07
Python
資料字典簡介和資料字典命中率
2017-03-20
根據字典中值得大小，對字典中的項排序
2017-07-16
排序
ThinkCMF資料字典
2019-05-11
MySQL資料字典
2021-04-05
MySql
字典樹學習
2018-09-02
python-字典
2018-11-14
Python
Python dict(字典)
2018-12-26
Python
Python羅技字典
2020-10-16
Python
Redis中的字典
2020-10-15
Redis
python 字典排序
2017-03-17
Python排序
python建立字典
2017-08-23
Python
javascript中的字典
2017-01-15
JavaScript
oracle 資料字典
2015-04-10
Oracle
Delphi TDictionary字典類
2024-03-12
字典樹專題
2024-04-20
Trie樹，字典樹
2024-08-17
python字典鍵的特性及字典內建函式&方法
2020-12-05
Python函式
Python中遍歷字典以及字典中的鍵和值
2024-03-26
Python
字典及相關操作
2019-03-06
【Python基礎】字典
2019-06-27
Python
【閱讀筆記：字典】
2019-07-01
筆記
Python字典介紹
2021-04-13
Python
Python3 字典
2018-08-27
Python

字典