Python遍历字典:如何在Python中遍历字典?

2021年8月13日05:26:45 发表评论 4,282 次浏览

字典是Python 中最重要和最有用的数据结构之一。他们可以帮助你解决各种各样的编程问题。本教程将带你深入了解如何在Python中遍历字典。

在本Python遍历字典教程结束时,你将知道:

  • 什么是字典,以及它们的一些主要特性和实现细节
  • 如何使用 Python 提供的基本工具在Python中遍历字典
  • 通过在Python中遍历字典可以执行什么样的现实世界任务
  • 如何使用一些更高级的技术和策略在Python中遍历字典、Python遍历字典键值以及Python遍历字典的值

有关词典的更多信息,你可以查看以下资源:

  • Python 中的字典
  • Python 3 中的 Itertools示例
  • 有关文档map()filter()

下面我们详细讨论Python遍历字典,看看如何在Python中遍历字典。

关于Python遍历字典的几句话

字典是 Python 的基石。该语言本身是围绕字典构建的。模块,类,对象,globals()locals():所有这些都是字典。字典从一开始就是 Python 的核心。

Python 的官方文档对字典的定义如下:

一个关联数组,其中任意键映射到值。键可以是任何带有__hash__()__eq__()方法的对象。(来源

Python遍历字典有几点需要牢记:

  1. 字典将键映射到值并将它们存储在数组或集合中。
  2. 键必须是可散列的类型,这意味着它们必须具有在键的生命周期内永远不会改变的散列值。

字典经常用于解决各种编程问题,因此它们是 Python 开发人员工具包的基本组成部分。

序列不同,它是支持使用整数索引访问元素的可遍历对象,字典由键索引。

字典中的键很像set,它是可散列和唯一对象的集合。因为对象需要是可散列的,所以不能将可变对象用作字典键。

另一方面,值可以是任何 Python 类型,无论它们是否是可散列的。从字面上看,对值没有限制。

在 Python 3.6 及更高版本中,字典的键和值按照创建它们的相同顺序进行遍历。但是,这种行为可能因不同的 Python 版本而异,并且取决于字典的插入和删除历史。

在 Python 2.7 中,字典是无序结构。字典项目的顺序是混乱的。这意味着项目的顺序是确定性和可重复的。让我们看一个Python遍历字典的例子:>>>

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}

如果你离开解释器并稍后打开一个新的交互式会话,你将获得相同的项目顺序:>>>

>>> # Python 2.7. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}

仔细查看这两个输出,你会发现两种情况下的结果顺序完全相同。这就是为什么你可以说排序是确定性的。

在 Python 3.5 中,字典仍然是无序的,但这次是随机的数据结构。这意味着每次重新运行字典时,你都会得到不同的项目顺序。让我们来看看:>>>

>>> # Python 3.5
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}

如果你进入一个新的交互式会话,那么你将获得以下信息:>>>

>>> # Python 3.5. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}

这一次,你可以看到两个输出中项目的顺序不同。这就是为什么你可以说它们是随机数据结构的原因。

在 Python 3.6 及更高版本中,字典是有序的数据结构,这意味着它们保持元素的顺序与它们被引入时的顺序相同,如下所示:>>>

>>> # Python 3.6 and beyond
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}

如何在Python中遍历字典?这是 Python 词典的一个相对较新的特性,也是一个非常有用的特性。但是,如果你正在编写应该在不同 Python 版本中运行的代码,那么你不能依赖此功能,因为它可能会产生错误行为。

字典的另一个重要特性是它们是可变数据结构,这意味着你可以添加、删除和更新它们的项目。值得注意的是,这也意味着它们不能用作其他字典的键,因为它们不是可散列的对象。

注意:你在本节中学到的所有内容都与核心 Python 实现CPython 相关

其他 Python 实现,如PyPy、IronPythonJython,可能会表现出超出本文范围的不同字典行为和特性。

如何在Python中遍历字典:基础知识

字典是 Python 中一种有用且广泛使用的数据结构。作为 Python 编码人员,你经常会遇到需要实现Python遍历字典,同时对其键值对执行某些操作的情况。

在Python中遍历字典时,该语言为你提供了一些很棒的工具,我们将在本文中介绍这些工具。

Python遍历字典:直接遍历键

Python遍历字典键值:Python 的字典是映射对象。这意味着它们继承了一些特殊的方法,Python 在内部使用这些方法来执行一些操作。这些方法的命名使用在方法名称的开头和结尾添加双下划线的命名约定。

要可视化任何 Python 对象的方法和属性,你可以使用dir(),这是一个用于此目的的内置函数。如果你dir()使用空字典作为参数运行,那么你将能够看到字典实现的所有方法和属性:>>>

>>> dir({})
['__class__', '__contains__', '__delattr__', ... , '__iter__', ...]

如果你仔细查看之前的输出,你会看到'__iter__'. 这是一个在容器需要遍历器时调用的方法,它应该返回一个新的遍历器对象,该对象可以遍历容器中的所有对象。

注意:...为了节省空间,前面代码的输出被缩写为 ( )。

对于映射(如字典),.__iter__()应该遍历键。这意味着如果你将字典直接放入for循环中,Python 将自动调用.__iter__()该字典,并且你将在其键上获得一个遍历器:>>>

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

Python 足够聪明,知道这a_dict是一个字典并且它实现了.__iter__(). 在这个例子中,Python.__iter__()自动调用,这允许你遍历a_dict.

这是Python遍历字典的最简单方法。只需将其直接放入for循环中,就大功告成了!

如果你将这种Python遍历字典方法与一个小技巧一起使用,那么你就可以处理任何字典的键和值。技巧包括使用索引运算符[]和字典及其键来访问值:>>>

>>> for key in a_dict:
...     print(key, '->', a_dict[key])
...
color -> blue
fruit -> apple
pet -> dog

前面的代码允许你同时访问键 ( key) 和值 ( a_dict[key]a_dict。这样,你可以对键和值进行任何操作。

Python遍历字典:.items()

当你使用字典时,你可能希望同时使用键和值。在Python中遍历字典最有用的方法之一是使用.items(),这是一种返回字典项的新视图的方法:>>>

>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> d_items = a_dict.items()
>>> d_items  # Here d_items is a view of items
dict_items([('color', 'blue'), ('fruit', 'apple'), ('pet', 'dog')])

字典视图像d_items提供了字典条目的动态视图,这意味着当字典发生变化时,视图会反映这些变化。

视图可以遍历以产生它们各自的数据,因此你可以使用返回的视图对象在Python中遍历字典.items():>>>

>>> for item in a_dict.items():
...     print(item)
...
('color', 'blue')
('fruit', 'apple')
('pet', 'dog')

返回的视图对象一次.items()生成一个键值对,并允许你在Python中遍历字典,但你可以同时访问键和值。

如果你仔细查看由 产生的单个项目.items(),你会注意到它们实际上是tuple对象。让我们来看看:>>>

>>> for item in a_dict.items():
...     print(item)
...     print(type(item))
...
('color', 'blue')
<class 'tuple'>
('fruit', 'apple')
<class 'tuple'>
('pet', 'dog')
<class 'tuple'>

一旦你知道了这一点,你就可以使用tuple解包来遍历你正在使用的字典的键和值。要实现这一点,你只需要将每个项目的元素解包为两个不同的表示键和值的变量:>>>

>>> for key, value in a_dict.items():
...     print(key, '->', value)
...
color -> blue
fruit -> apple
pet -> dog

在这里,变量key和循环value头中的变量for进行解包。每次循环运行时,key将存储键,value并将存储已处理的项目的值。这样,你将对字典的项目有更多的控制,并且你将能够以更具可读性和 Pythonic 的方式分别处理键和值。

注意:请注意,.values().keys()返回视图对象就像 一样.items(),你将在接下来的两节中看到。

Python遍历字典:.keys()

如何在Python中遍历字典?如果你只需要使用字典的键,那么你可以使用.keys(),这是一种返回包含字典键的新视图对象的方法:>>>

>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> keys = a_dict.keys()
>>> keys
dict_keys(['color', 'fruit', 'pet'])

.keys()这里返回的对象提供了关于 的键的动态视图a_dict。此视图可用于遍历 的键a_dict

Python遍历字典:.keys(),你只需要.keys()for循环的头中调用:>>>

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

当你调用.keys()a_dict,你会看到键的视图。Python 知道视图对象是可遍历的,所以它开始循环,你可以处理a_dict.

Python遍历字典的值:另一方面,使用你之前见过的相同技巧(索引运算符[]),你可以访问字典的值:>>>

>>> for key in a_dict.keys():
...     print(key, '->', a_dict[key])
...
color -> blue
fruit -> apple
pet -> dog

通过这种方式,你可以同时访问 的键 ( key) 和值 ( a_dict[key]a_dict,并且可以对它们执行任何操作。

Python遍历字典:.values()

在 Python 中只使用这些值来遍历字典也是很常见的。一种方法是使用.values(),它返回一个包含字典值的视图:>>>

>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> values = a_dict.values()
>>> values
dict_values(['blue', 'apple', 'dog'])

在前面的代码中,values持有对包含 值的视图对象的引用a_dict

与任何视图对象一样,返回的对象.values()也可以遍历。在这种情况下,.values()产生 的值a_dict:>>>

>>> for value in a_dict.values():
...     print(value)
...
blue
apple
dog

使用.values(),你将只能访问 的值a_dict,而无需处理键。

值得注意的是,它们还支持成员资格测试 ( in),如果你想知道特定元素是否在字典中,这是一个重要功能:>>>

>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> 'pet' in a_dict.keys()
True
>>> 'apple' in a_dict.values()
True
>>> 'onion' in a_dict.values()
False

如果键(或值或项目)存在于你正在测试的字典中,则使用成员资格测试in返回TrueFalse否则返回。如果你只想知道字典中是否存在某些键(或值或项目),成员资格测试允许你不遍历 Python 中的字典。

修改值和键

实现Python遍历字典时,需要修改值和键是很常见的。要完成此任务,你需要考虑一些要点。

例如,你可以随时修改这些值,但你需要使用原始字典和映射要修改的值的键:>>>

>>> prices = {'apple': 0.40, 'orange': 0.35, 'banana': 0.25}
>>> for k, v in prices.items():
...     prices[k] = round(v * 0.9, 2)  # Apply a 10% discount
...
>>> prices
{'apple': 0.36, 'orange': 0.32, 'banana': 0.23}

在前面的代码示例中,要修改 的值prices并应用 10% 的折扣,你使用了表达式prices[k] = round(v * 0.9, 2)

那么,如果你可以访问它的键 ( k) 和它的值 ( v),为什么还必须使用原始字典呢?你是否应该能够直接修改它们?

真正的问题是,原始字典中没有反映kv更改。也就是说,如果你直接在循环内修改它们中的任何一个(kv),那么真正发生的是你将丢失对相关字典组件的引用,而不会更改字典中的任何内容。

另一方面,通过将返回的视图.keys()转换为list对象,可以在字典中添加或删除键:>>>

>>> prices = {'apple': 0.40, 'orange': 0.35, 'banana': 0.25}
>>> for key in list(prices.keys()):  # Use a list instead of a view
...     if key == 'orange':
...         del prices[key]  # Delete a key from prices
...
>>> prices
{'apple': 0.4, 'banana': 0.25}

这种方法可能会产生一些性能影响,主要与内存消耗有关。例如,list你的系统内存中将拥有一个全新的对象,而不是按需生成元素的视图对象。但是,这可能是在Python中遍历字典时修改键的安全方法。

最后,如果你尝试直接prices使用 using删除一个键.keys(),那么 Python 会引发一个RuntimeError告诉你字典的大小在遍历过程中发生了变化的消息:>>>

>>> # Python 3. dict.keys() returns a view object, not a list
>>> prices = {'apple': 0.40, 'orange': 0.35, 'banana': 0.25}
>>> for key in prices.keys():
...     if key == 'orange':
...         del prices[key]
...
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    for key in prices.keys():
RuntimeError: dictionary changed size during iteration

这是因为.keys()返回一个字典视图对象,该对象一次生成一个键,如果你删除一个项目 ( del prices[key]),那么 Python 会引发 a RuntimeError,因为你在遍历期间修改了字典。

注意:在 Python 2 中,, .items().keys(), 和.values()returnlist对象。但是.iteritems()iterkeys(), 和.itervalues()返回遍历器。因此,如果你使用的是 Python 2,那么你可以.keys()直接使用修改字典的键。

另一方面,如果你iterkeys()在 Python 2 代码中使用并尝试修改字典的键,那么你将得到一个RuntimeError.

Python遍历字典:真实世界的例子

到目前为止,你已经看到了在Python中遍历字典的更基本的方法。现在是时候看看如何在遍历期间对字典的项目执行某些操作了。让我们看一些现实世界的例子。

注意:在本文后面,你将看到使用其他 Python 工具解决这些非常相同的问题的另一种方法。

把键变成值,反之亦然

假设你有一本字典,由于某种原因需要将键转换为值,反之亦然。在这种情况下,你可以使用for循环遍历字典并使用键作为值构建新字典,反之亦然:>>>

>>> a_dict = {'one': 1, 'two': 2, 'thee': 3, 'four': 4}
>>> new_dict = {}
>>> for key, value in a_dict.items():
...     new_dict[value] = key
...
>>> new_dict
{1: 'one', 2: 'two', 3: 'thee', 4: 'four'}

new_dict[value] = key通过将键转换为值并使用值作为键,该表达式为你完成了所有工作。要使此代码起作用,存储在原始值中的数据必须是可散列的数据类型。

过滤项目

有时你会遇到这样的情况:你有一本字典,而你想创建一个新字典来仅存储满足给定条件的数据。你可以使用循环内的if语句执行此操作,for如下所示:>>>

>>> a_dict = {'one': 1, 'two': 2, 'thee': 3, 'four': 4}
>>> new_dict = {}  # Create a new empty dictionary
>>> for key, value in a_dict.items():
...     # If value satisfies the condition, then store it in new_dict
...     if value <= 2:
...         new_dict[key] = value
...
>>> new_dict
{'one': 1, 'two': 2}

在此示例中,你已过滤掉值大于 的项目2。现在new_dict只包含满足条件的项目value <= 2。这是此类问题的一种可能解决方案。稍后,你将看到一种更 Pythonic 和可读的方式来获得相同的结果。

做一些计算

在Python中遍历字典时需要进行一些计算也是很常见的。假设你已将公司销售额的数据存储在字典中,现在你想知道一年的总收入。

为了解决这个问题,你可以定义一个初始值为零的变量。然后,你可以在该变量中累积字典的每个值:>>>

>>> incomes = {'apple': 5600.00, 'orange': 3500.00, 'banana': 5000.00}
>>> total_income = 0.00
>>> for value in incomes.values():
...     total_income += value  # Accumulate the values in total_income
...
>>> total_income
14100.0

在这里,你已经incomes按照自己的意愿遍历并按顺序累积了它的值total_income。这个表达式很total_income += value神奇,在循环结束时,你将获得当年的总收入。请注意,total_income += value相当于total_income = total_income + value.

Python遍历字典:使用推导式

一个字典的理解是处理一个集合中元素的全部或部分,并返回一个字典作为结果的紧凑的方式。与列表推导相反,它们需要两个用冒号分隔的表达式,后跟forif(可选)子句。运行字典理解时,生成的键值对会按照它们生成的顺序插入到新字典中。

例如,假设你有两个数据列表,你需要根据它们创建一个新字典。在这种情况下,你可以使用 Pythonzip(*iterables)来成对循环遍历两个列表的元素:>>>

>>> objects = ['blue', 'apple', 'dog']
>>> categories = ['color', 'fruit', 'pet']
>>> a_dict = {key: value for key, value in zip(categories, objects)}
>>> a_dict
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}

在这里,zip()接收两个可遍历对象(categoriesobjects)作为参数,并创建一个遍历器来聚合每个可遍历对象的元素。然后将tuple生成的对象zip()解包到key和 中value,最终用于创建新字典。

字典推导式打开了广泛的新可能性,并为你提供了一个很好的工具来遍历 Python 中的字典。

将键转为值,反之亦然:重新审视

Python遍历字典键值:如果你再看看将键转换为值的问题,反之亦然,你会发现你可以通过使用字典推导来编写更 Pythonic 和高效的解决方案:>>>

>>> a_dict = {'one': 1, 'two': 2, 'thee': 3, 'four': 4}
>>> new_dict = {value: key for key, value in a_dict.items()}
>>> new_dict
{1: 'one', 2: 'two', 3: 'thee', 4: 'four'}

通过这种字典理解,你已经创建了一个全新的字典,其中键代替了值,反之亦然。这种新方法使你能够编写更具可读性、简洁、高效和 Pythonic 的代码。

此代码工作的条件与你之前看到的相同:值必须是可散列的对象。否则,你将无法将它们用作new_dict.

过滤项目:重新审视

要使用推导过滤字典中的项目,你只需要添加一个if子句来定义你想要满足的条件。在前面过滤字典的示例中,该条件为if v <= 2。通过将此if子句添加到字典理解式的末尾,你将过滤掉值大于 的项目2。让我们来看看:>>>

>>> a_dict = {'one': 1, 'two': 2, 'thee': 3, 'four': 4}
>>> new_dict = {k: v for k, v in a_dict.items() if v <= 2}
>>> new_dict
{'one': 1, 'two': 2}

现在new_dict只包含满足你条件的项目。与之前的解决方案相比,这个解决方案更加 Pythonic 和高效。

做一些计算:重新审视

Python遍历字典的值:还记得公司销售的例子吗?如果你使用列表推导式遍历字典的值,那么你将获得更紧凑、更快速和 Pythonic 的代码:>>>

>>> incomes = {'apple': 5600.00, 'orange': 3500.00, 'banana': 5000.00}
>>> total_income = sum([value for value in incomes.values()])
>>> total_income
14100.0

列表推导式创建了一个list包含 的值的对象incomes,然后你通过使用将所有值相加sum()并将结果存储在 中total_income

如果你正在使用一个非常大的字典,并且内存使用对你来说是一个问题,那么你可以使用生成器表达式而不是列表推导式。甲发生器表达式是返回一个遍历的表达式。它看起来像一个列表推导式,但你需要使用括号来定义它而不是括号:>>>

>>> total_income = sum(value for value in incomes.values())
>>> total_income
14100.0

Python遍历字典:如果你更改一对括号(sum()此处的括号)的方括号,你会将列表推导式转换为生成器表达式,并且你的代码将节省内存,因为生成器表达式会按需生成元素。你一次只需存储一个元素,而不是在内存中创建和存储整个列表。

注意:如果你完全不熟悉生成器表达式,你可以查看Python 生成器简介和Python 生成器 101以更好地理解该主题。

最后,有一种更简单的方法来解决这个问题,只需incomes.values()直接将其用作 的参数sum():>>>

>>> total_income = sum(incomes.values())
>>> total_income
14100.0

sum()接收一个可遍历对象作为参数并返回其元素的总和。在这里,incomes.values()扮演传递给 的可遍历对象的角色sum()。结果是你正在寻找的总收入。

删除特定项目

现在,假设你有一本字典,需要创建一个删除选定键的新字典。还记得 key-view 对象如何像set吗?嗯,这些相似之处不仅仅是可散列和唯一对象的集合。Key-view 对象也支持常见的set操作。让我们看看如何利用它来删除字典中的特定项目:>>>

>>> incomes = {'apple': 5600.00, 'orange': 3500.00, 'banana': 5000.00}
>>> non_citric = {k: incomes[k] for k in incomes.keys() - {'orange'}}
>>> non_citric
{'apple': 5600.0, 'banana': 5000.0}

此代码之所以有效,是因为关键视图对象支持set并集、交集和差异等操作。当你incomes.keys() - {'orange'}在字典理解里面写的时候,你真的在​​做一个set差异运算。如果你需要对set字典的键执行任何操作,那么你可以直接使用 key-view 对象,而无需先将其转换为set. 这是关键视图对象的一个​​鲜为人知的功能,在某些情况下可能很有用。

字典排序

通常需要对集合的元素进行排序。从 Python 3.6 开始,字典是有序的数据结构,因此如果你使用 Python 3.6(及更高版本),你将能够通过使用sorted()并借助字典理解对任何字典的项目进行排序:>>>

>>> # Python 3.6, and beyond
>>> incomes = {'apple': 5600.00, 'orange': 3500.00, 'banana': 5000.00}
>>> sorted_income = {k: incomes[k] for k in sorted(incomes)}
>>> sorted_income
{'apple': 5600.0, 'banana': 5000.0, 'orange': 3500.0}

此代码允许你使用按排序顺序的键创建新字典。这是可能的,因为sorted(incomes)返回可用于生成新字典的排序键列表sorted_dict

Python遍历字典:按排序顺序遍历

有时你可能需要在Python中遍历字典,但希望按排序顺序进行。这可以通过使用来实现sorted()。当你调用 时sorted(iterable),你会得到一个按排序顺序排列list的元素iterable

让我们看看sorted()当你需要按排序顺序执行字典时,如何使用Python 中的字典进行遍历。

按键排序

Python遍历字典键值:如果你需要在Python中遍历字典并希望它按键排序,那么你可以将字典用作sorted(). 这将返回一个list包含按排序顺序的键,你将能够遍历它们:>>>

>>> incomes = {'apple': 5600.00, 'orange': 3500.00, 'banana': 5000.00}
>>> for key in sorted(incomes):
...     print(key, '->', incomes[key])
...
apple -> 5600.0
banana -> 5000.0
orange -> 3500.0

在此示例中,你按循环sorted(incomes)标头中使用的键对字典进行了排序(按字母顺序)for。请注意,你也可以使用sorted(incomes.keys())来获得相同的结果。在这两种情况下,你都会得到list按排序顺序包含字典键的 。

注意:排序顺序将取决于你用于键或值的数据类型以及 Python 用于对这些数据类型进行排序的内部规则。

Python遍历字典:按值排序

你可能还需要遍历 Python 中的字典,其中的项目按值排序。你也可以使用sorted(),但使用名为key.

key关键字参数指定用于提取从每个元素你正在处理的比较关键一个参数的函数。

要按值对字典的项目进行排序,你可以编写一个函数来返回每个项目的值并将此函数用作 的key参数sorted():>>>

>>> incomes = {'apple': 5600.00, 'orange': 3500.00, 'banana': 5000.00}
>>> def by_value(item):
...     return item[1]
...
>>> for k, v in sorted(incomes.items(), key=by_value):
...     print(k, '->', v)
...
('orange', '->', 3500.0)
('banana', '->', 5000.0)
('apple', '->', 5600.0)

如何在Python中遍历字典?在此示例中,你定义by_value()并使用它来incomes按值对项目进行排序。然后,你使用 以排序顺序遍历字典sorted()。键函数 ( by_value()) 告诉按每个项目的第二个元素sorted()排序incomes.items(),即按值 ( item[1])排序。

Python遍历字典的值:你可能还只想按排序顺序遍历字典的值,而不必担心键。在这种情况下,你可以.values()按如下方式使用:>>>

>>> for value in sorted(incomes.values()):
...     print(value)
...
3500.0
5000.0
5600.0

sorted(incomes.values())根据需要按排序顺序返回字典的值。如果使用incomes.values(),将无法访问密钥,但有时你并不真正需要密钥,只需要值,这是访问它们的快速方法。

反转

如果你需要以相反的顺序对字典进行排序,你可以将其reverse=True作为参数添加到sorted(). 关键字参数reverse应采用布尔值。如果设置为True,则元素按相反顺序排序:>>>

>>> incomes = {'apple': 5600.00, 'orange': 3500.00, 'banana': 5000.00}
>>> for key in sorted(incomes, reverse=True):
...     print(key, '->', incomes[key])
...
orange -> 3500.0
banana -> 5000.0
apple -> 5600.0

在这里,你incomes通过sorted(incomes, reverse=True)for循环的标头中使用以相反的顺序遍历了键。

最后,重要的是要注意它sorted()并没有真正修改底层字典的顺序。真正发生的是sorted()创建一个独立的列表,其元素按排序顺序,所以incomes保持不变:>>>

>>> incomes
{'apple': 5600.0, 'orange': 3500.0, 'banana': 5000.0}

这段代码显示你incomes没有改变。sorted()没有修改incomes。它只是从 的键创建了一个新的排序列表incomes

使用.popitem() 进行破坏性遍历

有时你需要在Python中遍历字典并按顺序删除其项目。要完成此任务,你可以使用.popitem(),它将从字典中删除并返回任意键值对。另一方面,当你调用.popitem()一个空字典时,它会引发一个KeyError.

如果你真的需要破坏性地遍历 Python 中的字典,那么.popitem()它会很有用。下面是一个例子:

 1# File: dict_popitem.py
 2
 3a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
 4
 5while True:
 6    try:
 7        print(f'Dictionary length: {len(a_dict)}')
 8        item = a_dict.popitem()
 9        # Do something with item here...
10        print(f'{item} removed')
11    except KeyError:
12        print('The dictionary has no item now...')
13        break

在这里,你使用了while循环而不是for循环。这样做的原因是,如果你假装以这种方式修改字典,也就是说,如果你要删除或向其中添加项目,那么在Python中遍历字典永远不会安全。

while循环内部,你定义了一个try...except块以在变为空时捕获KeyError引发的。在块中,你处理字典,在每次遍历中删除一个项目。该变量保留对连续项目的引用,并允许你对它们执行一些操作。.popitems()a_dicttry...exceptitem

注意:在前面的代码示例中,你使用 Python 的 f-strings 进行字符串格式化。如果你想更深入地研究 f-strings,那么你可以查看Python 3 的 f-Strings:改进的字符串格式语法(指南)。

如果你从命令行运行此脚本,则会得到以下结果:

$ python3 dict_popitem.py
Dictionary length: 3
('pet', 'dog') removed
Dictionary length: 2
('fruit', 'apple') removed
Dictionary length: 1
('color', 'blue') removed
Dictionary length: 0
The dictionary has no item now...

这里.popitem()依次删除了 的项目a_dict。当字典变空时循环中断,并.popitem()引发KeyError异常。

Python遍历字典:使用一些 Python 的内置函数

Python 提供了一些内置函数,这些函数在你处理集合(如字典)时可能会很有用。这些函数是一种遍历工具,为你提供了另一种在Python中遍历字典的方法。让我们看看其中的一些。

map()

Python'smap()被定义为map(function, iterable, ...)并返回一个遍历器,该遍历器适用function于 的每一项iterable,根据需要产生结果。因此,map()可以将其视为一种遍历工具,可用于在Python中遍历字典。

假设你有一个包含一堆产品价格的字典,并且你需要对它们应用折扣。在这种情况下,你可以定义一个管理折扣的函数,然后将其用作 的第一个参数map()。第二个参数可以是prices.items():>>>

>>> prices = {'apple': 0.40, 'orange': 0.35, 'banana': 0.25}
>>> def discount(current_price):
...     return (current_price[0], round(current_price[1] * 0.95, 2))
...
>>> new_prices = dict(map(discount, prices.items()))
>>> new_prices
{'apple': 0.38, 'orange': 0.33, 'banana': 0.24}

在这里,map()遍历字典 ( prices.items())的项目以使用 对每个水果应用 5% 的折扣discount()。在这种情况下,你需要使用从 返回的遍历器dict()生成new_prices字典map()

请注意,discount()返回tuple形式为 的a (key, value),其中current_price[0]表示键并round(current_price[1] * 0.95, 2)表示新值。

filter()

filter()是另一个内置函数,你可以使用它来遍历 Python 中的字典并过滤掉其中的一些项目。该函数被定义为filter(function, iterable)并返回的那些元件的遍历器iterable为其function返回True

假设你想知道价格低于 的产品0.40。你需要定义一个函数来确定价格是否满足该条件并将其作为第一个参数传递给filter()。第二个参数可以是prices.keys():>>>

>>> prices = {'apple': 0.40, 'orange': 0.35, 'banana': 0.25}
>>> def has_low_price(price):
...     return prices[price] < 0.4
...
>>> low_price = list(filter(has_low_price, prices.keys()))
>>> low_price
['orange', 'banana']

在这里,你遍历了priceswith的键filter()。然后filter()适用has_low_price()于 的每个键prices。最后,你需要使用list()来生成低价产品列表,因为filter()返回一个遍历器,而你确实需要一个list对象。

Python遍历字典:使用 collections.ChainMap

collections是 Python 标准库中一个有用的模块,它提供了专门的容器数据类型。其中一种数据类型是ChainMap,它是一个类似于字典的类,用于创建多个映射(如字典)的单个视图。使用ChainMap,你可以将多个字典组合在一起以创建一个可更新的视图。

如何在Python中遍历字典?现在,假设你有两个(或更多)字典,你需要将它们作为一个一起遍历。为此,你可以创建一个ChainMap对象并使用你的字典对其进行初始化:>>>

>>> from collections import ChainMap
>>> fruit_prices = {'apple': 0.40, 'orange': 0.35}
>>> vegetable_prices = {'pepper': 0.20, 'onion': 0.55}
>>> chained_dict = ChainMap(fruit_prices, vegetable_prices)
>>> chained_dict  # A ChainMap object
ChainMap({'apple': 0.4, 'orange': 0.35}, {'pepper': 0.2, 'onion': 0.55})
>>> for key in chained_dict:
...     print(key, '->', chained_dict[key])
...
pepper -> 0.2
orange -> 0.35
onion -> 0.55
apple -> 0.4

导入ChainMapfrom 后collections,你需要ChainMap使用要链接的字典创建一个对象,然后你可以像使用常规字典一样自由地遍历生成的对象。

ChainMap对象也实现.keys()values(), 和.items()作为标准字典所做的,所以你可以使用这些方法来遍历由 生成的类似字典的对象ChainMap,就像你使用普通字典一样:>>>

>>> for key, value in chained_dict.items():
...     print(key, '->', value)
...
apple -> 0.4
pepper -> 0.2
orange -> 0.35
onion -> 0.55

在这种情况下,你调用.items()了一个ChainMap对象。该ChainMap对象的行为就像是一个普通的字典,并.items()返回一个可以像往常一样遍历的字典视图对象。

Python遍历字典:使用 itertools

Pythonitertools是一个模块,它提供了一些有用的工具来执行遍历任务。让我们看看如何使用它们中的一些来遍历 Python 中的字典。

循环遍历 cycle()

如何在Python中遍历字典?假设你想在Python中遍历字典,但需要在单个循环中重复遍历它。要完成此任务,你可以使用itertools.cycle(iterable),它使遍历器返回元素iterable并保存每个元素的副本。当iterable耗尽时,cycle()从保存的副本中返回元素。这是以循环方式执行的,因此由你来停止循环。

在以下示例中,你将连续 3 次遍历字典的项目:>>>

>>> from itertools import cycle
>>> prices = {'apple': 0.40, 'orange': 0.35, 'banana': 0.25}
>>> times = 3  # Define how many times you need to iterate through prices
>>> total_items = times * len(prices)
>>> for item in cycle(prices.items()):
...     if not total_items:
...         break
...     total_items -= 1
...     print(item)
...
('apple', 0.4)
('orange', 0.35)
('banana', 0.25)
('apple', 0.4)
('orange', 0.35)
('banana', 0.25)
('apple', 0.4)
('orange', 0.35)
('banana', 0.25)

前面的代码允许你遍历prices给定的次数(3在本例中)。这个周期可以根据你的需要进行,但你有责任停止它。iftotal_items倒数到零时,该条件打破循环。

链式遍历 chain()

itertools也提供chain(*iterables),它获取一些iterables作为参数并创建一个遍历器,该遍历器从第一个可遍历对象中产生元素,直到耗尽,然后遍历下一个可遍历对象,依此类推,直到所有元素都耗尽。

这允许你遍历链中的多个字典,就像你所做的一样collections.ChainMap:>>>

>>> from itertools import chain
>>> fruit_prices = {'apple': 0.40, 'orange': 0.35, 'banana': 0.25}
>>> vegetable_prices = {'pepper': 0.20, 'onion': 0.55, 'tomato': 0.42}
>>> for item in chain(fruit_prices.items(), vegetable_prices.items()):
...     print(item)
...
('apple', 0.4)
('orange', 0.35)
('banana', 0.25)
('pepper', 0.2)
('onion', 0.55)
('tomato', 0.42)

在上面的代码中,chain()返回一个可遍历对象,它组合了来自fruit_prices和的项目vegetable_prices

也可以使用.keys().values(),根据你的需要,条件是同质的:如果你使用.keys()的参数chain(),那么你需要使用.keys()其余的。

Python遍历字典:使用字典解包运算符 ( **)

Python 3.5 带来了一个有趣的新特性。PEP 448 -在 Python 中遍历多个字典时,额外的解包概括可以让你的生活更轻松。让我们用一个简短的例子来看看这是如何工作的。

如何在Python中遍历字典?假设你有两个(或更多)字典,并且你需要一起遍历它们,而不使用collections.ChainMapitertools.chain(),正如你在前几节中看到的那样。在这种情况下,你可以使用字典解包运算符 ( **) 将两个字典合并为一个新字典,然后对其进行遍历:>>>

>>> fruit_prices = {'apple': 0.40, 'orange': 0.35}
>>> vegetable_prices = {'pepper': 0.20, 'onion': 0.55}
>>> # How to use the unpacking operator **
>>> {**vegetable_prices, **fruit_prices}
{'pepper': 0.2, 'onion': 0.55, 'apple': 0.4, 'orange': 0.35}
>>> # You can use this feature to iterate through multiple dictionaries
>>> for k, v in {**vegetable_prices, **fruit_prices}.items():
...     print(k, '->', v)
...
pepper -> 0.2
onion -> 0.55
apple -> 0.4
orange -> 0.35

字典解包运算符 ( **) 在 Python 中确实是一个很棒的功能。它允许你将多个字典合并为一个新字典,就像你在示例中使用vegetable_prices和所做的那样fruit_prices。将字典与解包运算符合并后,你可以像往常一样遍历新字典。

Python遍历字典的值:重要的是要注意,如果你尝试合并的字典具有重复或公共键,则最右侧字典的值将占上风:>>>

>>> vegetable_prices = {'pepper': 0.20, 'onion': 0.55}
>>> fruit_prices = {'apple': 0.40, 'orange': 0.35, 'pepper': .25}
>>> {**vegetable_prices, **fruit_prices}
{'pepper': 0.25, 'onion': 0.55, 'apple': 0.4, 'orange': 0.35}

pepper关键是存在于两个字典。合并它们后,( )的fruit_prices值占优势,因为是最右边的字典。pepper0.25fruit_prices

Python遍历字典结论

你现在了解了如何实现Python遍历字典的基础知识,以及一些更高级的技术和策略!

你已经学到:

  • 什么是字典,以及它们的一些主要特性和实现细节
  • 如何在Python中遍历字典?在Python中遍历字典的基本方法是什么
  • 在Python中遍历字典可以完成什么样的任务
  • 如何使用一些更详细的技术和策略在Python中遍历字典

你拥有充分利用 Python 字典所需的工具和知识。这将帮助你在将来使用字典遍历时更加高效和有效。

木子山

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: