当前位置：
  1. 首页
  2. 软件开发
  3. python
  4. 正文

Python字典操作详解

python 0 0

字典（Dictionary）是Python中最重要的数据结构之一，它提供了一种灵活的方式来存储和操作键值对数据。本教程将全面深入地讲解Python字典的各种操作技巧，从基础创建到高级应用，涵盖所有核心知识点和实用技巧。

1. 字典基础概念

字典在Python中是一种可变、无序的数据结构，由键值对（key-value pairs）组成。键必须是唯一且不可变的（如字符串、数字或元组），而值可以是任意数据类型。字典用花括号{}表示，键值对之间用冒号分隔，各对之间用逗号分隔。

1.1. 为什么选择字典

高效查找：字典基于哈希表实现，平均时间复杂度为O(1)，适合快速查找

灵活性强：可以存储各种类型的值，支持嵌套结构

内存效率：比列表更节省内存（当需要关联存储时）

动态性：可以随时添加、修改或删除元素

2. 创建字典

2.1. 使用花括号创建空字典

# 创建一个空字典
empty_dict = {}
print(f"空字典: {empty_dict}")
print(f"类型: {type(empty_dict)}")

输出：

空字典: {}
类型: <class 'dict'>

2.2. 使用花括号创建带初始值的字典

# 创建包含多个键值对的字典
person = {
    "name": "张三",
    "age": 30,
    "gender": "男",
    "married": True
}
print(f"个人信息: {person}")

输出：

个人信息: {'name': '张三', 'age': 30, 'gender': '男', 'married': True}

2.3. 使用dict()构造函数创建字典

# 使用关键字参数创建
user = dict(name="李四", age=25, email="lisi@example.com")
print(f"用户信息: {user}")

# 使用键值对列表创建
pairs = [("a", 1), ("b", 2), ("c", 3)]
num_dict = dict(pairs)
print(f"数字字典: {num_dict}")

输出：

用户信息: {'name': '李四', 'age': 25, 'email': 'lisi@example.com'}
数字字典: {'a': 1, 'b': 2, 'c': 3}

2.4. 使用字典推导式创建

# 创建平方数字典
squares = {x: x**2 for x in range(1, 6)}
print(f"平方数字典: {squares}")

# 创建条件字典
even_squares = {x: x**2 for x in range(1, 11) if x % 2 == 0}
print(f"偶数平方数字典: {even_squares}")

输出：

平方数字典: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
偶数平方数字典: {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

3. 访问字典元素

3.1. 使用方括号访问

student = {"name": "王五", "age": 20, "major": "计算机科学"}

# 直接访问存在的键
print(f"姓名: {student['name']}")
print(f"专业: {student['major']}")

# 尝试访问不存在的键会引发KeyError
try:
    print(student['grade'])
except KeyError as e:
    print(f"错误: {e}")

输出：

姓名: 王五
专业: 计算机科学
错误: 'grade'

3.2. 使用get()方法安全访问

# 使用get()方法访问存在的键
print(f"年龄: {student.get('age')}")

# 使用get()方法访问不存在的键（返回None）
print(f"成绩: {student.get('grade')}")

# 指定默认值
print(f"成绩(默认值): {student.get('grade', '未提供')}")

输出：

年龄: 20
成绩: None
成绩(默认值): 未提供

3.3. 使用keys()、values()和items()方法

# 获取所有键
print(f"所有键: {list(student.keys())}")

# 获取所有值
print(f"所有值: {list(student.values())}")

# 获取所有键值对
print(f"所有键值对: {list(student.items())}")

输出：

所有键: ['name', 'age', 'major']
所有值: ['王五', 20, '计算机科学']
所有键值对: [('name', '王五'), ('age', 20), ('major', '计算机科学')]

4. 修改字典

4.1. 添加或更新单个键值对

config = {"host": "localhost", "port": 8080}

# 更新存在的键
config["port"] = 8000
print(f"更新端口: {config}")

# 添加新键
config["timeout"] = 30
print(f"添加超时设置: {config}")

输出：

更新端口: {'host': 'localhost', 'port': 8000}
添加超时设置: {'host': 'localhost', 'port': 8000, 'timeout': 30}

4.2. 使用update()方法批量更新

# 初始字典
defaults = {"color": "blue", "size": "M", "quantity": 10}

# 使用update()更新多个键
defaults.update({"size": "L", "quantity": 15, "material": "cotton"})
print(f"更新后: {defaults}")

输出：

更新后: {'color': 'blue', 'size': 'L', 'quantity': 15, 'material': 'cotton'}

4.3. 使用setdefault()方法添加默认值

# 初始字典
inventory = {"apples": 50, "oranges": 30}

# 如果键存在则返回其值，不存在则添加并返回默认值
apples_count = inventory.setdefault("apples", 0)
print(f"苹果数量: {apples_count}")

bananas_count = inventory.setdefault("bananas", 0)
print(f"香蕉数量: {bananas_count}")

print(f"当前库存: {inventory}")

输出：

苹果数量: 50
香蕉数量: 0
当前库存: {'apples': 50, 'oranges': 30, 'bananas': 0}

5. 删除字典元素

5.1. 使用del删除键值对

employee = {"name": "赵六", "id": 1001, "dept": "研发"}

# 删除特定键
del employee["dept"]
print(f"删除部门后: {employee}")

# 尝试删除不存在的键会引发KeyError
try:
    del employee["salary"]
except KeyError as e:
    print(f"删除错误: {e}")

输出：

删除部门后: {'name': '赵六', 'id': 1001}
删除错误: 'salary'

5.2. 使用pop()方法删除并返回值

product = {"name": "手机", "price": 2999, "stock": 100}

# 删除并获取值
price = product.pop("price")
print(f"已删除价格: {price}")
print(f"剩余信息: {product}")

# 尝试删除不存在的键（会引发KeyError）
try:
    product.pop("discount")
except KeyError as e:
    print(f"错误: {e}")

# 提供默认值避免错误
discount = product.pop("discount", 0)
print(f"折扣(默认值): {discount}")

输出：

已删除价格: 2999
剩余信息: {'name': '手机', 'stock': 100}
错误: 'discount'
折扣(默认值): 0

5.3. 使用popitem()删除最后一个元素

# 注意：在Python 3.7+中，popitem()删除并返回最后一个插入的元素
settings = {"theme": "dark", "font": "Arial", "size": 14}

# 删除并返回最后一个元素
last_item = settings.popitem()
print(f"已删除项: {last_item}")
print(f"剩余设置: {settings}")

输出（可能因插入顺序不同而变化）：

已删除项: ('size', 14)
剩余设置: {'theme': 'dark', 'font': 'Arial'}

5.4. 使用clear()清空字典

cache = {"data": "样本", "timestamp": 1625097600}
print(f"清空前: {cache}")

cache.clear()
print(f"清空后: {cache}")

输出：

清空前: {'data': '样本', 'timestamp': 1625097600}
清空后: {}

6. 遍历字典

6.1. 遍历所有键

scores = {"数学": 95, "英语": 88, "物理": 92}

for subject in scores:
    print(f"科目: {subject}")

输出：

科目: 数学
科目: 英语
科目: 物理

6.2. 遍历所有值

for score in scores.values():
    print(f"分数: {score}")

输出：

分数: 95
分数: 88
分数: 92

6.3. 遍历键值对

for subject, score in scores.items():
    print(f"{subject}: {score}分")

输出：

数学: 95分
英语: 88分
物理: 92分

6.4. 使用enumerate()遍历带索引

for index, (subject, score) in enumerate(scores.items()):
    print(f"{index + 1}. {subject}: {score}分")

输出：

1. 数学: 95分
2. 英语: 88分
3. 物理: 92分

7. 字典常用方法

7.1. copy()方法

original = {"a": 1, "b": [2, 3]}

# 创建浅拷贝
duplicate = original.copy()

# 修改原始字典中的不可变元素
duplicate["a"] = 100
print(f"原始字典: {original}")
print(f"拷贝字典: {duplicate}")

# 修改嵌套的可变元素
duplicate["b"].append(4)
print(f"修改嵌套列表后:")
print(f"原始字典: {original}")
print(f"拷贝字典: {duplicate}")

输出：

原始字典: {'a': 1, 'b': [2, 3]}
拷贝字典: {'a': 100, 'b': [2, 3]}
修改嵌套列表后:
原始字典: {'a': 1, 'b': [2, 3, 4]}
拷贝字典: {'a': 100, 'b': [2, 3, 4]}

7.2. fromkeys()方法

# 使用fromkeys()创建所有键具有相同值的字典
keys = ["name", "age", "gender"]
default_values = dict.fromkeys(keys, "未知")
print(f"默认字典: {default_values}")

# 使用fromkeys()创建所有值为None的字典
none_values = dict.fromkeys(keys)
print(f"空值字典: {none_values}")

输出：

默认字典: {'name': '未知', 'age': '未知', 'gender': '未知'}
空值字典: {'name': None, 'age': None, 'gender': None}

7.3. 检查键是否存在

data = {"username": "admin", "password": "secret"}

# 使用in关键字
if "username" in data:
    print("用户名存在")

# 使用not in检查不存在
if "email" not in data:
    print("电子邮件不存在")

输出：

用户名存在
电子邮件不存在

8. 字典推导式

8.1. 基本字典推导式

# 创建数字及其平方的字典
squares = {num: num ** 2 for num in range(1, 6)}
print(f"平方数: {squares}")

# 创建字符及其ASCII码的字典
ascii_dict = {char: ord(char) for char in "abcde"}
print(f"ASCII码: {ascii_dict}")

输出：

平方数: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
ASCII码: {'a': 97, 'b': 98, 'c': 99, 'd': 100, 'e': 101}

8.2. 带条件的字典推导式

# 创建偶数及其平方的字典
even_squares = {x: x**2 for x in range(1, 11) if x % 2 == 0}
print(f"偶数平方: {even_squares}")

# 创建过滤掉特定键的字典
data = {"a": 1, "b": 2, "c": 3, "d": 4}
filtered = {k: v for k, v in data.items() if k not in ["a", "c"]}
print(f"过滤后: {filtered}")

输出：

偶数平方: {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}
过滤后: {'b': 2, 'd': 4}

8.3. 多重迭代字典推导式

# 创建两个序列的组合字典
letters = ["a", "b", "c"]
numbers = [1, 2, 3]
combined = {l: n for l in letters for n in numbers if n > 1}
print(f"组合字典: {combined}")

输出：

组合字典: {'a': 2, 'a': 3, 'b': 2, 'b': 3, 'c': 2, 'c': 3}

9. 字典的嵌套

9.1. 创建嵌套字典

# 嵌套字典示例
students = {
    "班级A": {
        "张三": {"语文": 85, "数学": 90},
        "李四": {"语文": 78, "数学": 88}
    },
    "班级B": {
        "王五": {"语文": 92, "数学": 95},
        "赵六": {"语文": 88, "数学": 91}
    }
}
print(f"学生数据: {students}")

9.2. 访问嵌套字典元素

# 访问特定班级的学生
print(f"班级A的学生: {students['班级A']}")

# 访问特定学生的成绩
print(f"张三的数学成绩: {students['班级A']['张三']['数学']}")

# 安全访问嵌套元素
try:
    print(f"班级C的学生: {students['班级C']}")
except KeyError:
    print("班级C不存在")

9.3. 修改嵌套字典

# 添加新学生
students["班级A"]["钱七"] = {"语文": 80, "数学": 85}
print(f"添加新学生后: {students['班级A']}")

# 更新成绩
students["班级A"]["张三"]["数学"] = 92
print(f"张三更新后的数学成绩: {students['班级A']['张三']['数学']}")

10. 字典的排序

10.1. 按键排序

scores = {"数学": 95, "英语": 88, "物理": 92, "化学": 90}

# 按键升序排序
sorted_keys = sorted(scores.items())
print(f"按键升序排序: {sorted_keys}")

# 按键降序排序
sorted_keys_desc = sorted(scores.items(), reverse=True)
print(f"按键降序排序: {sorted_keys_desc}")

输出：

按键升序排序: [('数学', 95), ('英语', 88), ('物理', 92), ('化学', 90)]
按键降序排序: [('英语', 88), ('物理', 92), ('数学', 95), ('化学', 90)]

10.2. 按值排序

# 按值升序排序
sorted_values = sorted(scores.items(), key=lambda item: item[1])
print(f"按值升序排序: {sorted_values}")

# 按值降序排序
sorted_values_desc = sorted(scores.items(), key=lambda item: item[1], reverse=True)
print(f"按值降序排序: {sorted_values_desc}")

输出：

按值升序排序: [('英语', 88), ('化学', 90), ('物理', 92), ('数学', 95)]
按值降序排序: [('数学', 95), ('物理', 92), ('化学', 90), ('英语', 88)]

10.3. 创建有序字典

from collections import OrderedDict

# 创建有序字典
ordered_dict = OrderedDict()
ordered_dict["first"] = 1
ordered_dict["second"] = 2
ordered_dict["third"] = 3

print(f"有序字典: {ordered_dict}")
print(f"键的顺序: {list(ordered_dict.keys())}")

输出：

有序字典: OrderedDict([('first', 1), ('second', 2), ('third', 3)])
键的顺序: ['first', 'second', 'third']

11. 字典的浅拷贝与深拷贝

11.1. 浅拷贝问题示例

original = {"a": 1, "b": [2, 3]}
shallow_copy = original.copy()

# 修改不可变元素
shallow_copy["a"] = 100
print(f"修改不可变元素后:")
print(f"原始字典: {original}")
print(f"浅拷贝字典: {shallow_copy}")

# 修改可变元素
shallow_copy["b"].append(4)
print(f"\n修改可变元素后:")
print(f"原始字典: {original}")
print(f"浅拷贝字典: {shallow_copy}")

输出：

修改不可变元素后:
原始字典: {'a': 1, 'b': [2, 3]}
浅拷贝字典: {'a': 100, 'b': [2, 3]}

修改可变元素后:
原始字典: {'a': 1, 'b': [2, 3, 4]}
浅拷贝字典: {'a': 100, 'b': [2, 3, 4]}

11.2. 深拷贝解决方案

from copy import deepcopy

original = {"a": 1, "b": [2, 3]}
deep_copy = deepcopy(original)

# 修改可变元素
deep_copy["b"].append(4)
print(f"深拷贝后修改可变元素:")
print(f"原始字典: {original}")
print(f"深拷贝字典: {deep_copy}")

输出：

深拷贝后修改可变元素:
原始字典: {'a': 1, 'b': [2, 3]}
深拷贝字典: {'a': 1, 'b': [2, 3, 4]}

12. 字典的高级应用

12.1. 使用字典作为函数参数

def configure_server(**kwargs):
    config = {
        "host": "localhost",
        "port": 8080,
        "debug": False
    }
    config.update(kwargs)
    return config

# 使用关键字参数调用
server_config = configure_server(host="192.168.1.1", port=8000, debug=True)
print(f"服务器配置: {server_config}")

输出：

服务器配置: {'host': '192.168.1.1', 'port': 8000, 'debug': True}

12.2. 合并多个字典

dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
dict3 = {"e": 5, "f": 6}

# 使用update()方法（会修改原字典）
merged = dict1.copy()
merged.update(dict2)
merged.update(dict3)
print(f"合并结果1: {merged}")

# 使用字典解包（Python 3.5+）
merged2 = {**dict1, **dict2, **dict3}
print(f"合并结果2: {merged2}")

输出：

合并结果1: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
合并结果2: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

12.3. 使用defaultdict处理缺失键

from collections import defaultdict

# 创建defaultdict，默认值为int（即0）
word_count = defaultdict(int)
text = "python is powerful and python is easy to learn"

for word in text.split():
    word_count[word] += 1

print(f"词频统计: {dict(word_count)}")

# 创建defaultdict，默认值为list
grouped = defaultdict(list)
data = [("a", 1), ("b", 2), ("a", 3), ("b", 4)]

for key, value in data:
    grouped[key].append(value)

print(f"分组结果: {dict(grouped)}")

输出：

词频统计: {'python': 2, 'is': 2, 'powerful': 1, 'and': 1, 'easy': 1, 'to': 1, 'learn': 1}
分组结果: {'a': [1, 3], 'b': [2, 4]}

13. 总结

Python字典是一种极其强大且灵活的数据结构，通过本教程的详细学习，您已经掌握了：

字典基础：理解了字典的核心概念和基本特性

创建方法：掌握了多种创建字典的方式，包括字面量、构造函数和推导式

访问操作：学会了使用方括号、get()方法以及keys()/values()/items()访问字典元素

修改技巧：熟练掌握了添加、更新和合并字典元素的各种方法

删除操作：能够使用del、pop()、popitem()和clear()安全地删除字典元素

遍历方法：掌握了多种遍历字典的方式，包括键、值和键值对遍历

常用方法：熟悉了copy()、fromkeys()等字典内置方法的使用

高级技巧：掌握了字典推导式、嵌套字典、排序字典等高级应用

拷贝机制：理解了浅拷贝与深拷贝的区别及应用场景

实战应用：了解了字典在函数参数、数据统计、分组等实际场景中的应用

字典在Python编程中无处不在，从配置管理到数据缓存，从JSON处理到数据库映射，都离不开字典的身影。掌握字典的各种操作技巧将使您的Python代码更加高效、简洁和强大。建议在实际项目中多练习使用字典，深入理解其工作原理，以便能够灵活应对各种编程挑战。

上一篇 Docker Compose 使用完全指南

相关文章

发表回复

后才能评论