字典(dict)篇（二）

最新推荐文章于 2024-06-10 22:18:41 发布

熊猫Devin

最新推荐文章于 2024-06-10 22:18:41 发布

阅读量711

点赞数 24

分类专栏： python笔记文章标签： python 开发语言

本文链接：https://blog.csdn.net/d710055071/article/details/136920353

版权

python笔记专栏收录该内容

92 篇文章 3 订阅

订阅专栏

文章目录

4.8 items()
4.9 判断指定键是否存在于字典中
4.10 keys()函数
4.11 pop()函数
4.12 popitem()函数
4.13 setdefault()函数
4.14 update()函数
4.15 values()函数

4.8 items()

在Python中，字典的items()方法返回一个特殊的视图对象，该对象包含了字典中所有的键值对（key-value pairs）。每个键值对作为一个元组（tuple）返回，元组的第一个元素是键，第二个元素是对应的值。这个视图对象会随着字典的更新而动态变化。

以下是如何使用items()方法的示例：

# 创建一个字典
my_dict = {
    'apple': 1,
    'banana': 2,
    'cherry': 3
}

# 使用items()方法获取字典的键值对
items_view = my_dict.items()

# 打印items_view的类型，它是一个字典视图对象
print(type(items_view))  # 输出: <class 'dict_items'>

# 遍历字典的键值对
for key, value in items_view:
    print(key, value)

# 输出:
# apple 1
# Banana 2
# Cherry 3

# 由于items_view是一个视图，所以原始字典的更改会反映在视图中
my_dict['banana'] = 5

# 再次遍历键值对，你会看到'banana'的值已经改变
for key, value in items_view:
    print(key, value)

# 输出:
# Apple 1
# Banana 5
# Cherry 3

# 你可以将items()返回的视图转换为列表、元组或其他可迭代对象
items_list = list(my_dict.items())
print(items_list)  # 输出: [('apple', 1), ('banana', 5), ('cherry', 3)]

需要注意的是，虽然items()方法返回的是一个视图对象，但它并不是字典的一个拷贝。因此，对视图对象的修改会反映到原始字典上，反之亦然。

此外，items()返回的视图对象还支持集合操作，如并集（union）、交集（intersection）和差集（difference）等，但这要求操作的对象也必须是字典视图或集合。

# 创建两个字典
dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'b': 2, 'c': 3, 'd': 4}

# 获取两个字典的items视图
view1 = dict1.items()
view2 = dict2.items()

# 求两个视图的交集
intersection_view = view1.intersection(view2)
print(list(intersection_view))  # 输出: [('b', 2), ('c', 3)]

4.9 判断指定键是否存在于字典中

在Python中，如果你想判断一个指定的键是否存在于字典中，你可以使用in关键字来检查。这是一个简单而直接的方法，它会返回一个布尔值（True或False），表示键是否在字典中。

下面是一个例子：

# 创建一个字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 检查键'name'是否存在于字典中
if 'name' in my_dict:
    print("键'name'存在于字典中。")
else:
    print("键'name'不存在于字典中。")

# 检查键'job'是否存在于字典中
if 'job' in my_dict:
    print("键'job'存在于字典中。")
else:
    print("键'job'不存在于字典中。")

输出将会是：

键'name'存在于字典中。
键'job'不存在于字典中。

在这个例子中，‘name’ in my_dict会返回True，因为’name’是my_dict的一个键。而’job’ in my_dict会返回False，因为’job’不是my_dict的一个键。

这种方法不会引发异常，即使键不存在于字典中也不会有问题。这是推荐的方式来检查键的存在性，因为它既安全又简单。

4.10 keys()函数

在Python中，字典（dict）的keys()方法用于获取字典中所有的键（key）的视图对象。这个视图对象会展示字典中所有的键，并且随着字典的更新而动态变化。

下面是keys()方法的基本用法：

# 创建一个字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 使用keys()方法获取字典中所有的键
keys_view = my_dict.keys()

# 打印keys_view的类型，它是一个字典视图对象
print(type(keys_view))  # 输出: <class 'dict_keys'>

# 遍历字典的键
for key in keys_view:
    print(key)

# 输出:
# name
# age
# city

# 由于keys_view是一个视图，所以原始字典的更改会反映在视图中
my_dict['job'] = 'Engineer'

# 再次遍历键，你会看到新的键'job'已经添加
for key in keys_view:
    print(key)

# 输出:
# name
# age
# city
# job

# 你可以将keys()返回的视图转换为列表或其他可迭代对象
keys_list = list(my_dict.keys())
print(keys_list)  # 输出: ['name', 'age', 'city', 'job']

需要注意的是，keys()方法返回的是一个视图对象，而不是一个列表或其他类型的集合。这个视图对象支持集合操作，如并集、交集和差集等，但它并不是字典的一个拷贝。因此，对视图对象的修改会反映到原始字典上，反之亦然。

与items()方法类似，keys()方法返回的视图对象也支持迭代操作，你可以使用for循环来遍历字典中的所有键。同时，你也可以使用len()函数来获取字典中键的数量，或者使用in关键字来检查某个键是否存在于字典中。

4.11 pop()函数

在Python中，字典的pop()方法用于删除并返回字典中指定键对应的值。如果指定的键不存在于字典中，pop()方法会抛出一个KeyError异常。为了避免这个异常，你可以提供一个可选的默认值作为pop()方法的第二个参数，这样当键不存在时，会返回这个默认值而不是抛出异常。

以下是pop()方法的基本用法：

# 创建一个字典
my_dict = {
    'apple': 1,
    'banana': 2,
    'cherry': 3
}

# 使用pop()方法删除并返回一个键的值
value = my_dict.pop('apple')
print(value)       # 输出: 1
print(my_dict)     # 输出: {'banana': 2, 'cherry': 3}

# 尝试删除一个不存在的键，不提供默认值
try:
    value = my_dict.pop('orange')
except KeyError:
    print("键'orange'不存在于字典中")

# 尝试删除一个不存在的键，并提供默认值
value = my_dict.pop('orange', 'Not found')
print(value)       # 输出: 'Not found'

# 你可以通过pop()方法同时删除多个键，但这需要解包一个键的列表或元组
keys_to_remove = ['banana', 'cherry']
for key in keys_to_remove:
    my_dict.pop(key, None)

print(my_dict)     # 输出: {}

在上面的例子中，pop(‘apple’)删除了键’apple’及其对应的值1，并返回了1。然后，我们尝试删除一个不存在的键’orange’，由于我们没有提供默认值，所以抛出了KeyError异常。在随后的尝试中，我们提供了默认值’Not found’，所以当键不存在时，pop()方法返回了这个默认值而不是抛出异常。

最后，我们通过循环和pop()方法删除了多个键。这里使用了None作为默认值，这意味着如果键不存在，pop()方法将返回None。

需要注意的是，pop()方法会直接修改原始字典，删除指定的键及其对应的值。如果你不希望修改原始字典，而是想要一个不包含指定键的新字典，你可以使用字典推导式或其他方法来复制字典并删除不需要的键。

4.12 popitem()函数

在Python中，字典（dict）的popitem()方法用于随机删除字典中的一个键值对，并返回被删除的键值对。如果字典为空，调用popitem()会抛出KeyError异常。

这个方法通常在你不需要关心哪个键值对被删除，只是想减小字典大小或者需要随机处理字典中的元素时非常有用。

以下是popitem()方法的基本用法：

# 创建一个字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 使用popitem()随机删除一个键值对，并打印被删除的键值对
item = my_dict.popitem()
print(item)  # 输出可能是 ('city', 'New York')，但顺序可能是随机的

# 再次调用popitem()删除另一个键值对
item = my_dict.popitem()
print(item)  # 输出可能是 ('age', 30) 或 ('name', 'Alice')，顺序也是随机的

# 尝试在一个空字典上调用popitem()
empty_dict = {}
try:
    item = empty_dict.popitem()
except KeyError:
    print("字典为空，不能调用popitem()")

# 输出: 字典为空，不能调用popitem()

需要注意的是，popitem()方法的行为在Python 3.7及以后的版本中有所改变。在Python 3.6及之前的版本中，popitem()会删除并返回字典中的最后一个键值对（按照插入顺序）。然而，在Python 3.7及以后的版本中，字典是按照插入顺序保持有序的，但popitem()的行为依然是随机的，它不再遵循LIFO（后进先出）原则。

如果你需要按照特定的顺序（如FIFO或LIFO）删除键值对，你可能需要使用其他数据结构，如collections.deque或collections.OrderedDict。其中，OrderedDict保持了键值对的插入顺序，并且提供了popitem(last=True)方法来控制是删除并返回第一个还是最后一个键值对。例如，popitem(last=False)将删除并返回第一个键值对，而popitem(last=True)（或简单地调用popitem()）将删除并返回最后一个键值对。

4.13 setdefault()函数

在Python中，字典（dict）的setdefault()方法用于获取指定键的值，如果该键不存在于字典中，则它会设置该键的值为默认值，并返回这个默认值。如果键已经存在于字典中，则setdefault()方法会返回键的当前值，并不会修改它。

以下是setdefault()方法的基本用法：

# 创建一个字典
my_dict = {
    'name': 'Alice',
    'age': 30
}

# 使用setdefault()获取一个已存在的键的值
age = my_dict.setdefault('age', 25)
print(age)       # 输出: 30，因为'age'键已经存在，返回其当前值

# 使用setdefault()获取一个不存在的键的值，并设置默认值
job = my_dict.setdefault('job', 'Unknown')
print(job)       # 输出: 'Unknown'，因为'job'键不存在，设置其值为'Unknown'并返回

# 再次尝试获取'job'键的值，这次它已经存在于字典中了
job = my_dict.setdefault('job', 'Engineer')
print(job)       # 输出: 'Unknown'，因为'job'键已经存在，返回其当前值，不修改它

# setdefault()也可以用来更新已存在键的值
my_dict.setdefault('age', 40)  # 'age'键已存在，但值不会被改变
print(my_dict)  # 输出: {'name': 'Alice', 'age': 30, 'job': 'Unknown'}

# 使用setdefault()与可变对象一起时要小心，因为默认值是可变的，可能会导致不期望的行为
my_dict.setdefault('hobbies', []).append('reading')
my_dict.setdefault('hobbies', []).append('traveling')
print(my_dict)  # 输出: {'name': 'Alice', 'age': 30, 'job': 'Unknown', 'hobbies': ['reading', 'traveling']}
# 注意，这里'hobbies'键对应的值是一个列表，两次setdefault()调用都返回了同一个列表对象，
# 所以两次append()操作都修改了同一个列表。

在上面的例子中，setdefault()方法被用来获取键’age’的值，因为该键已经存在于字典中，所以返回了它的当前值30。然后，我们使用setdefault()方法尝试获取一个不存在的键’job’的值，并提供了一个默认值’Unknown’。因为’job’键不存在，所以它被添加到字典中，并返回了默认值’Unknown’。

需要注意的是，setdefault()方法在处理可变对象（如列表、字典等）作为默认值时要特别小心。由于默认值是可变的，如果多次调用setdefault()并尝试添加元素到默认值中，可能会导致不期望的行为，如上例中的hobbies键所示。在这种情况下，最好先检查键是否存在，然后决定是否要添加元素。

4.14 update()函数

在Python中，字典（dict）的update()方法用于将一个字典或键值对更新到另一个字典中。如果更新的键在目标字典中已经存在，那么它的值会被新的值所替换；如果键不存在，那么它会被添加到字典中。

update()方法可以接受一个字典作为参数，也可以接受一个可变数量的键值对参数。下面展示了update()方法的基本用法：

# 创建一个字典
my_dict = {
    'apple': 1,
    'banana': 2
}

# 使用update()方法更新一个字典
new_items = {
    'cherry': 3,
    'apple': 4  # 这将更新'apple'键的值
}
my_dict.update(new_items)

print(my_dict)  # 输出: {'apple': 4, 'banana': 2, 'cherry': 3}

# 使用update()方法更新单个键值对
my_dict.update(orange=5)

print(my_dict)  # 输出: {'apple': 4, 'banana': 2, 'cherry': 3, 'orange': 5}

# 使用update()方法更新多个键值对
my_dict.update(grape=6, pear=7)

print(my_dict)  # 输出: {'apple': 4, 'banana': 2, 'cherry': 3, 'orange': 5, 'grape': 6, 'pear': 7}

# 如果传入的键在字典中不存在，该键将被添加
my_dict.update(kiwi=8)

print(my_dict)  # 输出: {'apple': 4, 'banana': 2, 'cherry': 3, 'orange': 5, 'grape': 6, 'pear': 7, 'kiwi': 8}

在上面的例子中，我们首先创建了一个包含’apple’和’banana’两个键的字典my_dict。然后，我们使用update()方法将一个新的字典new_items中的键值对合并到my_dict中。由于’apple’键在两个字典中都存在，所以my_dict中’apple’键的值被更新为4。

接下来，我们使用update()方法添加了一个新的键值对’orange’: 5，然后添加了另外两个键值对’grape’: 6和’pear’: 7。最后，我们添加了一个键’kiwi’，它在my_dict中之前并不存在。

需要注意的是，update()方法不会返回任何值（返回None），它直接在原始字典上进行修改。如果你不希望修改原始字典，而是想要创建一个新的字典，你需要先复制原始字典，然后在复制的字典上调用update()方法。

# 复制字典并更新
new_dict = my_dict.copy()
new_dict.update(grape=9, pear=10)

print(new_dict)  # 输出: {'apple': 4, 'banana': 2, 'cherry': 3, 'orange': 5, 'grape': 9, 'pear': 10, 'kiwi': 8}
print(my_dict)  # 输出: {'apple': 4, 'banana': 2, 'cherry': 3, 'orange': 5, 'grape': 6, 'pear': 7, 'kiwi': 8}

在这个例子中，new_dict是my_dict的一个副本，我们在这个副本上调用update()方法，因此my_dict的内容保持不变。

4.15 values()函数

在Python中，字典（dict）的values()方法返回一个视图对象，该对象显示字典中所有的值。这个视图会实时反映字典的更新。也就是说，如果原字典在视图生成后发生变化，视图也会相应地更新。但是，视图本身并不支持添加或删除操作，如果尝试这样做，会抛出TypeError。

以下是一个使用values()方法的例子：

# 创建一个字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 使用values()获取字典中的所有值
values_view = my_dict.values()

# 打印视图对象
print(values_view)  # 输出可能是一个视图对象，如：dict_values(['Alice', 30, 'New York'])

# 转换为列表以打印所有值
values_list = list(values_view)
print(values_list)  # 输出: ['Alice', 30, 'New York']

# 修改字典
my_dict['age'] = 31

# 再次打印视图对象，将显示更新后的值
print(values_view)  # 输出可能类似：dict_values(['Alice', 31, 'New York'])

# 尝试通过视图对象添加或删除键值对将失败
try:
    values_view.add('country', 'USA')  # 这将抛出TypeError
except TypeError as e:
    print(e)  # 输出类似：'dict_values' object has no attribute 'add'

try:
    del values_view['name']  # 这将抛出TypeError
except TypeError as e:
    print(e)  # 输出类似：'dict_values' object does not support item deletion

请注意，由于values()返回的是一个视图对象，而不是一个列表或其他可修改的数据结构，因此你不能直接对这个视图进行添加或删除操作。如果你需要一个可以修改的数据结构，你应该将视图转换为列表或其他合适的类型。

此外，values()返回的视图是动态的，这意味着它会随着字典的更改而自动更新。这与dict.values()方法返回的静态列表不同，后者是在调用时创建的，不会随后续的字典更改而更新。

熊猫Devin

关注

24
点赞
踩
18

收藏

觉得还不错? 一键收藏
打赏
0
评论
字典(dict)篇（二）

然而，在Python 3.7及以后的版本中，字典是按照插入顺序保持有序的，但popitem()的行为依然是随机的，它不再遵循LIFO（后进先出）原则。在上面的例子中，setdefault()方法被用来获取键’age’的值，因为该键已经存在于字典中，所以返回了它的当前值30。在Python中，字典（dict）的setdefault()方法用于获取指定键的值，如果该键不存在于字典中，则它会设置该键的值为默认值，并返回这个默认值。需要注意的是，pop()方法会直接修改原始字典，删除指定的键及其对应的值。
复制链接

扫一扫