Python 120个字典操作方法

用户11081884

发布于 2026-07-20 18:38:20

300

字典(Dictionary)是Python中最强大、最常用的数据结构之一，它以键值对的形式存储数据，提供了快速的数据查找能力。本文将全面介绍120个字典操作方法，涵盖基础操作、高级技巧和实战应用场景，帮助掌握这一重要数据结构。

一、字典创建方法

1、使用花括号创建空字典

empty_dict = {}

这是创建空字典最简洁的方式。

2、使用dict()构造函数创建空字典

empty_dict = dict()

与花括号方式等效，但不如花括号简洁。

3、直接赋值创建字典

person = {'name': 'Alice', 'age': 25, 'city': 'New York'}

这是最常用的字典创建方式。

4、使用dict()从键值对序列创建

person = dict([('name', 'Alice'), ('age', 25), ('city', 'New York')])

适用于已有键值对序列的情况。

5、使用关键字参数创建字典

person = dict(name='Alice', age=25, city='New York')

语法更简洁，键不需要引号。

6、创建混合键类型字典

mixed_keys = {'name': 'Bob', 42: 'answer', (1, 2): 'tuple as key'}

键可以是字符串、数字或元组等不可变类型。

7、使用fromkeys()创建默认值字典

default_dict = dict.fromkeys(['a', 'b', 'c'], 0)

快速创建具有相同默认值的字典。

8、使用zip()从两个列表创建字典

keys = ['a', 'b', 'c']
values = [1, 2, 3]
my_dict = dict(zip(keys, values))

将两个列表合并为字典的便捷方式。

9、使用字典推导式创建字典

squares = {x: x**2 for x in range(5)}

简洁高效地创建字典。

10、条件过滤创建字典

numbers = [1,2,3,4,5,6]
result = {x: x**2 for x in numbers if x % 2 == 0}

只包含满足条件的元素。

二、字典访问方法

11、通过键直接访问值

print(person['name'])  # Alice

键不存在时会引发KeyError。

12、使用get()方法安全访问

print(person.get('age'))      # 25
print(person.get('gender'))   # None

键不存在时返回None而不报错。

13、带默认值的get()方法

print(person.get('gender', 'unknown'))  # 返回默认值'unknown'

键不存在时返回指定默认值。

14、使用setdefault()获取并设置默认值

value = person.setdefault('phone', '123-456-7890')

键不存在时将其添加到字典并设置默认值。

15、检查键是否存在

if 'name' in person:
    print(person['name'])

使用in运算符检查键是否存在。

16、检查键不存在

if 'gender' not in person:
    print('gender key not found')

使用not in运算符。

17、检查值是否存在

if 25 in person.values():
    print('25 is one of the values')

检查值是否存在于字典中。

18、使用try-except处理缺失键

try:
    value = person['gender']
except KeyError:
    value = 'default'

捕获KeyError异常处理缺失键。

19、安全访问嵌套字典

city = people.get('Alice', {}).get('city', 'Unknown')

避免嵌套字典访问时的KeyError。

20、使用collections.defaultdict处理缺失键

from collections import defaultdict
my_dict = defaultdict(int)
my_dict['a'] += 1  # 自动初始化为0

为不存在的键提供默认值。

三、字典修改方法

21、添加新键值对

person['email'] = 'alice@example.com'

键不存在时为添加操作。

22、修改现有值

person['age'] = 26

键存在时为修改操作。

23、使用update()合并字典

person.update({'city': 'New York', 'age': 26})

批量更新多个键值对。

24、使用update()有条件更新值

my_dict.update((k, v*2) for k, v in my_dict.items() if condition)

根据条件更新字典中的值。

25、根据另一字典更新值

dict1.update((k, dict1[k]+dict2[k]) for k in dict1.keys() & dict2.keys())

根据dict2中的对应值更新dict1。

26、使用字典解包合并字典

merged_dict = {**dict1, **dict2}

Python 3.5+支持的简洁合并方式。

27、使用|操作符合并字典

merged_dict = dict1 | dict2

Python 3.9+新增的合并运算符。

28、使用collections.ChainMap合并字典

from collections import ChainMap
combined = dict(ChainMap(dict1, dict2))

逻辑合并而不创建新字典。

29、使用pop()删除并返回值

age = person.pop('age')

删除键并返回对应的值。

30、带默认值的pop()

gender = person.pop('gender', 'unknown')

键不存在时返回默认值而不报错。

四、字典遍历方法

31、遍历所有键

for key in person:
    print(key, person[key])

最基础的字典遍历方式。

32、显式遍历键

for key in person.keys():
    print(key)

使用keys()方法更明确。

33、遍历所有值

for value in person.values():
    print(value)

只关注字典中的值。

34、遍历键值对

for key, value in person.items():
    print(f"{key}: {value}")

同时获取键和值的最常用方式。

35、反向迭代字典

for key in reversed(person):
    print(key, person[key])

Python 3.7+保持插入顺序，可以反向迭代。

36、有序遍历键

for key in sorted(person):
    print(key, person[key])

按键排序后遍历。

37、按值排序遍历

for key, value in sorted(person.items(), key=lambda x: x:
    print(key, value)

按值排序后遍历。

38、条件过滤遍历

for key, value in person.items():
    if value > 20:
        print(key, value)

只遍历满足条件的元素。

39、使用enumerate遍历

for i, (key, value) in enumerate(person.items()):
    print(i, key, value)

同时获取索引和键值对。

40、批量处理遍历

from itertools import islice
batch_size = 10
for batch in iter(lambda: list(islice(person.items(), batch_size)), []):
    process_batch(batch)

处理大型字典时分批处理。

五、字典转换方法

41、转换为键列表

keys = list(person.keys())

获取字典所有键的列表。

42、转换为值列表

values = list(person.values())

获取字典所有值的列表。

43、转换为键值对列表

items = list(person.items())

获取(key, value)元组列表。

44、转换为JSON字符串

import json
json_str = json.dumps(person)

字典与JSON字符串相互转换。

45、从JSON字符串加载

person = json.loads(json_str)

JSON字符串转回字典。

46、字典键转换为字符串

str_dict = {str(key): value for key, value in person.items()}

确保所有键为字符串类型。

47、字典值类型转换

int_values = {k: int(v) for k, v in person.items()}

将所有值转换为特定类型。

48、转换为具名元组

from collections import namedtuple
Person = namedtuple('Person', person.keys())
person_nt = Person(**person)

字典转具名元组便于访问。

49、转换为pandas DataFrame

import pandas as pd
df = pd.DataFrame(list(person.items()), columns=['key', 'value'])

字典转DataFrame便于分析。

50、反转键值对

inverted = {v: k for k, v in person.items()}

交换键和值的位置。

51、条件过滤转换

filtered = {k: v for k, v in person.items() if v > 20}

只保留满足条件的键值对。

52、键重命名转换

renamed = {'new_'+k: v for k, v in person.items()}

批量修改键名。

53、值映射转换

mapped = {k: func(v) for k, v in person.items()}

对所有值应用函数转换。

54、嵌套字典扁平化

flat = {k+'_'+k2: v2 for k, nested in person.items() for k2, v2 in nested.items()}

将多级嵌套字典展平。

55、从元组列表创建字典

tuple_list = [('a', 1), ('b', 2)]
dict_from_tuples = dict(tuple_list)

元组列表转字典。

56、字典转字符串

dict_str = str(person)

获取字典的字符串表示。

57、字典转集合

keys_set = set(person.keys())

获取键的集合便于集合操作。

58、字典值去重

unique_values = set(person.values())

获取唯一值集合。

59、使用map转换所有值

transformed = dict(map(lambda item: (item[0], func(item), person.items()))

函数式编程方式转换值。

60、字典分组

from itertools import groupby
grouped = {k: list(v) for k, v in groupby(sorted(items, key=key_func), key=key_func)}

按特定条件分组字典。

六、字典高级技巧

61、嵌套字典操作

employees = {
    'Alice': {'age': 25, 'position': 'Developer'},
    'Bob': {'age': 30, 'position': 'Manager'}
}
print(employees['Alice']['age'])

处理多层嵌套字典。

62、嵌套字典安全访问

age = employees.get('Alice', {}).get('age', 0)

避免嵌套访问时的KeyError。

63、字典推导式条件过滤

high_grades = {k: v for k, v in grades.items() if v >= 90}

根据条件筛选字典元素。

64、字典推导式键值转换

squared = {k: v**2 for k, v in original.items()}

对键或值进行转换。

65、字典视图操作

keys_view = person.keys()
values_view = person.values()
items_view = person.items()

获取字典的动态视图对象。

66、字典视图集合操作

common_keys = dict1.keys() & dict2.keys()
unique_items = dict1.items() - dict2.items()

对字典视图进行集合运算。

67、字典排序操作

sorted_by_key = dict(sorted(person.items()))
sorted_by_value = dict(sorted(person.items(), key=lambda x: x)

按键或值排序字典。

68、字典交集

common = dict(dict1.items() & dict2.items())

找出两个字典共有的键值对。

69、字典差集

difference = dict(dict1.items() - dict2.items())

找出dict1独有的键值对。

70、字典对称差集

sym_diff = dict(dict1.items() ^ dict2.items())

找出两个字典互不相同的键值对。

71、字典合并冲突解决

merged = {**dict1, **dict2, **dict3}

后面字典的值会覆盖前面字典的值。

72、字典条件合并

merged = {k: dict1.get(k, 0) + dict2.get(k, 0) for k in set(dict1) | set(dict2)}

合并时对值进行特定操作。

73、字典批量更新

updates = {'a': 1, 'b': 2}
person.update(updates)

批量更新多个键值对。

74、字典子集提取

subset = {k: person[k] for k in ['name', 'age'] if k in person}

提取指定键的子字典。

75、字典键重映射

key_map = {'old_key': 'new_key'}
remapped = {key_map.get(k, k): v for k, v in person.items()}

批量重命名字典键。

76、字典值统计

from collections import Counter
value_counts = Counter(person.values())

统计字典值出现的频率。

77、字典内存占用检查

import sys
size = sys.getsizeof(person)

获取字典占用的内存大小。

78、字典比较

are_equal = dict1 == dict2

比较两个字典是否相同。

79、字典浅拷贝

copy_dict = person.copy()

创建字典的浅拷贝。

80、字典深拷贝

import copy
deep_copy = copy.deepcopy(person)

创建字典的深拷贝，适用于嵌套字典。

81、字典键前缀处理

prefixed = {'prefix_'+k: v for k, v in person.items()}

为所有键添加前缀。

82、字典键后缀处理

suffixed = {k+'_suffix': v for k, v in person.items()}

为所有键添加后缀。

83、字典键大小写转换

lower_keys = {k.lower(): v for k, v in person.items()}

统一键的大小写形式。

84、字典值大小写转换

upper_values = {k: v.upper() if isinstance(v, str) else v for k, v in person.items()}

对字符串值统一大小写。

85、字典键类型转换

str_keys = {str(k): v for k, v in person.items()}

确保所有键为字符串类型。

86、字典值类型转换

int_values = {k: int(v) for k, v in person.items() if str(v).isdigit()}

转换值为整数类型。

87、字典键值交换条件

swapped = {v: k for k, v in person.items() if isinstance(v, (int, float, str))}

仅交换符合条件的键值对。

88、字典分组聚合

from collections import defaultdict
grouped = defaultdict(list)
for k, v in data:
    grouped[k].append(v)

按键分组并聚合值。

89、字典最大值键

max_key = max(person, key=lambda k: person[k])

找出值最大的键。

90、字典最小值键

min_key = min(person, key=lambda k: person[k])

找出值最小的键。

七、字典实战应用

91、统计单词频率

word_count = {}
for word in text.split():
    word_count[word] = word_count.get(word, 0) + 1

经典的字频统计应用。

92、JSON数据解析

import json
with open('data.json') as f:
    data = json.load(f)

字典是处理JSON数据的自然结构。

93、配置文件处理

config = {
    'database': {
        'host': 'localhost',
        'port': 5432,
        'user': 'admin'
    }
}

使用嵌套字典管理配置。

94、缓存实现

cache = {}
def get_data(key):
    if key not in cache:
        cache[key] = load_data(key)
    return cache[key]

简单的内存缓存实现。

95、数据索引

index = {}
for i, record in enumerate(data):
    index[record['id']] = i

为数据创建快速查找索引。

96、属性存储

class AttrDict(dict):
    def __getattr__(self, key):
        return self[key]

通过属性访问字典键。

97、枚举替代

Colors = {'RED': 1, 'GREEN': 2, 'BLUE': 3}

简单枚举功能的实现。

98、数据分组

grouped = defaultdict(list)
for item in data:
    grouped[item['category']].append(item)

按类别分组数据。

99、数据转换

mapping = {'A': 'Excellent', 'B': 'Good'}
converted = [mapping.get(grade, 'Unknown') for grade in grades]

八、使用字典进行数据值转换

100、命令分发

from typing import Callable, Dict

def cmd_help() -> None:
    print("help: show this message")

def cmd_exit() -> None:
    print("bye!")
    exit()

commands: Dict[str, Callable[[], None]] = {"help": cmd_help, "exit": cmd_exit}

运行时调用

commands[commond]()

101、状态管理

state: dict = {"logged_in": False, "user": None}

102、数据清洗

clean_data = {k: clean_func(v) for k, v in raw_data.items()}     # type: ignore

103、数据验证

schema = {"name": str, "age": int}
valid = all(isinstance(v, schema[k]) for k, v in data.items())

104、数据采样

import random
sample = dict(random.sample(data.items(), 5))

105、数据分块

chunks = [dict(list(data.items())[i : i + 10]) for i in range(0, len(data), 10)]

106、数据透视

pivot = {(x["year"], x["month"]): x["value"] for x in data}

107、数据聚合

from collections import defaultdict

totals: defaultdict[str, float] = defaultdict(float)
for record in data:
    totals[record["category"]] += record["amount"]

108、数据过滤

filtered = {k: v for k, v in data.items() if v > threshold}

109、数据归一化

max_val = max(data.values())
normalized = {k: v / max_val for k, v in data.items()}

110、数据合并

merged = {}
for d in dict_list:
    merged.update(d)

111、数据排序输出

for k, v in sorted(data.items(), key=lambda kv: -kv[1]):
    print(f"{k}: {v}")

112、数据转换管道

from functools import reduce

pipeline = [clean_func, transform_func, filter_func]  # type: ignore
result = reduce(lambda d, f: f(d), pipeline, data)

113、数据差异比较

diff = {
    k: (dict1[k], dict2[k])
    for k in dict1
    if k in dict2 and dict1[k] != dict2[k]
}

114、数据补全

defaults = {"name": "", "age": 0, "city": "Unknown"}
complete = defaults | user_data

115、数据掩码

sensitive = {"password", "token"}
masked = {k: "*****" if k in sensitive else v for k, v in data.items()}

116、数据抽样

sample = {k: data[k] for k in random.sample(list(data.keys()), 10)}

117、数据分箱

bins = defaultdict(list)
for k, v in data.items():
    bins[int(v / bin_size)].append(k)

118、数据扩展

expanded = {f"{k}_{i}": v + i for k, v in data.items() for i in range(3)}

119、数据逆序

reversed_dict = dict(reversed(data.items()))

120、数据分页

page_size = 10
pages = [dict(list(data.items())[i : i + page_size]) for i in range(0, len(data), page_size)]

字典在Python编程中的应用场景极为广泛，从简单的配置管理到复杂的数据分析，都离不开字典的支持。Python字典的120个操作方法，涵盖了从基础创建、访问、修改到高级技巧和实战应用的各个方面。字典作为Python中最重要、最高效的数据结构之一，其灵活性和强大功能使其成为处理键值对数据的首选工具。通过掌握这些字典操作技巧：