1 定義

字典是一種映射對象類型，由鍵值對構成的一個可變容器。字典中的每個鍵值對內用冒號 ( : ) 分隔，鍵值對間用逗號 ( , ) 分隔，所有鍵值對包括在{}中。字典的鍵必須是唯一的，只有可散列的數據類型才能用作這些映射里的鍵，而值則不必是唯一的。

可散列數據類型：一個對象是可散列的，那么在它的生命周期中它的hash值是不變的。Python所有內置的不可變的對象都是可散列的（hashable），如數字、字符串等；可變的容器（比如list或dict）不是hashable；對于元組，只有它包含的所有元素都是可散列類型的情況下，它才是可散列的。 # 判斷對象是不是可散列數據類型t = (1, 2, 3)hash(t) # 有hash值t = (1, 2, [1, 2])hash(t) # TypeError: unhashable type: 'list'

創建字典的方法：

• 根據定義創建：使用一對中括號 {}，鍵值對中間用冒號，每項間使用逗號分隔。

d = {} # 空字典d = {'a':1, 'b':2, 'c':3}

• 使用dict()構造函數

# 鍵值對d1 = dict({'name':'Tom', 'age':'18', 'gender':'male'})# 關鍵字參數d2 = dict('name'='Tom', 'age'='18', 'gender'='male')# 元素為元組或列表的元組、元素為元組或列表的列表d3 = dict([(name', 'Tom'), ('age', '18'), ('gender', 'male')])# zip(seq1, seq2)seq1 = ['name', 'age', 'gender']seq2 = ['Tom', '18', 'male']d4 = dict(zip(seq1, seq2))

• fromkeys() 方法

"""用于創建一個新字典，以序列seq中元素做字典的鍵，value為字典所有鍵對應的初始值。語法：dict.fromkeys(seq, value)參數：seq為字典鍵值列表，value為鍵序列對應的值，默認為None。返回值：返回一個新的字典。"""seq = ['a', 'b', 'c']value = [1, 2]d1 = dict.fromkeys(seq, value)d2 = {}.fromkeys(seq, value)d3 = {'A':1, 'B':2}.fromkeys(seq, value)print(d1) # {'a': [1, 2], 'b': [1, 2], 'c': [1, 2]}print(d2) # {'a': [1, 2], 'b': [1, 2], 'c': [1, 2]}print(d3) # {'a': [1, 2], 'b': [1, 2], 'c': [1, 2]}

• 字典推導構建新字典

字典推導可以從任何以鍵值對作為元素的可迭代對象中構建出字典。

# 利用元組列表生成字典lt = [('a', 1), ('b', 2), ('c', 3)]d = {key: value for key, value in lt} # {'a': 1, 'b': 2, 'c': 3}# 利用一個字典生成另一個字典d1 = {key.upper(): value for key, value in d.items()} # {'A': 1, 'B': 2, 'C': 3}

2 基本操作

2.1 訪問字典

• 根據字典的鍵來訪問字典，如果不存在，則會拋出異常。

d = {'name':'Tom', 'age':'18', 'gender':'male'}d['name'] # Tomd['nationality'] # 報異常 KeyError: 'nationality'

• 使用get()函數訪問字典，如果鍵不存在，返回默認值，而不會報錯。

"""語法：dict.get(key, default=None)參數：key為要查找的鍵，default為鍵不存在時返回的默認值。返回：返回指定鍵的值，若不存在，則返回默認值default，default默認為None。"""d = {'name':'Tom', 'age':'18', 'gender':'male'}d.get('nationality', 'Chinese') # Chinese

2.2 修改字典

2.2.1 更新字典元素

# 更新指定鍵對應的值d = {'name':'Tom', 'age':'18', 'gender':'male'}d['name'] = 'Henry'print(d)Out:{'name': 'Henry', 'age': '18', 'gender': 'male'}

2.2.2 添加字典元素

d = {'name':'Tom', 'age':'18', 'gender':'male'}d['nationality'] = 'Chinese' # 添加元素print(d)Out:{'name': 'Tom', 'age': '18', 'gender': 'male', 'nationality': 'Chinese'}

2.2.3 setdefault()添加元素

與get()方法類似，如果key在字典中，返回對應的值，不修改已存在的鍵對應值。如果key不在字典中，則插入key及設置的默認值default，并返回 default，default默認值為None。

"""語法：dict.setdefault(key, default=None)參數：key為要添加的鍵，default為key在字典dict中不存在時插入的值，默認為None。返回值：如果key在字典中，則返回對應的值，若不存在則插入鍵值對，并返回插入的值。"""d = {'name':'Tom', 'age':'18', 'gender':'male'}r = d.setdefault('name', 'Henry') # r = Tom，字典不變r = d.setdefault('nationality', 'Chinese') print(r)print(d)Out:Chinese{'name': 'Tom', 'age': '18', 'gender': 'male', 'nationality': 'Chinese'}

2.2.4 update()添加或更新元素

update()用于更新字典中的鍵值對，可以修改存在的鍵對應的值，也可以添加新的鍵值對到字典中。

"""語法：dict.update(data)參數：data為要更新或添加的鍵值對數據，可以是字典、關鍵字參數、元組列表等。返回值：無"""# 更新存在鍵對應的值，傳入字典d = {'name': 'Tom', 'age': '18', 'sex': 'Male'}d.update({'name': 'Henry'})print(d)Out: # 打印d的結果{'name': 'Henry', 'age': '18', 'sex': 'Male'}# 添加鍵值對，傳入關鍵字參數 d = {'name': 'Tom', 'age': '18', 'sex': 'Male'}d.update(stature='188', nationality='Chinese')print(d)Out:{'name': 'Tom', 'age': '18', 'sex': 'Male', 'stature': '188', 'nationality': 'Chinese'}# 傳入元組列表d = {'name': 'Tom', 'age': '18', 'sex': 'Male'}d.update([('stature', '188'), ('nationality', 'Chinese')])print(d)Out:{'name': 'Tom', 'age': '18', 'sex': 'Male', 'stature': '188', 'nationality': 'Chinese'}

2.3 刪除字典

• 刪除單個字典元素

# del 刪除指定鍵的元素d = {'name': 'Tom', 'age': '18', 'sex': 'Male'}del d['sex']print(d)Out:{'name': 'Tom', 'age': '18'}# dict.pop(key, default) 刪除啊指定鍵key對應的值，并返回被刪除的值。若key不存在，default要給出，否則報錯。d = {'name': 'Tom', 'age': '18', 'sex': 'Male'}d.pop('sex')print(d)Out:{'name': 'Tom', 'age': '18'}

• 清空字典所有元素

d = {'name': 'Tom', 'age': '18', 'sex': 'Male'}d.clear()print(d)Out:{}

• 刪除整個字典

d = {'name': 'Tom', 'age': '18', 'sex': 'Male'}del d

2.4 字典視圖

字典自帶的三個方法 dict.items()、dict.keys()、dict.values()，它們返回的對象都是原字典的視圖，修改原字典對象，視圖對象的值也會發生改變。

2.4.1 dict.items()

"""語法：dict.items()參數：無返回值：返回可遍歷的元組數組，元組由鍵值對構成。"""d = {'a': 1, 'b': 2, 'c': 3}r = d.items()print(r)print(list(r))Out:dict_items([('a', 1), ('b', 2), ('c', 3)])[('a', 1), ('b', 2), ('c', 3)]

2.4.2 dict.keys()

"""語法： dict.keys()參數：無返回值：返回一個由字典鍵構成的迭代器，使用list()可轉換為列表。"""d = {'a': 1, 'b': 2, 'c': 3}print(d.keys())Out:dict_keys(['a', 'b', 'c'])# 獲取所有鍵集合set(d)set(d.keys())

2.4.3 dict.values()

"""語法： dict.values()參數：無返回值：返回一個由字典值構成的迭代器，使用list()可轉換為列表。"""d = {'a': 1, 'b': 2, 'c': 3}print(d.values())Out:dict_values([1, 2, 3])

2.5 字典遍歷

字典遍歷常與 dict.items()、dict.keys()、dict.values()等三個方法配合使用。

# items()d = {'a': 1, 'b': 2, 'c': 3}for key, value in d.items():print(f'key = {key}, value = {value}')Out:key = a, value = 1key = b, value = 2key = c, value = 3# 字典推導d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}d_new = {k: v for k, v in d.items() if v%2 == 0}print(d_new)Out:{'b': 2, 'd': 4}

2.6 字典排序

# 根據字典鍵排序d = {'b': 2, 'a': 1, 'c': 3}d_new = dict(sorted(d.items(), key=lambda x: x[0], reverse=True))print(d_new)Out:{'c': 3, 'b': 2, 'a': 1}# 根據字典值排序d = {'b': 2, 'a': 1, 'c': 3}d_new = dict(sorted(d.items(), key=lambda x: x[1]))print(d_new)Out:{'a': 1, 'b': 2, 'c': 3}

2.7 統計元素個數

d = {'b': 2, 'a': 1, 'c': 3}print(len(d))Out:3

3 進階知識

3.1 collections模塊中字典類型

3.1.1 collections.defaultdict

通過字典key訪問字典元素時，如果key不存在，則會引發‘KeyError‘異常。為了避免這種情況，前面介紹的get()和setdefault()方法是通過指定默認值。除此之外，我們也可以使用 collections模塊中的defaultdict類（dict的子類）來處理找不到的鍵的情況。使用defaultdict()可以用于以下兩種場合：

在key不存在時，不報異常，而是返回一個默認值。

在key不存在時，也可以賦值，而不報異常。

collections.defaultdict(default_factory,...): defaultdict是內置的dict類的一個子類，返回一個新的類字典的對象，第一個參數提供了default_factory屬性的初始值，默認為None。default_factory可以設置為：

使用類型名稱來作為初始化函數的參數，當所訪問的鍵不存在的時候，根據傳入類型實例化一個初始值作為默認值。

使用不帶參數的可調用函數作為初始化函數參數，以該函數返回值作為默認值。

下面，通過一個統計列表中單詞次數的示例來看如何處理鍵不存在的情況。

• KeyError異常

"""在Python中如果訪問字典里不存在的鍵，會出現KeyError異常。"""# 統計列表中單詞出現次數，并記錄在字典count中fruits = ['apple', 'orange', 'cherry', 'apple', 'apple', 'cherry', 'blueberry']fruit_count = {}for fruit in fruits:fruit_count[fruit] += 1 # KeyError: 'apple'

• 使用判斷語句檢查

fruits = ['apple', 'orange', 'cherry', 'apple', 'apple', 'cherry', 'blueberry']fruit_count = {}for fruit in fruits:if fruit not in fruit_count:fruit_count[fruit] = 1else:fruit_count[fruit] += 1print(fruit_count)Out:{'apple': 3, 'orange': 1, 'cherry': 2, 'blueberry': 1}

• 使用dict.setdefault()方法

fruits = ['apple', 'orange', 'cherry', 'apple', 'apple', 'cherry', 'blueberry']fruit_count = {}for fruit in fruits:fruit_count.setdefault(fruit, 0)fruit_count[fruit] += 1print(fruit_count)Out:{'apple': 3, 'orange': 1, 'cherry': 2, 'blueberry': 1}

• 使用collections.defaultdict類

# 指定字典的值類型為int，用于計數from collections import defaultdictfruits = ['apple', 'orange', 'cherry', 'apple', 'apple', 'cherry', 'blueberry']fruit_count = defaultdict(int)for fruit in fruits:fruit_count[fruit] += 1print(fruit_count)Out:defaultdict(<class 'int'>, {'apple': 3, 'orange': 1, 'cherry': 2, 'blueberry': 1})# 指定字典的值類型為listseq = [('A', 1), ('B', 2), ('A', 3), ('B', 4), ('C', 1)]d = defaultdict(list)print(d['D']) Out:[]for k, v in seq:d[k].append(v)print(d)Out:defaultdict(<class 'list'>, {'A': [1, 3], 'B': [2, 4], 'C': [1]})# 使用不帶參數的可調用函數from collections import defaultdictdef zero():return 0d = defaultdict(zero)print(d['A'])print(d)Out:0defaultdict(<function zero at 0x00000188F6163DC8>, {'A': 0})# 計數from collections import defaultdictfruits = ['apple', 'orange', 'cherry', 'apple', 'apple', 'cherry', 'blueberry']fruit_count = defaultdict(lambda: 0) # 使用lambda來定義簡單的函數for fruit in fruits:fruit_count[fruit] += 1print(dict(fruit_count))Out:{'apple': 3, 'orange': 1, 'cherry': 2, 'blueberry': 1}

3.1.2 collections.OrderedDict

使用dict時，key是無序的。在對dict做迭代時，我們無法確定key的順序。如果要保持Key的順序，可以用OrderedDict。

from collections import OrderedDictod = OrderedDict([('A', 1), ('B', 2), ('C', 3)])od['D'] = 4od['E'] = 5od['F'] = 6print(od)Out:OrderedDict([('A', 1), ('B', 2), ('C', 3), ('D', 4), ('E', 5), ('F', 6)])# 按鍵排序，創建排序字典d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}od = OrderedDict(sorted(d.items(), key=lambda t: t[0])) print(od)Out:OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])# 按值排序，創建排序字典d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}od = OrderedDict(sorted(d.items(), key=lambda t: t[1])) print(od)Out:OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])# 按鍵的字符長度排序，創建排序字典d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}od = OrderedDict(sorted(d.items(), key=lambda t: len(t[0]))) print(od)Out:OrderedDict([('pear', 1), ('apple', 4), ('banana', 3), ('orange', 2)])

3.1.3 collections.ChainMap

ChainMap 用來成合并多個字典，但和 update 不同，它不會改變原對象，而且效率更高。

from collections import ChainMapa = {'a': 1, 'b': 2}b = {'b': 3, 'c': 4}c = ChainMap(a, b)print(c)Out:ChainMap({'a': 1, 'b': 2}, {'b': 3, 'c': 4})# ChainMap讀取和更新：ChainMap內部存儲了一個名為maps的list用以維護mapping關系, 這個list可以直接查看和修改，修改之后相應ChainMap值也就修改了。print(c.maps)Out:[{'a': 1, 'b': 2}, {'b': 3, 'c': 4}]c.maps[0]['b'] = 5c.maps[1]['b'] = 6print(c)Out:ChainMap({'a': 1, 'b': 5}, {'b': 6, 'c': 4})# 如果不是修改maps這個list，對ChainMap的修改只會影響第一個map，讀取的時候會從第一個map開始讀，直到遇到指定的key。print(c['b'])Out:5# new_child(m=None): 生成一個新的ChainMap, m指定mappings作為第一個mapping，后面跟著原先的mappings。print(c.new_child())print(c.new_child({'d': 10}))Out:ChainMap({}, {'a': 1, 'b': 5}, {'b': 6, 'c': 4})ChainMap({'d': 10}, {'a': 1, 'b': 5}, {'b': 6, 'c': 4})# 返回父ChainMap，由除了第一個map之后的其它mappings組成d = c.new_child({'d': 10})print(d.parents)Out:ChainMap({'a': 1, 'b': 5}, {'b': 6, 'c': 4})

3.1.4 collections.Counter

Counter是dict的一個子類，用于可哈希對象的計數。它是一個無序鍵值對的集合，其中以元素為鍵，值為元素的計數值。

from collections import Counter# 創建Counter對象c = Counter() # 創建一個空counter對象c = Counter(['apple', 'orange', 'apple', 'pear', 'orange']) # 從一個可迭代對象（list、tuple、dict、字符串等）創建c = Counter({'A': 1, 'B': 2}) # 從一個映射對象（字典對象）創建c = Counter(cats=4, dogs=8) # 根據關鍵字參數創建# Counter對象有字典接口，當不存在指定鍵時，返回的計數為0c = Counter({'A': 1, 'B': 2})c['C']Out:0# 統計列表中單詞出現次數cnt = Counter()seq = ['red', 'blue', 'red', 'green', 'blue', 'blue']for color in seq:cnt[color] += 1print(cnt)Out:Counter({'blue': 3, 'red': 2, 'green': 1})# 將counter中元素置0或刪除元素seq = ['red', 'blue', 'red', 'green', 'blue', 'blue']cnt = Counter(seq)cnt['green'] = 0print(cnt)del cnt['green']print(cnt)Out:Counter({'blue': 3, 'red': 2, 'green': 0})Counter({'blue': 3, 'red': 2})# 按照元素出現次數返回一個迭代器，如果元素計數小于1，則忽略。c = Counter(a=4, b=2, c=0, d=-2)print(c.elements())print(sorted(c.elements()))Out:<itertools.chain object at 0x00000188F677D1C8>['a', 'a', 'a', 'a', 'b', 'b']# 使用most_common(n)返回一個list, list中包含Counter對象中出現最多前n個元素。c = Counter('abracadabra')print(c.most_common(3))Out:[('a', 5), ('b', 2), ('r', 2)]# subtractc1 = Counter(a=2, b=3)c2 = Counter(a=1, b=4)c1.subtract(c2)print(c1)Out:Counter({'a': 1, 'b': -1})

3.2 字典并集

def merge(d1, d2):return {**d1, **d2}d1 = {'a':1, 'b':2}d2 = {'c':3, 'd':4}r = merge(d1, d2)print(r)Out:{'a': 1, 'b': 2, 'c': 3, 'd': 4}

3.3 字典差集

def diff(d1, d2):return dict([(k, v) for k, v in d1.items() if k not in d2])d1 = {'a':1, 'b':2, 'c':3}d2 = {'c':3, 'd':4}r = diff(d1, d2) # r = {'a': 1, 'b': 2}

3.4 獲取字典前n個最大值對應的鍵

from heapq import nlargestdef topn_dict(d, n):return nlargest(n, d, key=lambda k: d[k])# 調用函數d = {'a':5, 'b':6, 'c':8, 'd':4}r = topn_dict(d, 2) # r = ['c', 'b']

3.5 一鍵對多值字典

lst = [('a', 1), ('b', 2), ('a', 3), ('b', 4), ('c', 5)]d = {}for k, v in lst:if k not in d:d[k] = []d[k].append(v)print(d)Out:{'a': [1, 3], 'b': [2, 4], 'c': [5]}# 使用 collections模塊中的defaultdictfrom collections import defaultdictd = defaultdict(list)for k, v in lst:d[k].append(v)print(d)Out:defaultdict(<class 'list'>, {'a': [1, 3], 'b': [2, 4], 'c': [5]})

3.6 在字典中根據條件篩選數據

# 生成數據from random import randintd = {"student%d" % i : randint(70, 100) for i in range(1,6)}print(d)# 使用字典解析res= {k:v for k, v in d.items() if v >= 90}print(res)# 使用filter()函數res = dict(filter(lambda item: item[1] >= 90, d.items()))print(res)Out:{'student1': 75, 'student2': 85, 'student3': 91, 'student4': 84, 'student5': 98}{'student3': 91, 'student5': 98}{'student3': 91, 'student5': 98}

--END--

總結

以上是生活随笔為你收集整理的c++中判断某个值在字典的value中_Python核心知识系列：字典的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。