【0017】Python数据类型-字典类型详解（全网最细教程）

最新推荐文章于 2025-04-07 08:00:00 发布
最新推荐文章于 2025-04-07 08:00:00 发布
阅读量1.9k 收藏 15
点赞数 25
分类专栏： 【007】Python 文章标签： Python字典 字典 Python字典的创建 Python字典的合并 字典推导式 Python字典数据类型 Python数据类型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cxyzxc0325/article/details/146178271
版权

如果你觉得我的文章写的不错，请关注我哟，请点赞、评论，收藏此文章，谢谢！

本文内容体系结构如下：
在这里插入图片描述

Python字典是一种内置的数据结构，它以键值对（key-value pair）的形式存储数据。字典是Python中非常强大且灵活的数据类型之一，广泛应用于各种编程场景中。掌握它的使用对于提高编程效率和解决实际问题具有重要意义。无论是初学者还是有经验的程序员，都应该熟练掌握字典的相关操作和应用场景。


一、什么是字典？

1.1 字典的定义

字典（Dictionary）是Python中一种内置的数据结构，它以键值对（key-value pair）的形式存储数据。字典中的每个元素都是一个键值对，键（key）是唯一的，而值（value）则可以是任何数据类型。

1.2 字典的特点

  • 无序性：字典中的元素是无序的，即无法通过索引来访问元素。
  • 可变性：字典是可变的，可以随时增加、删除或修改元素。
  • 键唯一性：字典中的键是唯一的，不可变类型，不允许重复。

1.3 字典的应用场景

字典在Python编程中有着广泛的应用，常见的应用场景包括：

  • 存储配置信息：可以使用字典来存储应用程序的配置信息，如数据库连接参数、API密钥等。
  • 表示实体对象：可以使用字典来表示一个实体对象，如学生、商品等，其中键为属性名，值为属性值。
  • 计数统计：可以使用字典来进行计数统计，如统计字符串中每个字符出现的次数。
  • 缓存数据：可以使用字典作为缓存来存储已经计算过的结果，以提高程序性能。

二、字典的创建

要创建一个字典，可以使用大括号 {} 将一系列键值对元素包围起来，元素之间用英文逗号 , 分隔，键值对里的键和值之间使用英文冒号:分隔。或者使用dict()函数创建字典。

2.1 使用大括号创建字典

可以直接使用大括号 {} 来创建一个空字典，或者在大括号内添加键值对来创建一个有初始值的字典。

具体格式如下：

dictname = {key:value, key:value,...,key:value}

其中，dictname表示字典变量名，key表示字典键值对元素的键，value表示字典键值对元素的值。

# 创建空字典
empty_dict = {}
print(empty_dict) # {}
print(type(empty_dict)) # <class 'dict'>

# 创建有初始值的字典
student = {
    "name": "小明",
    "age": 20,
    "gender": "男"
}
print(student) # {'name': '小明', 'age': 20, 'gender': '男'}
print(type(student)) # <class 'dict'>

2.2 使用 dict() 函数创建字典

可以使用 dict() 函数来创建一个空字典，或者通过传入一个包含键值对的序列（如列表或元组）来创建字典。

# 创建空字典
empty_dict = dict()
print(empty_dict) # {}
print(type(empty_dict)) # <class 'dict'>

# 通过键值对序列创建字典
dict01 = dict(name="小明", age=20, gender="男")
print(dict01) # {'name': '小明', 'age': 20, 'gender': '男'}
print(type(dict01)) # <class 'dict'>

# 使用列表创建字典
list01 = [['name', 'Alice']]
dict02 = dict(list01)
print(dict02)  # {'name': 'Alice'}
list02 = [['name', 'Alice'], ['age', 30], ['city', 'New York']]
dict03 = dict(list02)
print(dict03)  # {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 使用元组创建字典
tuple01 = (('name', 'Bob'),) # 注意：这里('name', 'Bob')后面必须写一个,，不然房使用dict(tuple01)函数创建字典会报错，这个很有意思
dict04 = dict(tuple01)
print(dict04)  # {'name': 'Bob'}
tuple02 = (('name', 'Bob'), ('age', 25), ('city', 'Los Angeles'))
dict05= dict(tuple02)
print(dict05)  # {'name': 'Bob', 'age': 25, 'city': 'Los Angeles'}

# 使用JSON格式的字符串创建字典
import json
json_string = '{"name": "Charlie", "age": 22, "city": "Chicago"}'
dict06 = json.loads(json_string)
print(dict06)  # {'name': 'Charlie', 'age': 22, 'city': 'Chicago'}

# 从简单字符串创建单键值字典
key = 'name'
value = 'David'
dict07 = dict({key: value})
print(dict07)  # {'name': 'David'}

2.3 使用fromkeys()方法创建字典

fromkeys() 方法使用给定的多个 key 创建字典，这些 key 对应的 value 默认都是 None；也可以额外传入一个参数作为默认的 value。该方法一般不会使用字典对象调用（没什么意义），通常会使用 dict 类直接调用。

# 使用列表创建包含2个key的字典
dict01 = dict.fromkeys(['a', 'b'])
print(dict01) # {'a': None, 'b': None}
# 使用元组创建包含2个key的字典
dict02 = dict.fromkeys((13, 17))
print(dict02) # {13: None, 17: None}
# 使用元组创建包含2个key的字典，指定默认的value
dict03 = dict.fromkeys((13, 17), 'good')
print(dict03) # {13: 'good', 17: 'good'}

三、删除字典

当字典不再使用时，使用del命令删除整个字典。删除字典后，再次使用字典会报NameError错误。

# 创建字典
dict01 = dict({"name":"张三","age":30})
print(dict01) # {'name': '张三', 'age': 30}
# 删除字典
del dict01
# 删除后使用字典
print(dict01) # NameError: name 'dict01' is not defined

代码执行效果如下：
在这里插入图片描述


四、访问字典元素的值

因为字典中的元素是无序的，所以字典中的元素不能通过索引来访问。字典中的元素可以直接根据键来访问，也可以使用字典中的get()方法来访问。

4.1 通过键访问值

可以使用字典的键来访问对应的值。如果键不存在，会抛出 KeyError 异常。语法格式如下：

值=字典名["键名"]

演示代码如下所示：

student = {
    "name": "小明",
    "age": 20,
    "gender": "男"
}

# 访问字典中的值
print(student["name"])  # 小明
print(student["age"])   # 20
print(student["gender"]) # 男
# 访问字典中不存在的键
print(student["score"]) # KeyError: 'score'

运行结果如下图所示：
在这里插入图片描述

4.2 使用 get() 方法访问值

可以使用 get() 方法来访问字典中的值。如果键不存在，get() 方法会返回 None，而不会抛出异常。

student = {
    "name": "小明",
    "age": 20,
    "gender": "男"
}

# 使用 get() 方法访问值
# 访问字典中的键
print(student.get("name"))
print(student.get("age"))
print(student.get("gender"))# 输出：小明
# 访问字典中不存在的键
print(student.get("score")) # 键不存在，返回None

运行结果如下图所示：
在这里插入图片描述

4.3 使用 setdefault() 方法访问值

setdefault() 方法也用于根据 key 来获取对应 value 的值。如果该 key-value 对存在，则直接返回该 key 对应的 value；如果该 key-value 对不存在，则先为该 key 对应的值设置值为None，并将这个键值对存储到字典中，返回None。如果不想使用系统设置的None值，可以在使用setdefault() 方法时传递一个指定的值，注意，如果获取的键有对应的值，你还设置了默认值，默认值不会覆盖原来键对应的值。

student = {
    "name": "小明",
    "age": 20,
    "gender": "男"
}
print(student) # {'name': '小明', 'age': 20, 'gender': '男'}

# 使用 get() 方法访问值
# 访问字典中的存在的键
print(student.setdefault("name")) # 小明
print(student.setdefault("age")) # 20
print(student.setdefault("gender")) # 男
# 访问字典中的存在的键，并赋值，赋值不会覆盖字典中原来键对应的值
print(student.setdefault("name","张三")) # 小名

# 访问字典中不存在的键，不给键赋值，返回None，并且将这个键对应的值设置为None，让后将键值对添加进字典，
print(student.setdefault("score")) # None
print(student) # {'name': '小明', 'age': 20, 'gender': '男', 'score': None}
# 访问字典中不存在的键，给键赋值，返回这个赋予的值，并将这个键值对添加进字典
print(student.setdefault("grade","大一")) # 大一
print(student) # {'name': '小明', 'age': 20, 'gender': '男', 'score': None, 'grade': '大一'}

运行结果如下图所示：
在这里插入图片描述


五、遍历字典元素

遍历字典，可以分为遍历字典的键、字典的值和字典的键值对。

5.1 遍历字典的键

（1）for 循环来遍历字典的键

直接使用for循环遍历字典，输出的是字典中所有的键

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

# 遍历字典的键
for key in student:
    print(key)  # name, age, gender（顺序可能不同）

运行结果如下图所示：
在这里插入图片描述

（2）使用keys()方法获取所有的键

通过字典对象调用keys()方法可以获取字典中所有的键，存储在一个视图对象类型dict_keys中，dict_keys 不是列表，不支持列表的所有操作。然后可以使用for循环、enumerate()方法等方式遍历这个列表，获取所有的键。

演示代码如下所示：

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

# 获取所有的键
keys = student.keys()
print(keys) # dict_keys(['name', 'age', 'gender'])
print(type(keys)) # <class 'dict_keys'>
# 使用for循环遍历列表keys
for key in keys:
    print(key)

print("-------------------------------------------")

# 使用while循环遍历列表keys
for index,key in enumerate(keys):
    print(f"{index}：{key}")

运行结果如下图所示：
在这里插入图片描述

5.2 遍历字典的值

在 Python 中，遍历字典的值有多种方法。以下是一些常用的方法。

（1）使用 values() 方法获取所有的值。

通过字典对象调用values()方法可以获取字典中所有的值，存储在一个视图对象类型dict_values中，dict_keys 不是列表，不支持列表的所有操作。然后可以使用for循环、enumerate()方法等方式遍历这个列表，获取所有的值。最常用的是 .values() 方法，因为它直接且清晰。

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

# 获取所有的值
values = student.values()
print(values)
print(type(values))
# 使用for循环遍历列表values
for value in values:
    print(value)

print("-------------------------------------------")

# 使用while循环遍历列表values
for index,value in enumerate(values):
    print(f"{index}：{value}")

运行结果如下图所示：
在这里插入图片描述

（2）使用 for 循环直接遍历字典

先获取键，然后通过键访问值。这种方法虽然不是直接遍历值，但在需要键和值都用的情况下很常用。

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

for key in student:
    print(student[key]) # 使用print(student.get(key))也可以

运行结果如下图所示：
在这里插入图片描述

（3）使用字典解包（Python 3.5+）

如果你使用的是 Python 3.5 或更高版本，可以利用 ** 解包操作符。

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

# 使用字典解包
for value in student.values():
    print(value)

运行结果如下图所示：
在这里插入图片描述

（4）将字典转换为列表或其他可迭代对象

如果需要对值进行进一步的处理，可以先将其转换为列表。

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

# 将字典转换为列表或其他可迭代对象
value_list=list(student.values())
for value in value_list:
    print(value)

运行结果如下图所示：
在这里插入图片描述

这些方法各有其适用场景，选择哪种方法主要取决于你的具体需求和代码风格偏好。

5.3 遍历字典的键值对

（1）使用 items() 方法来遍历字典键值对
student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

# 遍历字典的键值对
for key, value in student.items():
    print(f"{key}: {value}")  # 输出：name: 小明, age: 21, gender: 男（顺序可能不同）

运行结果如下图所示：
在这里插入图片描述

（2）使用 for 循环遍历字典键值对

使用for先获取键，然后通过键访问值。

student = {
    "name": "小明",
    "age": 21,
    "gender": "男"
}

for key in student:
    print(key,"：",student[key]) # 使用student.get(key)也可以

运行结果如下图所示：
在这里插入图片描述


六、增加字典元素

在 Python 中，可以通过多种方式向字典中添加元素。以下是一些常用的方法。

6.1 使用赋值运算符

这是最直接的方法，通过键来添加或更新字典中的值。如果键不存在，九添加新的键值对，如果键已经存在，则会覆盖原有的值。

student = {
    "name": "小明",
    "age": 20,
    "gender": "男"
}
print(student) # {'name': '小明', 'age': 20, 'gender': '男'}

# 增加新元素
student["score"] = 90
print(student)  # {'name': '小明', 'age': 20, 'gender': '男', 'score': 90}
# 增加已经存在的键，新增的值会覆盖字典中已经存在的键
student["age"] = 21
print(student) # {'name': '小明', 'age': 21, 'gender': '男', 'score': 90}

运行结果如下图所示：
在这里插入图片描述

6.2 使用 update() 方法

update() 方法可使用一个字典所包含的 key-value 对来更新己有的字典。在执行 update() 方法时，如果被更新的字典中己包含对应的 key-value 对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的 key-value 对，则该 key-value 对被添加进去。update() 方法可以用来添加多个键值对。它接受另一个字典或可迭代的键值对。

dict01 = {'key1': 'value1'}
print(dict01) # {'key1': 'value1'}
# 添加1个不存在的键值对
dict01.update({'key2': 'value2'})
print(dict01) # {'key1': 'value1', 'key2': 'value2'}
# 添加2个键值对，一个字典中已经存在，一个不存在
dict01.update(({"key2":"值2","key3":"value3"}))
print(dict01) # {'key1': 'value1', 'key2': '值2', 'key3': 'value3'}

# 也可以使用一个可迭代的键值对
dict01.update(key4='value4', key5='value5')
print(dict01) # {'key1': 'value1', 'key2': '值2', 'key3': 'value3', 'key4': 'value4', 'key5': 'value5'}

运行结果如下图所示：
在这里插入图片描述

6.4 使用 setdefault() 方法

setdefault() 方法也用于根据 key 来获取对应 value 的值。如果该 key-value 对存在，则直接返回该 key 对应的 value；如果该 key-value 对不存在，则先为该 key 对应的值设置值为None，并将这个键值对存储到字典中，返回None。如果不想使用系统设置的None值，可以在使用setdefault() 方法时传递一个指定的值，注意，如果获取的键有对应的值，你还设置了默认值，默认值不会覆盖原来键对应的值。

student = {
    "name": "小明",
    "age": 20,
    "gender": "男"
}
print(student) # {'name': '小明', 'age': 20, 'gender': '男'}

# 使用 get() 方法访问值
# 访问字典中的存在的键
print(student.setdefault("name")) # 小明
print(student.setdefault("age")) # 20
print(student.setdefault("gender")) # 男
# 访问字典中的存在的键，并赋值，赋值不会覆盖字典中原来键对应的值
print(student.setdefault("name","张三")) # 小名

# 访问字典中不存在的键，不给键赋值，返回None，并且将这个键对应的值设置为None，让后将键值对添加进字典，
print(student.setdefault("score")) # None
print(student) # {'name': '小明', 'age': 20, 'gender': '男', 'score': None}
# 访问字典中不存在的键，给键赋值，返回这个赋予的值，并将这个键值对添加进字典
print(student.setdefault("grade","大一")) # 大一
print(student) # {'name': '小明', 'age': 20, 'gender': '男', 'score': None, 'grade': '大一'}

运行结果如下图所示：
在这里插入图片描述

6.5 解包语法（Python 3.5+）

如果你有两个字典，并希望将它们合并成一个新字典，你可以使用解包语法（**）。这不会更新原有字典，而是返回一个新字典。

dict01 = {'key1': 'value1'}
dict02 = {'key2': 'value2'}
print("操作前字典dict01：",dict01) # 操作前字典dict01： {'key1': 'value1'}
print("操作前字典dict01：",dict02) # 操作前字典dict01： {'key2': 'value2'}

merged_dict = {**dict01, **dict02}
print(merged_dict) # {'key1': 'value1', 'key2': 'value2'}

print("操作后字典dict01：",dict01) # 操作后字典dict01： {'key1': 'value1'}
print("操作后字典dict01：",dict02) # 操作后字典dict01： {'key2': 'value2'}

运行结果如下图所示：
在这里插入图片描述

6.6 字典合并运算符（Python 3.9+）

从 Python 3.9 开始，可以使用合并运算符（|）来合并两个字典，生成一个新字典。

dict01 = {'key1': 'value1'}
dict02 = {'key2': 'value2'}
print("操作前字典dict01：",dict01) # 操作前字典dict01： {'key1': 'value1'}
print("操作前字典dict01：",dict02) # 操作前字典dict01： {'key2': 'value2'}

# 合并两个字典
merged_dict = dict01 | dict02
print(merged_dict) #{'key1': 'value1', 'key2': 'value2'}

print("操作后字典dict01：",dict01) # 操作后字典dict01： {'key1': 'value1'}
print("操作后字典dict01：",dict02) # 操作后字典dict01： {'key2': 'value2'}

运行结果如下图所示：
在这里插入图片描述

七、删除字典元素

在 Python 中，可以通过几种方法从字典中删除元素。以下是常用的方法。

7.1 pop()方法删除字典元素

  • 使用 pop() 方法可以通过指定键来删除字典中的元素，并返回该键对应的值。
  • 如果指定的键不存在，可以提供一个默认值，这样就不会引发错误。不然得话，程序会报KeyError错误。
dict01 = {'a': 1, 'b': 2, 'c': 3}
print(dict01) # {'a': 1, 'b': 2, 'c': 3}

# 删除字典中存在的键
value01 = dict01.pop('b')  # 删除键 'b'
print(value01) # 2
print(dict01) # {'a': 1, 'c': 3}
# 如果键不存在，提供默认值
defaultvalue = dict01.pop('d', 'default_value')
print(defaultvalue) # default_value
print(dict01) # {'a': 1, 'c': 3}
# 如果键不存在，不提供默认值，报错
value02 = dict01.pop('d') # KeyError: 'd'
print(value02)
print(dict01)

运行结果如下图所示：
在这里插入图片描述

7.2 del语句删除字典元素

  • 使用 del 语句可以直接删除字典中的键值对。
  • 如果指定的键不存在，会引发 KeyError。
dict01 = {'a': 1, 'b': 2, 'c': 3}
print(dict01) # {'a': 1, 'b': 2, 'c': 3}

# 删除字典中存在的键值对
del dict01["b"]
print(dict01) # {'a': 1, 'c': 3}

# 删除字典中不存在的键值对
del dict01["d"] # KeyError: 'd'
print(dict01)

运行结果如下图所示：
在这里插入图片描述

7.3 popitem()方法删除字典元素

  • popitem() 方法用于在不需要指定键的情况下删除字典中的最后一个元素（在 Python 3.7+ 中保证是 LIFO 顺序）。
  • 它返回一个包含键和值的元组。
dict01 = {'a': 1, 'b': 2, 'c': 3}
print(dict01) # {'a': 1, 'b': 2, 'c': 3}

# 删除字典中最后一个键值对
item01 = dict01.popitem()  # 删除并返回最后一个元素
print(item01) # ('c', 3)
print(dict01) # {'a': 1, 'b': 2}

item02 = dict01.popitem()  # 删除并返回最后一个元素
print(item02) # ('b', 2)
print(dict01) # {'a': 1}

运行结果如下图所示：
在这里插入图片描述

7.4 clear()方法删除字典元素

clear() 用于清空字典中所有的 key-value 对，对一个字典执行 clear() 方法之后，该字典就会变成一个空字典。

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

# 清空字典,字典变为一个空字典
dict01.clear()
print(dict01) # {}

运行结果如下图所示：
在这里插入图片描述

在实际使用中，选择哪种方法取决于具体的需求，例如是否需要返回值等。


八、修改字典元素

修改字典元素可以采用赋值运算符来给字典中已经存在的键值对重新赋值，或者用update()方法实现给字典中已经存在的键重新赋值，从而达到修改字典元素的目的。方法具体操作参照6.1和6.2小节。


九、查找字典元素

可以使用运算符in和notin查找字典中的元素是否存在，in和not in查找的都是对字典中的键是否存在做出判断，返回True或者False。

9.1 in运算符查询元素在字典中是否存在

使用in运算符查询某个元素在字典是否存在，如果存在返回True，如果不在返回False。

语法格式如下：

result = 元素值 in 字典名

演示代码如下：

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

# 使用运算符in查找键是否存在
print("键a在字典中存在：","a" in dict01) # 键a在字典中存在： True
print("键d在字典中存在：","d" in dict01) # 键d在字典中存在： False

运行结果如下图所示：
在这里插入图片描述

9.2 not in运算符查询元素在字典中是否不存在

使用not in运算符查询某个元素在字典中是否不存在，如果不存在返回True，如果存在返回False。

语法格式如下：

result = 元素值 not in 字典名

演示代码如下：

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

# 使用运算符not in查找键是否不存在
print("键a在字典中不存在：","a" not in dict01) # 键a在字典中不存在： False
print("键d在字典中不存在：","d" not in dict01) # 键d在字典中不存在： True

运行结果如下图所示：
在这里插入图片描述


十、排序字典元素

在 Python 中，对字典进行排序的方法有多种，具体取决于您想要根据字典的键还是值进行排序。以下是几种常用的字典排序方法。

10.1 按键排序

10.1.1 使用 sorted()函数
  • sorted() 函数返回一个新的列表，列表中的元素是排序后的字典项（即键值对）。
  • 可以使用 lambda 函数指定排序键。
my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_items = sorted(my_dict.items(), key=lambda x: x[0])
print(sorted_items)  # 输出: [('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)]
  • 若需要降序排序，可以将 reverse 参数设置为 True。
my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_items_desc = sorted(my_dict.items(), key=lambda x: x[0], reverse=True)
print(sorted_items_desc)  # 输出: [('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)]
10.1.2 使用 operator.itemgetter()函数
  • itemgetter() 函数是 operator 模块中的一个函数，用于获取对象的多个属性。
  • 它可以简化代码，提高可读性。
from operator import itemgetter

my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_items = sorted(my_dict.items(), key=itemgetter(0))
print(sorted_items)  # 输出: [('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)]
10.1.3 使用 collections.OrderedDict
  • OrderedDict 是一个有序的字典，它保持了元素插入的顺序。
  • 可以通过先排序再转换为 OrderedDict 来实现按键排序。
from collections import OrderedDict

my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_dict = OrderedDict(sorted(my_dict.items(), key=lambda x: x[0]))
print(sorted_dict)  # 输出: OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])

10.2 按值排序

10.2.1 使用 sorted() 函数
  • 与按键排序类似，只需调整 lambda 函数中的参数。
my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_items = sorted(my_dict.items(), key=lambda x: x[1])
print(sorted_items)  # 输出: [('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)]
10.2.2 使用 operator.itemgetter()函数
  • 同样可以简化代码。
from operator import itemgetter

my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_items = sorted(my_dict.items(), key=itemgetter(1))
print(sorted_items)  # 输出: [('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)]
10.2.3 使用 collections.OrderedDict
  • 同样可以转换为 OrderedDict 来保持排序后的顺序。
from collections import OrderedDict

my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_dict = OrderedDict(sorted(my_dict.items(), key=lambda x: x[1]))
print(sorted_dict)  # 输出: OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

注意事项：

  • 排序后的结果是一个列表，其中每个元素是一个元组（键值对）。
  • 如果需要将排序后的结果转换回字典，可以使用 dict() 函数。
  • 字典本身是无序的，排序操作不会改变原字典的顺序，而是返回一个新的有序序列。

这些方法可以根据具体需求选择使用，以实现按键或按值对字典进行排序。


十一、字典的复制

在 Python 中，复制字典的方法有多种，根据具体需求和 Python 版本的不同，可以选择以下几种方法。

11.1 使用 copy 方法

  • dict.copy()：这会创建一个浅复制（shallow copy）的新字典。
original = {'a': 1, 'b': 2}
print(original,id(original)) # {'a': 1, 'b': 2} 2097791629312
copied = original.copy()
print(copied,id(copied)) # {'a': 1, 'b': 2} 2097792040768

11.2 使用 dict`函数

  • 可以通过 dict() 函数直接创建一个新字典。
original = {'a': 1, 'b': 2}
print(original,id(original)) # {'a': 1, 'b': 2} 1572641044480
copied = dict(original)
print(copied,id(copied)) # {'a': 1, 'b': 2} 1572641578368

11.3 使用 dict 的解包语法（Python 3.5+）

  • 利用字典解包（dictionary unpacking）特性。
original = {'a': 1, 'b': 2}
print(original,id(original)) # {'a': 1, 'b': 2} 1521142003712
copied = {**original}
print(copied,id(copied)) # {'a': 1, 'b': 2} 1521142415168

11.4 使用 collections.ChainMa()

该方法只适用于创建合并视图，不是真正的复制）

  • collections.ChainMap 可以用于将多个字典视为一个字典，但这不产生实际的副本。
from collections import ChainMap

original = {'a': 1, 'b': 2}
print(original,id(original)) # {'a': 1, 'b': 2} 2792366798848
copied = dict(ChainMap(original))
print(copied,id(copied)) # {'a': 1, 'b': 2} 2792367330368

11.5 使用 copy 模块中的 deepcopy 函数

  • copy.deepcopy()：用于创建深复制（deep copy），对字典中包含的嵌套对象也进行复制。
import copy

original = {'a': 1, 'b': 2}
print(original,id(original)) # {'a': 1, 'b': 2} 2454908452672
copied = copy.deepcopy(original)
print(copied,id(copied)) # {'a': 1, 'b': 2} 2454908569280

需要注意的是，浅复制只是复制了字典的顶层结构，如果字典中包含可变对象（如另一个字典或列表），浅复制之后修改内部可变对象会影响到原字典。而深复制则会递归复制对象内部的所有层级，确保复制后的对象和原对象完全独立。选择合适的复制方法需要根据具体的使用场景来决定。


十二、字典的合并

在 Python 中，合并字典的方法有多种，以下是一些常用的方法

12.1 使用update()方法

  • 描述：update() 方法将一个字典的键值对更新到另一个字典中。

  • 示例：

    dict01 = {'a': 1, 'b': 2}
dict02 = {'b': 3, 'c': 4}
print(dict01) # {'a': 1, 'b': 2}
print(dict02) # {'b': 3, 'c': 4}

dict01.update(dict02)
print(dict01) # {'a': 1, 'b': 3, 'c': 4}
print(dict02) # {'b': 3, 'c': 4}

  • 注意事项：此方法会直接修改 dict1，不会创建新的字典。如果希望保留 dict1 的原始内容，可以先复制 dict1。

12.2使用解包语法（Python 3.5+）

  • 描述：使用 ** 运算符解包字典，将多个字典合并为一个新的字典。

  • 示例：

    dict01 = {'a': 1, 'b': 2}
dict02 = {'b': 3, 'c': 4}
print(dict01) # {'a': 1, 'b': 2}
print(dict02) # {'b': 3, 'c': 4}

merged_dict = {**dict01, **dict02}
print(merged_dict)  # {'a': 1, 'b': 3, 'c': 4}
print(dict01) # {'a': 1, 'b': 2}
print(dict02) # {'b': 3, 'c': 4}

12.3 使用 | 运算符（Python 3.9+）

  • 描述：| 运算符用于合并两个字典，生成一个新的字典。

  • 示例：

    dict01 = {'a': 1, 'b': 2}
dict02 = {'b': 3, 'c': 4}
print(dict01) # {'a': 1, 'b': 2}
print(dict02) # {'b': 3, 'c': 4}

merged_dict = dict01 | dict02
print(merged_dict)  # {'a': 1, 'b': 3, 'c': 4}
print(dict01) # {'a': 1, 'b': 2}
print(dict02) # {'b': 3, 'c': 4}

12.4 使用ChainMap

  • 描述：ChainMap 是 collections 模块中的一个类，允许将多个字典链接在一起，创建一个单一的视图。对 ChainMap 所做的任何更新或更改都会反映在底层字典中。适用于需要保留字典层级的情况

  • 示例：

    from collections import ChainMap

dict01 = {'a': 1, 'b': 2}
dict02 = {'c': 3, 'd': 4}
print(dict01) # {'a': 1, 'b': 2}
print(dict02) # {'c': 3, 'd': 4}

merged_dict = ChainMap(dict01, dict02)
print(merged_dict) # ChainMap({'a': 1, 'b': 2}, {'c': 3, 'd': 4})
print(merged_dict['a'])  # 1
print(merged_dict['b'])  # 2
print(merged_dict['c'])  # 3
print(merged_dict['d'])  # 4
dict03 = dict(merged_dict)
print(dict03) # {'c': 3, 'd': 4, 'a': 1, 'b': 2}

print(dict01) # {'a': 1, 'b': 2}
print(dict02) # {'c': 3, 'd': 4}

  • 注意事项：ChainMap 本身不是一个字典，而是一个字典视图。如果需要获取合并后的字典，可以使用 dict() 函数转换。

12.5 使用 dict.items()和集合操作（Python 3.9+）

  • 描述：利用 dict.items() 方法获取字典的键值对视图，然后使用集合操作合并这些键值对。

  • 示例：

    dict01 = {'a': 1, 'b': 2}
dict02 = {'b': 3, 'c': 4}
print(dict01) # {'a': 1, 'b': 2}
print(dict02) # {'b': 3, 'c': 4}

merged_dict = dict(dict01.items() | dict02.items())
print(merged_dict)  # {'c': 4, 'b': 3, 'a': 1}
print(dict01) # {'a': 1, 'b': 2}
print(dict02) # {'b': 3, 'c': 4}

  • 注意事项：这种方法在 Python 3.9 及更高版本中可用，因为 | 运算符在 Python 3.9 中被引入用于字典项的合并。

12.6 使用字典解析式

  • 描述：通过字典解析式将多个字典合并为一个新的字典。

  • 示例：

    dict01 = {'a': 1, 'b': 2}
dict02 = {'b': 3, 'c': 4}
print(dict01) # {'a': 1, 'b': 2}
print(dict02) # {'b': 3, 'c': 4}

merged_dict = {k: v for d in [dict01, dict02] for k, v in d.items()}
print(merged_dict)  # {'a': 1, 'b': 3, 'c': 4}

print(dict01) # {'a': 1, 'b': 2}
print(dict02) # {'b': 3, 'c': 4}

12.7 使用 for循环和 keys()方法

  • 描述：通过 for 循环遍历第二个字典的键，将键值对添加到第一个字典中。

  • 示例：

    dict01 = {'a': 1, 'b': 2}
dict02 = {'b': 3, 'c': 4}
print(dict01) # {'a': 1, 'b': 2}
print(dict02) # {'b': 3, 'c': 4}

for k in dict02.keys():
    dict01[k] = dict02[k]
print(dict01)  # {'a': 1, 'b': 3, 'c': 4}

print(dict01) # {'a': 1, 'b': 3, 'c': 4}
print(dict02) # {'b': 3, 'c': 4}

  • 注意事项：这种方法会直接修改 dict1，不会创建新的字典。

选择合适的方法

  • 如果希望保留原始字典：可以使用解包语法、| 运算符或字典解析式，这些方法会创建新的字典。
  • 如果需要在合并过程中保留字典层级：可以使用 ChainMap。
  • 如果希望代码简洁易读：可以使用 update() 方法（如果不需要保留原始字典）或 | 运算符（Python 3.9+）。

根据具体的需求和 Python 版本，可以选择最适合的方法来合并字典。


十三、字典推导式

13.1 什么是推导式

Python推导式（comprehension）是一种简洁而高效的构建容器（如列表、集合、字典）的方法。它允许你用一行代码来创建容器，并且可以通过循环和条件语句来生成容器中的元素。

推导式分为列表推导式（list comprehension）、集合推导式（set comprehension）、字典推导式（dictionary comprehension）以及生成器表达式（generator expression）。

推导式是Python中非常强大和常用的特性，可以使代码更加简洁和高效。

13.2 字典推导式

字典推导式（dictionary comprehension）是一种简洁而优雅的方式，用于从一个可迭代对象中创建字典。它的语法类似于列表推导式，但使用花括号 {} 而不是方括号 []。

13.3 基本语法

new_dict = {key_expression: value_expression for item in iterable if condition}
  • key_expression：用于生成字典的键的表达式。
  • value_expression：用于生成字典的值的表达式。
  • iterable：一个可迭代对象，如列表、元组、字典等。
  • condition（可选）：一个过滤条件，用于筛选哪些元素应该包含在字典中。

13.4 演示示例

以下是一些使用字典推导式的示例：

13.4.1 简单的字典推导式

从一个列表创建一个字典，其中键是列表中的元素，值是元素的平方：

numbers = [1, 2, 3, 4, 5]
squared_dict = {num: num ** 2 for num in numbers}
print(squared_dict)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
13.4.2 带有条件的字典推导式

从一个列表创建一个字典，其中键是列表中的偶数元素，值是元素的平方：

numbers = [1, 2, 3, 4, 5]
even_squared_dict = {num: num ** 2 for num in numbers if num % 2 == 0}
print(even_squared_dict)  # {2: 4, 4: 16}
13.4.3 从字典创建新的字典

从一个字典创建一个新的字典，交换键和值：

original_dict = {'a': 1, 'b': 2, 'c': 3}
inverted_dict = {value: key for key, value in original_dict.items()}
print(inverted_dict)  # {1: 'a', 2: 'b', 3: 'c'}
13.4.4 使用嵌套推导式

从一个嵌套列表创建一个字典，其中键是子列表的第一个元素，值是子列表的第二个元素：

nested_list = [['a', 1], ['b', 2], ['c', 3]]
nested_dict = {key: value for key, value in nested_list}
print(nested_dict)  # {'a': 1, 'b': 2, 'c': 3}

13.5 使用场景

  • 数据转换：从一个数据结构（如列表、元组）快速创建字典。
  • 过滤和筛选：在创建字典时，根据条件筛选元素。
  • 简化代码：将多行代码简化为单行，提高代码的可读性和可维护性。

13.6 注意事项

  • 可读性：虽然字典推导式可以简化代码，但过于复杂的推导式可能会降低代码的可读性。
  • 性能：字典推导式通常比传统的循环方式更高效，尤其是在处理大量数据时。
  • Python 版本：字典推导式在 Python 2.7 及更高版本中可用。

字典推导式是一种强大的工具，可以帮助开发者以简洁而高效的方式创建和操作字典。


十四、总结

本文我们详细学习了Python字典的基本概念、创建和访问方法、增删改查操作、遍历方法、复制、合并以及字典推导式等内容。字典是Python中一种非常强大的数据结构，掌握字典的使用对于提高编程效率和解决实际问题具有重要意义。希望大家能够认真练习，熟练掌握字典的相关操作。

全网最细 Python 格式化输出用法讲解
棒棒编程修炼场
01-17 1万+
文章目录一、使用 print() 函数二、使用 str.format() 方法三、详解 format() 函数运用一：格式转换运用二：生成数据编号运用三：格式化十进制整数运用四：格式化浮点数运用五：格式化百分数运用六：格式化科学记数法运用七：格式化金额运用八：格式化字符运用九：进制转换运用十：格式化日期和时间四、使用 f-string 方法 一、使用 print() 函数 在 Python 中，print() 函数支持格式化输出，与 C 语言的 printf 类似。 1. 格式化输出字符串和整数 【示例1】
[Python从零到壹] 十五.文本挖掘之数据预处理、Jieba工具和文本聚类万字详解
杨秀璋的专栏
08-06 2万+
前一篇文章讲述了分类算法的原理知识级案例，包括决策树、KNN、SVM，并通过详细的分类对比实验和可视化边界分析与大家总结。本文将详细讲解数据预处理、Jieba分词和文本聚类知识，这篇文章可以说是文本挖掘和自然语言处理的入门文章。两万字基础文章，希望对您有所帮助。欢迎大家来到“Python从零到壹”，在这里我将分享约200篇Python系列文章，带大家一起去学习和玩耍，看看Python这个有趣的世界。所有文章都将结合案例、代码和作者的经验讲解，真心想把自己近十年的编程经验分享给大家，希望对您有所帮助，文章中不
python数据类型字典
Gao376560938的博客
02-24 2074
python数据类型字典
Python学习之字典详解
moodytong的专栏
06-09 4万+
在元组和列表中，都是通过编号进行元素的访问，但有的时候我们按名字进行数据甚至数据结构的访问，在c++中有map的概念，也就是映射，在python中也提供了内置的映射类型--字典。映射其实就是一组key和value以及之间的映射函数，其特点是：key的唯一性、key与value的一对多的映射。 1.字典的创建       字典的基本形态dic={key1:value1, key2:value2.
Python字典操作全攻略：从创建到合并
最新发布
2401_87975790的博客
04-07 1541
Python字典是一种高效且灵活的数据结构，用于存储键值对。：生成新字典，可能增加内存占用，适合不可变数据或链式操作。：按插入顺序删除元素（如LIFO场景）或需要键值对元组。：动态访问键值对，支持集合操作（键值对需哈希）。：原地操作，内存效率高，适合频繁修改或大字典。：必须为不可变类型（如字符串、数字、元组）。处理可能不存在的键（通过默认值避免错误）。：需要获取被删除的值或处理可能缺失的键。：动态访问值，但无法保证唯一性或哈希性。：合并时，相同键的值由新字典覆盖旧值。确定键存在，或希望缺失键时抛出错误。
Python数据类型——字典
weixin_46039719的博客
01-13 921
目录 1 概述 1.1字典基本操作 1.2 字典常用方法 2 字典基本操作 2.1 创建字典 2.2遍历字典 2.3判断键是否在字典里面 3字典常用方法 3.1clear 3.2copy 3.3get 3.4 setdefault 3.5update 3.6items/iteritems 3.7keys/iterkeys 3.8values/itervalues 3.9pop 3.10popitem ...
python中的字典类型
qq_35218635的博客
09-24 321
字典的定义，一般使用下面所写的第一种，第二种则使用的比较少，但是也会使用，而且在列表中同样如此。 在字典中，key是唯一的，但是value的值是可以变化的。也就是当key相同时，对同一个key赋值不同的value会对对应的value修改掉，但是如果是对这个key第一次赋值，那么就是相当于是向字典中添加键值对。 列表可以转化成字典，但是转化成字典的前提是需要列表中的元素是两两对应存在，也就是说想要把列表转成字典 字典的增删改查： 增加：就是直接...
【python学习】python字典类型
learning CV
10-04 3061
中国史之【炎帝神农氏尝百草】： 中国上古时期姜姓部落的首领尊称，号神农氏，又称烈山氏。相传“神农尝百草”，教人医疗与农耕，中国人视之为传说中的农业和医药的发明者、守护神。在我国的川、鄂、陕交界传说是神农尝百草的地方，称为神农架山区。 -来源：全历史APP 今天讲python的字典类型，字典和列表是最常用的两种数据类型之二。有需要的也可以直接去我的github查看全部笔记： https://github.com/JackKoLing/python_notes_with_ten_days 俗话说：“好记性.
【Python基础篇】【11.数据类型 - 字典 dict】全网最全详解（附案例实战，源代码）
weixin_43612602的博客
11-28 582
字典 dict 创建 增加 删除 del、pop()、popitem()、clear() 修改 / 更新 update() 查询 get()、keys()、values()、items() 复制 copy() 案例 - 字典取值 案例 - 字符串统计
全网最详细的Python入门基础教程，Python最全教程
m0_72444380的博客
09-25 2024
3.Pythonplot_Matplotlib3D绘图函数plot_surface的rstride和cstride参数。9.Python2to3自动将Python2.x代码转换成Python3.x代码。7.Python2.x和Python3.x，初学者应如何选择？8.Python__iter__和__reversed__11.Python字符串操作（查找，替换，分割和连接）7.PythonScrapy突破反爬虫机制(一)8.PythonScrapy突破反爬虫机制(二)...
【Python基础篇】【12.数据类型 - 集合 set】全网最全详解（附案例实战，源代码）
weixin_43612602的博客
11-28 1041
集合 set 集合 set 创建 增加 add() 删除 remove()、pop()、clear()、discard() 查询 in、not in、is、is not 消除两个集合的差集 difference_update() 两个集合的合并 union() 求交集 isdisjoint() 集合 - 计算运算符 集合的遍历 总结
python中字典的使用
热门推荐
wzw_666的博客
01-03 8万+
一.字典的定义：       前面我们说过列表，它适合于将值组织到一个结构中并且通过编号对其进行引用。字典则是通过名字来引用值的数据结构，并且把这种数据结构称为映射，字典中的值没有特殊的顺序，都存储在一个特定的键（key）下，键可以是数字、字符串甚至元组。字典也是python中唯一内建的映射类型。 二.创建和使用字典      字典由多个键和其对应的值构成的键—值对组成，键和值中间以冒号：隔
Python中字典的学习
chengkou8481的博客
05-17 264
下例中,名字是键，电话号码是值. 所以: 每个键和它的值之间用冒号":"隔开,项之间用逗号","隔开,而整个字典是由一对大括号括起来 其中,键为任何不可变类型 phonebook = {'Alice':'2341','Beth':'9102','Cell...
【python笔记】：字典类型详解
_
11-29 2239
字典： 表示对象直接的映射关系（通过名字来访问值），是python中唯一内建的映射类型 映射类型通常被称为哈希表（散列表），字典就是一种哈希类型 字典中每一个元素可以形成key-value对（键值对，也称为item即项）:key是键，value是值 键唯一，可以是数字，字符串或元组等一些不可变的对象，使用键进行索引 字典中元素是无序的 创建字典 1.直接创建 2，用dict（）函数创建 变量info通过赋值获得一个列表数据，列表中每一个对象都是元组对，再利用dict函数将in...
Python字典类型
VIPToby的专栏
01-29 794
存放元素的容器3： 字典={键:值,键:值,键:值,键:值,.......} 1.字典的特点：        字典不适用默认的自然数来索引值           字典的开始和结束要加上花括号      “键”和“值”是一对一的关系，类似于”属性-值“        采用逗号将字典中的每一对“键-值”分开，“键”和“值”之间用冒号隔开        字典中可以放置任意的数据类型
Python---字典类型
m0_70312393的博客
10-17 661
字典类型是根据一个信息查找另一个信息的方式构成了“键值对”，它表示索引用的键和对应的值构成的成对关系。
python基础——数据类型(七)字典
xiaohei07的博客
07-14 3000
字典（dictionary）是python语言中唯一的标准映射类型，是python中除了列表以外最灵活的数据类型。字典是一种无序的、可变的序列，元素以"键值对"的形式进行存储，是可变的容器，容量是无限的。字典的键值是hashable值，即所有不可变类型的值（基于对象标识而非值进行比较的对象），可变类型不能用作键，且键值一定是唯一的，不能出现多次，否则只会保留最后出现的一个键值对。注意：数字类型用作键时遵循数字比较的一般原则：即两个近似数值相等的值会被用来作为一个键值索引同一条字典条目。
Python字典类型详解
永远是少年
12-12 3443
今天继续给大家介绍Python相关知识，本文主要内容是Python字典类型详解。 一、字典类型定义与简单使用 二、字典类型处理函数及方法 三、字典类型应用示例
Python数据类型------字典
weixin_45997340的博客
01-30 360
【代码】Python数据类型------字典。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员张小厨

你的鼓励将是我持创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值