Python遍历字典key和value的5种方法详解：for循环、items()、keys()、values()和列表推导式

python遍历字典中的key和value方法

2023 年 09 月 05 日 09 时 02 分 22 秒进行了更新，更新的作者是 shuo5555。

本文从多个角度对 Python 遍历字典中的 key 和 value 进行了分析，其中包括运用 for 循环、items()方法、keys()方法、values()方法以及列表推导式。通过本文的相关介绍，读者能够更加深入地知晓 Python 中遍历字典的各种方法，有需求的朋友可以参考一下。

目录

[id_1256099459]

Python是一种高级编程语言。它具备支持多种数据类型的能力。其中，字典是一种极为常用的数据类型。字典是由无序的键值对所组成的集合。我们能够通过键来获取对应的值。在 Python 当中，我们可以运用不同的方法去遍历字典中的键与值。本文将会从多个角度来剖析 Python 是如何遍历字典中的 key 和 value 的。

一、使用for循环遍历字典中的key和value

使用 for 循环能够对字典里的每一个元素进行循环遍历。以下是一个示例代码：

这个字典包含了一些信息，其中“Name”对应的是“John”，“Age”对应的是 25，“Location”对应的是“New York”。
for key in dict:
print(key, dict[key])

输出结果为：

Name John

Age 25

Location New York

在这个示例里，我们先定义了一个字典。接着，通过 for 循环去遍历这个字典里的每一个元素。在循环的过程中，我们能够利用字典的 key 去访问相应的 value，并且把它们打印出来。

二、使用items()方法遍历字典中的key和value

Python 中的字典类具备一个 items()方法，此方法能够返回字典里的所有键值对。以下是一个示例代码：

dict = {'Name': 'John', 'Age': 25, 'Location': 'New York'}
对于键和值，在字典的项中进行遍历。具体来说，对于每一个键值对，键用 key 表示，值用 value 表示，通过这种方式遍历字典中的所有元素。
print(key, value)

输出结果为：

Name John

Age 25

Location New York

在这个示例里，我们借助 items()方法去获取字典里的所有键值对。接着，通过 for 循环逐个遍历每一个键值对。在循环的主体部分，我们能够利用键值对中的 key 和 value 来开展操作。

三、使用keys()方法遍历字典中的key

如果我们仅仅想要遍历字典里的 key，那么可以运用 keys()方法。以下是一个示例代码：

dict = {'Name': 'John', 'Age': 25, 'Location': 'New York'}
for key in dict.keys():
print(key)

输出结果为：

Name

Age

Location

在这个示例里，我们借助 keys()方法去获取字典里的所有 key ，接着通过 for 循环逐个遍历每一个 key 。在循环的主体部分，我们仅仅打印了 key 。

四、使用values()方法遍历字典中的value

如果我们仅仅想要遍历字典里的 value，那么可以运用 values()方法。以下是一个示例代码：

dict = {'Name': 'John', 'Age': 25, 'Location': 'New York'}
for value in dict.values():
print(value)

输出结果为：

John

25

New York

在这个示例里，我们借助 values()方法去获取字典里的所有 value ，接着通过 for 循环逐个遍历每一个 value 。在循环的主体部分，我们仅仅打印了 value 。

五、使用列表推导式遍历字典中的key和value

除了上述那些方法之外，我们还能够运用列表推导式去对字典中的 key 以及 value 进行遍历。以下是一个示例代码：

dict = {'Name': 'John', 'Age': 25, 'Location': 'New York'}
对于字典中的每一个键值对，将其组成一个元组并添加到列表中，即得到 items = [(key, value) for key, value in dict.items()] 。具体来说，就是遍历字典中的每一个键值对，将键作为元组的第一个元素，值作为元组的第二个元素，然后将这些元组添加到列表 items 中。
print(items)

输出结果为：

['Name' 的值是 'John'，'Age' 的值是 25，'Location' 的值是 'New York']

在这个示例里，我们借助列表推导式去遍历字典里的所有键值对，接着把它们存到一个列表当中。在列表推导式里，我们运用了字典的 items() 方法来获取所有的键值对，并且用 for 循环来对每一个键值对进行遍历。在每一次循环的时候，我们使用一个元组来存储当前的键值对。

六、总结

本文从多个角度对 Python 遍历字典中的 key 和 value 的方式进行了分析，其中包含使用 for 循环这种方式，也有利用 items()方法来实现，还有运用 keys()方法以及 values()方法，同时还包括使用列表推导式。经由本文的介绍，读者能够更加深入地知晓 Python 中遍历字典的各种方法，从而为日后的编程工作给予帮助。

Python 遍历字典的若干方法

我们知道字典是 Python 中重要且有用的内置数据结构之一。字典无处不在，是语言本身的基本组成部分。

我们能够利用字典去解决诸多编程方面的问题。那么，在今天，我们就一同来看一看该怎样在 Python 当中对字典进行遍历。

全文内容：

文中所提及的 Python 指的是 CPython 这一实现方式；

译文如下：

字典是 Python 的重要基础。在这门语言中，其很多方面都是以字典为核心构建起来的。

模块是与 Python 实现紧密联系且为字典的例子；类是与 Python 实现紧密联系且为字典的例子；对象是与 Python 实现紧密联系且为字典的例子；globals()是与 Python 实现紧密联系且为字典的例子；locals()是与 Python 实现紧密联系且为字典的例子。

以下是 Python 官方文档定义字典的方式：

需要注意的是：

序列支持使用整数索引进行元素访问，它是可迭代对象。而字典是按键编制索引的。这就表明我们能够利用关联的键，而非整数索引，去访问存储在字典里的值。

字典中的键类似于 set，它是由可哈希且唯一的对象所组成的集合。因为键需要进行可哈希的处理，所以不能把可变对象当作字典的键，也就是说键不能是可变的数据类型。

一方面，字典的值能够是任何 Python 类型，不管这些类型是否可哈希。从字面意义来讲，对于值不存在任何限制。我们可以把任何数据类型当作 Python 字典里的值。

在 Python 3.6 之前，字典属于无序的数据结构。这表明 item 的顺序通常和插入的顺序不一致。

>>> # Python 3.5
likes 包含“颜色”为“蓝色”，“水果”为“苹果”，“宠物”为“狗”。
>>> likes
颜色是蓝色，宠物是狗，水果是苹果。

可以看到，生成的词典里，item 的顺序和最初插入 item 的顺序不一样。 生成的词典中，item 的先后顺序与最初插入 item 的先后顺序不相符。 能看到，生成的词典中，item 的次序和最初插入 item 的次序存在差异。 可以发现，生成的词典里，item 的顺序并非与最初插入 item 的顺序相同。 能看出，生成的词典中，item 的顺序和最初插入 item 的顺序是不一致的。 可以知晓，生成的词典中，item 的顺序与最初插入 item 的顺序不相符。 可以察觉到，生成的词典中，item 的顺序和最初插入 item 的顺序有差别。 可以了解到，生成的词典中，item 的顺序与最初插入 item 的顺序不一样。 可以明白，生成的词典中，item 的顺序和最初插入 item 的顺序不相同。

在 Python 3.6 以及更高的版本里，字典的键和值会与它们被插入到底层字典的顺序保持一致。也就是说，从 3.6 这个版本开始，字典转变为了一种紧凑且有序的数据结构。

>>> # Python 3.6
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> likes
这个字典的颜色是蓝色，里面的水果是苹果，宠物是狗。

保持 item 有序是很有用的功能。然而，若所使用的代码支持较旧的 Python 版本，就不能依靠此功能，因为可能会产生 bug。而对于较新的版本，依赖该特性则是完全安全的。

字典有另一个重要的特点，那就是它们属于可变的数据类型。这表明我们能够依据需求在原地对其项目进行添加、删除以及更新的操作。

值得注意的是，这种可变性意味着不能把字典当作另一个字典里的键。

如何在 python 中遍历字典

Python 开发人员时常会碰到这样的情形：在针对其键值对实施某些操作的时候，需要对现有的字典进行遍历。

因此，了解 Python 中字典迭代的不同方法是很重要的。保持 item 的有序性是一个很有用的功能。

Python 的字典具备一些独特的方法，这些方法在 Python 的内部被用于执行某些操作。

这两个方法的命名约定为，在方法名的开头添加两个下划线，并且在方法名的末尾也添加两个下划线。

可以通过使用内置的 dir()函数来获取任何 Python 对象所提供的方法和属性的列表。当使用空字典作为参数来运行 dir()时，就能够获得 dict 类的所有方法和属性。

>>> dir({})
这些属性包括 '__class__'、'__contains__'、'__delattr__' 等等，还有 '__iter__' 等等。

可以看到一个名为'__iter__'的属性，这种属性是 Python 在需要容器数据类型的迭代器时会自动调用的一种方法

该方法会返回一个新的迭代器对象，这个对象能够让我们去遍历底层容器类型里的所有项。

Python 字典在默认情况下是允许.__iter__()直接进行迭代键操作的。当你在 for 循环中直接使用字典时，Python 会自动调用.__iter__()属性，这样你就能获得一个遍历其键的迭代器。

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> for key in likes:
...     print(key)
...
color
fruit
pet

Python 很聪明，它知晓 likes 是一个字典，并且实现了.__iter__()。在这个事例当中，Python 会自动去调用.__iter__()，这样就能允许对 likes 字典的键进行迭代。

在 Python 中遍历字典有主要的方法，即只需将字典直接放入一个 for 循环里。

如果使用此方法并且与[key]运算符一同使用，那么在循环访问键的时候能够访问字典的值。

>>> for key in likes:
输出键和对应的值，即输出键，然后输出“->”，最后输出键对应的值，也就是输出键所对应的 likes 中的值
...
color -> blue
fruit -> apple
pet -> dog

在这个例子里，使用 key 去访问目标字典的键，同时使用 likes[key]去访问目标字典的值

在 Python 中直接遍历字典是很简单的。然而，字典提供了一些更方便且更明确的工具，能够让我们获得相同的结果。

.items()这个方法处于这种状况，它规定了一种能够快速对字典的 item 或者键值对进行迭代的方式

使用字典时，一个常见要求可能是同时循环访问键和值。.items()方法会返回一个视图对象，这个视图对象中包含着字典的项，并且这些项是以键值元组的形式存在的。

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> likes.items()
语言结构为一个包含三个键值对的可迭代对象 dict_items。其中一个键值对的键为'color'，值为'blue'；另一个键值对的键为'fruit'，值为'apple'；还有一个键值对的键为'pet'，值为'dog'。

字典视图对象能够提供字典项的一种动态的视角。在这种情况下，“动态”意味着当字典发生改变时，该视图会相应地反映出这些改变。

视图是可以进行迭代操作的。所以，我们能够利用调用.items()所生成的视图对象，来循环遍历字典中的各项。以下示例便展示了这一过程：

对于每一个 item 而言，它处于 likes 的 items 之中。
...     print(item)
...
('color', 'blue')
('fruit', 'apple')
('pet', 'dog')

在此示例中，会返回一个视图对象，这个对象能够一次生成一个键值对，通过.items()方法，并且允许我们对其进行循环访问。

仔细观察产生的各个项目.items()，就会注意到它们是 tuple 对象。

>>> for item in likes.items():
...     print(item)
...     print(type(item))
...
('color', 'blue')

('fruit', 'apple')

('pet', 'dog')

能够看到所有的 item 均为元组。知晓这一情况之后，就能够运用元组解包来同时遍历键与值。

要实现并行迭代并通过键和值来进行，只需把每个 item 的元素进行解压缩。解压缩后会得到两个不同的变量，一个用来表示键，另一个用来表示值。

对于键和值的每一对，在 likes 这个字典中，键为 key，值为 value。
输出 key 以及它对应的 value ，中间用“->”连接。
...
color -> blue
fruit -> apple
pet -> dog

在 for 循环头中的 key 和 value 变量会执行解包操作。每次循环运行时，key 会获取到对当前键的引用，而 value 会获取到对值的引用。

这样一来，我们能更好地对字典内容进行把控。所以，我们能够以可读的方式去处理键，也能够以 python 的方式去处理值。

Python 字典提供了第二种用于遍历其键的方式。除了在循环过程中直接运用目标字典之外，还能够运用.keys()这个方法。

这个方法返回一个只包含字典键的视图对象

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> likes.keys()
这个字典的键有'color'、'fruit'和'pet'。

该方法的.keys()能够返回一个对象，这个对象能提供 likes 键的动态视图。利用此视图对象，就可以对字典键进行循环访问。

>>> for key in likes.keys():
...     print(key)
...
color
fruit
pet

当您在 likes 上调用.keys()这个操作时，就能够获得键的视图。因为 Python 知晓视图对象是可以进行迭代的，所以它便开始进行循环。

为什么要使用.keys()呢？而不是直接去遍历字典。简单来讲，显式地运用.keys()能够让你更清晰地表达出只是遍历键的这种意图。

在遍历字典时，另一个常见的需求是仅遍历值。实现这个需求的方法是使用.values()方法，此方法会返回一个包含底层字典中值的视图。

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> likes.values()
这个 dict_values 包含了 'blue'、'apple' 和 'dog' 这三个元素。它是一个包含了多种类型值的集合。其中有颜色值 'blue'，有水果 'apple'，还有动物 'dog'。

上面的代码会返回一个视图对象，而这个视图对象通过.values()方法也能被返回。

和其他视图对象一样，结果的.values()是能够进行迭代的。所以，它可以在循环里被使用。

对于 likes 的值中的每一个值进行遍历。
...     print(value)
...
blue
apple
dog

使用.values()，只能访问目标字典的值

有时，在 Python 中迭代字典时需要更改字典中的值

在下面的例子中，你在一个字典中更新了一堆产品的价格:

水果有“apple”，其价格为 0.40；有“orange”，价格是 0.35；有“banana”，价格为 0.25。
对于水果和价格这一组合，在水果的各项（items）中，价格是与水果相对应的；对于每一种水果，都有其对应的价格；在水果的各项当中，每一种水果都有与之对应的价格；水果的各项中，每一个水果都对应着一个价格；在水果的各项里面，每种水果都有其对应的价格；对于水果的各项而言，每一种水果都有对应的价格。
将水果的价格乘以 0.9 后保留两位小数得到的结果是 fruits[fruit]
...
>>> fruits
苹果占比 0.36，橙子占比 0.32，香蕉占比 0.23。

在上述例子中需注意：我们为更新值，运用了原始的字典，并非像“price = round(price * 0.9, 2)”那样直接对当前价格进行更新。

如果以 price = round(price * 0.9, 2)这样的方式进行操作，那么对水果或价格的重新分配并未在原先的字典中得以体现。

会致使丢失对字典的引用，并且没有达成更改字典中任何内容这一结果

Python 字典具有可变的特性，所以我们能够依据需求将其中现有的 item 删除掉。

在下面的示例中，我们根据项的特定值选择性地删除项

注意，为了在遍历字典时安全地缩小字典，我们需要使用一个副本

>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
对于水果中的每一个水果（这里的水果指的是 fruits 中的元素），在 fruits 的副本（即 fruits.copy()）中进行遍历操作。
如果水果[fruit]的值大于等于 0.30 。
...         del fruits[fruit]
...
>>> fruits
{'banana': 0.25}

在这个例子里，通过使用.copy()来构建目标字典 fruits 的浅拷贝。接着进行循环，在循环过程中遍历这个副本，与此同时从原始字典里移除项，在本示例中，是运用 del 语句来删除字典项。

但是也可以使用.pop()将目标键作为参数

如果在尝试删除循环中的 item 时不使用目标词典的一个副本，那么就会收到错误。

>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
>>> for fruit in fruits:
...     if fruits[fruit] >= 0.30:
...         del fruits[fruit]
...
追踪回溯（最近的调用在最后）：
  File "", line 1, in 
    for fruit in fruits:
RuntimeError 发生了，原因是在迭代过程中字典的大小发生了改变。

在迭代过程中，当你试图从字典里删除一个 item 时，Python 会引发 RuntimeError 。

原始字典的大小发生了变化，所以对于如何继续迭代并不明确。因此，为避免这个问题，在迭代过程中应始终使用字典的副本。

遍历期间对字典的操作

有时我们期望在原本的字典基础之上创建一个仅包含符合特定条件的新字典。

我们可以在遍历原字典的时候加上条件判断

有一个名为 numbers 的字典，其中包含了键值对："one"对应 1，"two"对应 2，"three"对应 3，"four"对应 4。
>>> small_numbers = {}
遍历 numbers 中的每个键值对，对于其中的每一个键值对，将键赋值给 key，将值赋值给 value 。
...     if value <= 2:
...         small_numbers[key] = value
...
>>> small_numbers
{'one': 1, 'two': 2}

在此示例里，把筛选值小于项目 2 的那些筛选出来，然后把它们添加到 small_numbers 这个字典当中。

有一种技术能够用于从字典中对 item 进行过滤。其原因是键的视图对象与 Python 集合对象相似。

所以，它们能够支持集合方面的操作，像并集、交集以及差分等。能够借助这种与集合类似的行为，从字典里把某些键给过滤掉。

>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
获取 fruits 的键值集合，然后从中去掉 "orange" 这个键。
{'apple', 'banana'}

还可以更简洁

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}
对于 numbers 中的每个键值对（键为 key，值为 value），如果 value 满足特定条件，就进行相应的操作。具体来说，就是遍历 numbers 中的每一个元素，检查其值是否符合要求，然后根据条件执行相应的逻辑。<= 2}
{'one': 1, 'two': 2}

通过计算字典的键与一组不需要的键之间的差分，从而获得键集，再用这个键集构建一个新词典。

>>> non_citrus = {}
对于在 fruits.keys() 中的键（除了 "orange" 之外）：
非柑橘类水果的[key]等于水果的[key]。
...
>>> non_citrus
苹果的占比是 0.4，香蕉的占比是 0.25。

在遍历字典时，我们可以对字典的值进行计算

收入情况如下：“apple”的收入为 5600.00，“orange”的收入为 3500.00，“banana”的收入为 5000.00。
>>> total_income = 0.00
对于收入 in 收入.values()：
将 income 累加到 total_income 中。
...
>>> total_income
14100.0

可以使用内置的 sum() 函数。将字典中的值直接作为参数传递给 sum() 以进行求和操作。

>>> incomes = {"apple": 5600.00, "orange": 3500.00, "banana": 5000.00}
>>> sum(incomes.values())
14100.0

我们可以在遍历的时候交换字典的键和值

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> swapped = {}
>>> for key, value in numbers.items():
...     swapped[value] = key
...
>>> swapped
这个字典包含了四个元素，分别是 one、two、three 和 four。其中一个元素是 one，另一个元素是 two，还有一个元素是 three，最后一个元素是 four。

更简洁的写法

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}
对于 numbers 中的每个键值对，将键作为 key，值作为 value，生成一个字典 {value: key} 。具体来说，遍历 numbers 中的每个键值对，把键赋值给 key ，把值赋值给 value ，然后将 {value: key} 作为一个元素添加到新的字典中。
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

需要注意的是，原始字典值中的数据必须是可哈希数据类型

我们能够把内置的 zip()函数和 dict()构造函数结合起来使用。

创建一个字典，通过将 numbers 字典的值作为键，numbers 字典的键作为值来进行映射，最终得到一个新的字典。
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

在上面的示例里，先通过 zip() 来生成值键对的元组，接着，把生成的元组当作参数，利用 dict() 构建出所需要的字典。

字典推导式

与列表推导式不同，字典推导式需要一个映射到值的键

有以下几种类别：“color”类别、“fruit”类别、“pet”类别。
有一些对象，分别是“蓝色”“苹果”“狗”。
likes 是通过将 categories 和 objects 进行 zip 操作后，以键值对的形式创建的字典，其中键为 categories 中的元素，值为 objects 中对应的元素。
>>> likes
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}

上面的对象里，zip()把两个可迭代对象，即 categories 和 objects 接收过来，生成了一个 tuple 对象。接着，这个 tuple 对象被解压缩到了 key 和 value 当中。最后，它被用于创建新的所需字典。

更简洁的方法如下：

>>> categories = ["color", "fruit", "pet"]
>>> objects = ["blue", "apple", "dog"]
将类别与对象进行配对，得到一个由类别和对象组成的字典，这个字典的键是类别，值是对象。
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}

zip()函数会从原始列表中生成键值对，dict()构造函数则承担着创建新字典的任务。

这篇关于 Python 遍历字典的若干方法的文章到此就介绍完啦。更多关于 Python 遍历字典的内容，大家可以搜索脚本之家以前的文章，或者继续浏览下面的相关文章。希望大家以后能多多支持脚本之家！