Python 遍历字典的若干方法

这篇具有很好参考价值的文章主要介绍了Python 遍历字典的若干方法。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

哈喽大家好,我是咸鱼

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

我们可以使用字典来解决许多编程问题,那么今天我们就来看看如何在 Python 中遍历字典

全文内容:https://realpython.com/iterate-through-dictionary-python/

ps:文中提到的 Python 指的是 CPython 实现;

译文如下:

字典是 Python 的基石。这门语言的很多方面都是围绕着字典构建的

模块、类、对象、globals()locals() 都是字典与 Python 实现紧密联系的例子

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

An associative array, where arbitrary keys are mapped to values. The keys can be any object with __hash__() and __eq__() methods

需要注意的是:

  • 字典将键映射到值,并将它们存储在数组或集合中。键值对通常称为 items
  • 字典键必须是可哈希类型,这意味着它们必须具有在键的生命周期内永远不会更改的哈希值

与序列不同,序列是支持使用整数索引进行元素访问的可迭代对象,字典按键编制索引。这意味着我们可以使用关联的键而不是整数索引来访问存储在字典中的值

字典中的键很像 set ,它是可哈希和唯一对象的集合。由于键需要可哈希处理,因此不能将可变对象用作字典键(即键不能是可变数据类型)

另一方面,字典值可以是任何 Python 类型,无论它们是否可哈希。从字面上看,对值没有任何限制。我们可以使用任何数据类型作为 Python 字典中的值

在Python 3.6之前,字典是无序的数据结构。这意味着 item 的顺序通常与插入顺序不匹配

>>> # Python 3.5
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}

>>> likes
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}

可以看到,生成的词典中 item 的顺序与最初插入 item 的顺序不匹配

在 Python 3.6 及更高版本中,字典的键和值保持与将它们插入底层字典的顺序相同。即从3.6 开始,字典变成了紧凑有序的数据结构

>>> # Python 3.6
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}

>>> likes
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}

保持 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:
...     print(key, "->", likes[key])
...
color -> blue
fruit -> apple
pet -> dog

在本例中,同时使用 key likes[key] 来分别访问目标字典的键和值

尽管在 Python 中直接遍历字典非常简单,但字典提供了更方便、更明确的工具来获得相同的结果

.items() 该方法就是这种情况,它定义了一种快速迭代字典的 item 或键值对的方法

  • .items()方法遍历字典 item

使用字典时,同时循环访问键和值可能是一个常见要求。 .items() 方法返回一个视图对象,其中包含字典的项作为键值元组:

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}

>>> likes.items()
dict_items([('color', 'blue'), ('fruit', 'apple'), ('pet', 'dog')])

字典视图对象提供字典项的动态视图。在这里,动态意味着当字典更改时,视图会反映这些更改

视图是可迭代的,因此我们可以使用调用 .items() 生成的视图对象循环访问字典中的项,如以下示例所示:

>>> for item in 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')
<class 'tuple'>
('fruit', 'apple')
<class 'tuple'>
('pet', 'dog')

可以看到所有的 item 都是元组。一旦知道了这一点,就可以使用元组解包来并行地遍历键和值

要通过键和值实现并行迭代,只需将每个 item 的元素解压缩为两个不同的变量:一个用于键,另一个用于值

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

for 循环头中的 key 和 value 变量执行解包操作。每次循环运行时,key获得对当前键的引用,value获得对值的引用

这样,我们就可以更好地控制字典内容。因此,我们将能够以可读和 python 的方式分别处理键和值

  • .keys() 方法遍历字典的键

Python 字典提供了第二种遍历其键的方法。除了在循环中直接使用目标字典外,还可以使用.keys()方法

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

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}

>>> likes.keys()
dict_keys(['color', 'fruit', 'pet'])

该方法 .keys() 返回一个对象,该对象提供 likes 键的动态视图。可以使用此视图对象循环访问字典键

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

当您在 likes上调用 .keys() 时,将获得键的视图。Python 知道视图对象是可迭代的,所以它开始循环

为什么要使用 .keys() 而不是直接遍历字典。简单来说,显式地使用 .keys()可以让你更好地表达只遍历键的意图

  • .values() 方法遍历字典值

在遍历字典时面临的另一个常见需求是只遍历值。方法是使用 .values() 方法,它会返回一个包含底层字典中的值的视图

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}

>>> likes.values()
dict_values(['blue', 'apple', 'dog'])

上面的代码返回一个视图对象, .values() 返回一个视图对象。

与其他视图对象一样,的结果 .values() 也是可迭代的,因此可以在循环中使用它

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

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

  • 在迭代期间更改值

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

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

>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}

>>> for fruit, price in fruits.items():
...     fruits[fruit] = round(price * 0.9, 2)
...

>>> fruits
{'apple': 0.36, 'orange': 0.32, 'banana': 0.23}

在上面的例子中需要注意的是:为了更新值,我们使用了原始的字典,而不是像price = round(price * 0.9, 2)这样直接更新当前的价格

如果像price = round(price * 0.9, 2)这样,重新分配水果或价格并没有反映在原来的字典中

就会导致丢失对字典的引用,这样并没有实现更改字典中的任何内容

  • 在迭代期间安全地删除 item

由于 Python 字典是可变的,我们可以根据需要从中删除现有的 item

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

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

>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}

>>> for fruit in fruits.copy():
...     if fruits[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]
...
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    for fruit in fruits:
RuntimeError: dictionary changed size during iteration

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

由于原始字典的大小发生了变化,因此如何继续迭代是不明确的。因此,要避免这个问题,请始终在迭代中使用字典的副本

遍历期间对字典的操作

  • 根据值来过滤 item

有时候我们希望在原字典的前提下创建一个只包含满足特定条件的新字典

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

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}

>>> small_numbers = {}

>>> for key, value in numbers.items():
...     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.keys() - {"orange"}
{'apple', 'banana'}

还可以更简洁

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}

>>> {key: value for key, value in numbers.items() if value <= 2}
{'one': 1, 'two': 2}

或者通过计算字典的键与一组不需要的键之间的差分而获得的键集构建一个新词典

>>> non_citrus = {}

>>> for key in fruits.keys() - {"orange"}:
...     non_citrus[key] = fruits[key]
...

>>> non_citrus
{'apple': 0.4, 'banana': 0.25}
  • 算术运算

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

>>> incomes = {"apple": 5600.00, "orange": 3500.00, "banana": 5000.00}
>>> total_income = 0.00

>>> for income in incomes.values():
...     total_income += 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
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

更简洁的写法

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}

>>> {value: key for key, value in numbers.items()}
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

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

我们还可以将内置 zip() 函数与 dict() 构造函数一起使用

>>> dict(zip(numbers.values(), numbers.keys()))
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

上面的示例中,通过 zip() 生成值键对的元组,然后,使用生成的元组作为参数并 dict() 构建所需的字典

字典推导式

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

>>> categories = ["color", "fruit", "pet"]
>>> objects = ["blue", "apple", "dog"]

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

上面的对象中, zip() 接收两个可迭代对象( categoriesobjects )生成了一个 tuple 对象,然后被解压缩到 keyvalue 中,最终用于创建新的所需字典

更简洁的方法如下:

>>> categories = ["color", "fruit", "pet"]
>>> objects = ["blue", "apple", "dog"]

>>> dict(zip(categories, objects))
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}

zip() 函数从原始列表生成键值对,而 dict() 构造函数负责创建新字典文章来源地址https://www.toymoban.com/news/detail-693822.html

到了这里,关于Python 遍历字典的若干方法的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Python基础操作_字典的遍历

    结果: 结果: 结果: 结果: 结果: 结果: 结果: 结果: 结果: 结果: 结果: 结果: 结果: 结果: 结果: aliens = [] 结果: 结果: 结果: 结果: 结果: 总结: 1、字典的遍历方法:items()方法:键-值对遍历,返回的值是一个可以迭代序列,list()函数可以将其转为列表

    2024年02月07日
    浏览(40)
  • 【python基础】复杂数据类型-字典(遍历)

    一个字典可能只包含几个键值对,也可能包含数百万个键值对,所以Python支持字典遍历。字典可用于以各种方式存储信息,因此有多种遍历字典的方式:可遍历字典的所有键值对、键或值。 其语法格式: 比如遍历一个人的信息,编写程序如下所示: 这里,我们给键起了一个

    2024年02月08日
    浏览(49)
  • Python中dict字典的多种遍历方式

    可以使用 for key in dict 遍历字典中所有的键 字典提供了 keys () 方法返回字典中所有的键 字典提供了 values () 方法返回字典中所有的值 字典提供了 items () 方法返回字典中所有的键值对 item 键值对 item 是一个元组(第 0 项是键、第 1 项是值) 例子

    2024年02月08日
    浏览(38)
  • Python 遍历结构复杂的多层嵌套字典,收集特定键值对

    可以使用递归函数来遍历整个嵌套层次不同的字典,收集所有感兴趣的键值对,最终得到一个非嵌套结构的字典: (一般用于处理爬取的json数据,因为有些结构真的蛮怪的(メ3[____]

    2024年02月19日
    浏览(38)
  • 爬虫012_字典高级操作_查询_修改_添加_删除和清空_遍历---python工作笔记031

    然后来看字典高级,首先 打印某个元素     然后打印的时候注意,如果直接打印的值,在字典中没有就报错     这里要注意不能用点访问  

    2024年02月13日
    浏览(37)
  • python字典取值的几种方法

            Python 字典(dictionary)是一种可变容器模型,可以存储任意数量的任意类型的数据。字典中的每个元素由一个键和一个值组成,键和值之间用冒号分隔。字典通常用于存储键值对的数据,例如在数据库中存储记录。 以下是 Python 字典取值的几种方法及其代码演示: 方法

    2023年04月26日
    浏览(42)
  • Python|合并两个字典的8种方法

    在Python中,有多种方法可以通过使用各种函数和构造函数来合并字典。在本文中,我们将讨论一些合并字典的方法。 1. 使用方法update() 通过使用Python中的update()方法,可以将一个列表合并到另一个列表中。但是在这种情况下,第二个列表被合并到第一个列表中,并且没有创建

    2024年02月09日
    浏览(43)
  • python字典中删除键值的方法

    Python字典是一种无序的映射数据类型,通过键值对的形式进行存储,可以使用键来快速找到对应的值。在某些情况下,我们可能需要在字典中删除某个键,这时候就可以使用Python字典提供的pop()方法。 pop()方法用于删除字典中指定的键,并返回该键对应的值。使用该方法时需

    2024年02月05日
    浏览(49)
  • 在Python中将字典转为成员变量的方法

    当我们在Python中写一个class时,如果有一部分的成员变量需要用一个字典来命名和赋值,此时应该如何操作呢?这个场景最常见于从一个文件(比如json、npz之类的文件)中读取字典变量到内存当中,再赋值给一个类的成员变量,或者已经生成的实例变量。 在python中直接支持了

    2024年04月28日
    浏览(31)
  • 5种Python字典“键”和“值”的排序方法

    使用 sorted() 函数对字典进行排序,将其转换为元组列表,再按照指定的键或者值进行排序。 按照键排序的示例代码 结果如下: 按照值排序的示例代码 结果如下: 可以使用 operator 模块的 itemgetter() 函数对字典进行排序,将其转换为元组列表,然后按照指定的键或者值进行排

    2024年02月08日
    浏览(26)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包