学研君 2025-04-08 12:04 浙江
Python 字典使用秘籍：100 个技巧带你玩转键值对。
Python 字典使用秘籍：100 个技巧带你玩转键值对。
在Python编程的世界里，字典作为一种极为重要的内置数据类型，承载着无序键值对集合的功能，在其他编程语言中，它还有关联数组、哈希映射等别称。通过简洁的花括号{}以及冒号:，我们就能定义字典。
以如下代码为例，
my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
其中'key1'、'key2'和'key3'是键，'value1'、'value2'和'value3'是对应的值。
Python中字典具备无序性（自Python 3.7起保持插入顺序）、可变性、动态性等特性，键类型灵活但必须不可变，且键唯一。
掌握字典的使用技巧，有利于提升Python编程效率，接下来分享100个高效使用Python字典的技巧：
my_dict = {key: value for key, value in iterable}
dict.update()更新值：根据条件更新字典中的值。my_dict.update((k, v * 2) for k, v in my_dict.items() if condition)
update 方法合并字典，用新值更新已有的键。dict1.update(dict2)
update 一次性更新多个键。update_dict = {'key1': 'new_value1', 'key2': 'new_value2'}
my_dict.update(update_dict)
dict2 中的对应值更新 dict1 中的值。dict1.update((k, dict1[k] + dict2[k]) for k in dict1.keys() & dict2.keys())
keys = ['a', 'b', 'c']
values = [1, 2, 3]
my_dict = dict(zip(keys, values))
my_function(**my_dict)
**解包合并字典：使用 ** 解包操作符合并字典。merged_dict = {**dict1, **dict2}
update 方法或 ** 解包操作符合并字典。dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1.update(dict2)
# 或者
merged_dict = {**dict1, **dict2}
defaultdict设置默认值：从 collections 模块中使用 defaultdict 来设置默认值。from collections import defaultdict
my_dict = defaultdict(int)
defaultdict处理缺失键：使用带有自定义工厂函数的 defaultdict 优雅地处理缺失键。from collections import defaultdict
my_dict = defaultdict(lambda: "default_value")
collections.defaultdict设置默认值：使用带有默认工厂函数的 defaultdict 简化对值进行递增的代码。from collections import defaultdict
my_dict = defaultdict(int)
my_dict['key'] += 1
setdefault设置默认值：使用 setdefault 在键存在时获取值，不存在时设置默认值。my_dict.setdefault(key, default_value)
get避免键错误：使用 get 来获取值，如果键不存在则返回默认值。value = my_dict.get(key, default_value)
items() 高效地迭代键值对。for key, value in my_dict.items():
print(key, value)
keys() 和 values() 获取动态视图对象。key_view = my_dict.keys()
value_view = my_dict.values()
del 高效地删除键。del my_dict[key]
my_dict = {'a': 1, 'b': 2, 'c': 3}
new_dict = my_dict.copy()
json.dumps 和 json.loads 方便地在字典和JSON字符串之间进行转换。import json
json_string = json.dumps(my_dict)
new_dict = json.loads(json_string)
sorted 函数按排序后的顺序迭代键。for key in sorted(my_dict):
print(key, my_dict[key])
| 操作符合并字典。merged_dict = dict1 | dict2
dict.fromkeys进行键转换：使用 dict.fromkeys 创建带有默认值的字典。default_dict = dict.fromkeys(my_keys, default_value)
unique_list = list(dict.fromkeys(my_list))
unique_dict = {k: v for k, v in my_dict.items() if v not in set(unique_dict.values())}
itertools.groupby去重字典中的连续重复元素：使用 itertools.groupby 删除字典中连续的重复元素。unique_dict = {k: next(g) for k, g in groupby(sorted(my_dict.items()))}
Counter计数：利用 collections 模块中的 Counter 类统计元素出现的次数。from collections import Counter
element_counts = Counter(my_list)
types.MappingProxyType创建不可变字典：使用 types.MappingProxyType 创建字典的不可变版本。from types import MappingProxyType
immutable_dict = MappingProxyType(my_dict)
keys = list(my_dict.keys())
values = list(my_dict.values())
items = list(my_dict.items())
inverted_dict = {v: k for k, v in my_dict.items()}
ChainMap合并字典：使用 ChainMap 逻辑上合并多个字典。from collections import ChainMap
combined_dict = dict(ChainMap(dict1, dict2))
import sys
size_in_bytes = sys.getsizeof(my_dict)
are_equal = dict1 == dict2
pop 删除键并获取其对应的值。value = my_dict.pop(key, default_value)
popitem后进先出删除：使用 popitem() 高效地删除并获取最后一个键值对。last_item = my_dict.popitem()
pop 在键不存在时删除键且不抛出异常。deleted_value = my_dict.pop(key, None)
& 操作符或 dict.items() 的交集方法查找共同的键值对。common_items = dict1.items() & dict2.items()
in 检查键是否存在而不抛出异常。key_exists = key in my_dict
map 或字典推导式对所有值应用函数。modified_dict = {k: my_function(v) for k, v in my_dict.items()}
40.__missing__方法（Python 3.3+）：在自定义字典类中定义 __missing__ 方法，以控制在找不到键时的行为。class CustomDict(dict):
def __missing__(self, key):
return "default_value"
dict()合并字典：通过将字典转换为键值对列表来合并字典。combined_dict = dict(list(dict1.items()) + list(dict2.items()))
copy模块进行深拷贝：使用 copy.deepcopy 创建嵌套字典的深拷贝。import copy
deep_copy = copy.deepcopy(my_dict)
zip 初始化字典以提高内存效率。keys = ['a', 'b', 'c']
values = [1, 2, 3]
my_dict = dict(zip(keys, values))
str_dict = {str(key): value for key, value in my_dict.items()}
exclusive_items = dict1.items() ^ dict2.items()
for key in my_dict.keys():
# ...
for value in my_dict.values():
# ...
for key, value in my_dict.items():
# ...
filter过滤字典：使用 filter 创建只包含某些键值对的字典。filtered_dict = dict(filter(lambda item: condition(item), my_dict.items()))
filtered_dict = {key: value for key, value in my_dict.items() if condition}
map进行过滤和映射：对字典使用 filter 和 map 函数进行高效的过滤和映射。mapped_dict = dict(map(lambda item: (key_transform(item[0]), value_transform(item[1])), my_dict.items()))
filter高效求字典交集：使用 filter 高效查找字典的交集。common_items = dict(filter(lambda item: item in dict2.items(), dict1.items()))
collections.OrderedDict有序字典：使用 OrderedDict 保持键插入的顺序。from collections import OrderedDict
ordered_dict = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
tuple_list = list(my_dict.items())
map转换键：使用 map 在保持值不变的情况下转换键。transformed_dict = dict(map(lambda k: (transform_key(k), my_dict[k]), my_dict.keys()))
tuple_list = [('a', 1), ('b', 2), ('c', 3)]
my_dict = dict(tuple_list)
+ 操作符合并字典（注：实际Python中字典不能直接用+拼接，这里原文表述有误）。concatenated_dict = dict1 + dict2
map 原地转换值。my_dict.update((k, my_transform_function(v)) for k, v in my_dict.items())
itertools.groupby分组：使用 itertools.groupby 按特定键对字典进行分组。from itertools import groupby
grouped_dict = {k: list(v) for k, v in groupby(sorted(my_dict.items(), key=lambda x: x[0]), key=lambda x: x[0])}
case_insensitive_dict = {key.lower(): value for key, value in my_dict.items()}
get和默认值安全访问嵌套字典：使用带有默认值的 get 安全访问嵌套字典的值。nested_value = my_dict.get('key1', {}).get('key2', default_value)
sort方法，需转换为列表等可排序对象后操作，这里原文表述有误）。my_dict.sort() # 按键排序
my_dict.sort(key=lambda x: x[1]) # 按值排序
try和except**：使用 try 和 except 高效检查键是否存在。try:
value = my_dict[key]
except KeyError:
value = default_value
__hash__ 和 __eq__ 方法，使用自定义对象作为字典的键。class CustomKey:
def __init__(self, key_data):
self.key_data = key_data
def __hash__(self):
return hash(self.key_data)
def __eq__(self, other):
return isinstance(other, CustomKey) and self.key_data == other.key_data
my_dict = {CustomKey('a'): 1, CustomKey('b'): 2}
collections.Counter计数：使用 Counter 高效统计列表或可迭代对象中元素的出现次数。from collections import Counter
element_counts = Counter(my_list)
map转换值：使用 map 对字典中的所有值应用函数。transformed_dict = {k: my_function(v) for k, v in my_dict.items()}
itertools.islice进行批量处理：使用 itertools.islice 对大型字典进行批量处理。from itertools import islice
batch_size = 10
for batch in iter(lambda: list(islice(my_dict.items(), batch_size)), []):
# 处理批次
reversed 反向迭代键或项。for key in reversed(my_dict):
# ...
& 操作符高效求字典的交集。common_dict = dict1 & dict2
unique_values = set(my_dict.values())
from collections import namedtuple
MyNamedTuple = namedtuple('MyNamedTuple', my_dict.keys())
my_namedtuple = MyNamedTuple(**my_dict)
- 操作符或 difference 方法查找第一个字典独有的元素。unique_items = dict1.items() - dict2.items()
swapped_dict = {v: k for k, v in my_dict.items()}
all判断字典是否相等： 使用all函数检查所有键值对是否匹配。are_equal = all(dict1[key] == dict2[key] for key in dict1.keys() & dict2.keys())
subset_dict = {k: my_dict[k] for k in desired_keys if k in my_dict}
nested_value = my_dict.get('key1', {}).get('key2', {}).get('key3', default_value)
sorted_dict = dict(sorted(my_dict.items(), key=lambda x: custom_sort_function(x[0])))
keys = ['a', 'b', 'c']
values = [1, 2, 3]
my_dict = dict(zip(keys, values))
pandas库将字典转换为数据框。import pandas as pd
df = pd.DataFrame(list(my_dict.items()), columns=['key', 'value'])
flat_dict = {k + '_' + k2: v2 for k, nested_dict in my_dict.items() for k2, v2 in nested_dict.items()}
itertools.groupby进行批量处理： 使用itertools.groupby对已排序的字典进行批量处理。from itertools import groupby
for key, group in groupby(sorted(my_dict.items(), key=lambda x: x[0]), key=lambda x: x[0]):
# 处理分组
key_intersection = my_dict.keys() & other_dict.keys()
value_difference = my_dict.values() - other_dict.values()
any函数高效检查是否有任何值满足特定条件。has_condition_met = any(value > 10 for value in my_dict.values())
itertools.cycle交替访问字典的键和值。from itertools import cycle
alternating_items = {k: v for k, v in zip(my_dict.keys(), cycle(my_dict.values()))}
defaultdict： 使用带有工厂函数的defaultdict高效初始化嵌套字典。from collections import defaultdict
nested_dict = defaultdict(dict)
key_exists = key in set(my_dict)
collections.ChainMap合并字典： 使用collections.ChainMap合并字典，而不创建新字典。from collections import ChainMap
combined_dict = dict(ChainMap(dict1, dict2))
inverted_dict = {v: k for k, v in my_dict.items()}
iteritems进行内存高效的迭代： 使用iteritems进行内存高效的迭代，特别是对于大型字典。for key, value in my_dict.iteritems():
# ...
key_set = set(my_dict.keys())
set_of_frozensets = {frozenset(item) for item in my_dict.items()}
if my_dict:
# 字典不为空
my_dict.clear()
set.symmetric_difference求字典的对称差： 使用集合操作找出两个字典的对称差。symmetric_difference = set(my_dict1.items()).symmetric_difference(my_dict2.items())
keys_to_extract = ['key1', 'key2']
sub_dict = {k: my_dict[k] for k in keys_to_extract if k in my_dict}
next并设置默认值： 使用next函数并设置默认值，以获取下一个值；若迭代器耗尽，则返回默认值。next_value = next(iter(my_dict.values()), default_value)
key_exists = my_dict.get(key) is not None
prefix = 'prefix_'
prefixed_dict = {prefix + k: v for k, v in my_dict.items()}
import re
filtered_dict = {k: v for k, v in my_dict.items() if re.match(pattern, k)}
exclusive_items = dict1.items() ^ dict2.items()
common_items = my_dict.viewitems() & other_dict.viewitems()
max_values = {k: max(d[k] for d in list_of_dicts) for k in set.union(*(d.keys() for d in list_of_dicts))}
需要说明的是，上述代码中的viewitems()在 Python 3 里已被items()替代，iteritems()在 Python 3 中也不存在了，可直接用items()进行迭代。
希望本文介绍的 100 个技巧能成为你 Python 编程路上的得力助手，帮助你更高效地处理数据，编写出更简洁、健壮的代码。记得在实际编程中多多练习、灵活运用，不断探索 Python 字典的更多可能。
