使用 for 循环遍历字典

问题描述：

d = {'x': 1, 'y': 2, 'z': 3}

for key in d:
    print(key, 'corresponds to', d[key])

Python 如何识别它只需要从key字典中读取？是key一个特殊的关键字，还是只是一个变量？

解决方案 1：

key只是一个变量名。

for key in d:

将只循环字典中的键，而不是键和值。要循环键和值，可以使用以下命令：

对于 Python 3.x：

for key, value in d.items():

对于 Python 2.x：

for key, value in d.iteritems():

为了亲自测试，请将单词key改为poop。

在 Python 3.x 中，iteritems()被替换为简单的items()，它返回由字典支持的集合类视图，类似iteritems()但更好。这在 2.7 中也可用，如viewitems()。

此操作items()适用于 2 和 3，但在 2 中它将返回字典对的列表(key, value)，这不会反映调用后对字典的更改items()。如果您想在 3.x 中使用 2.x 行为，您可以调用list(d.items())。

解决方案 2：

这并不是说 key 是一个特殊词，而是说字典实现了迭代器协议。你可以在你的类中这样做，例如，请参阅此问题以了解如何构建类迭代器。

对于字典，它是在 C 级别实现的。详细信息请参阅PEP 234。特别是标题为“字典迭代器”的部分：

• 字典实现了一个 tp_iter 槽，它返回一个高效的迭代器，可以迭代字典的键。[...] 这意味着我们可以写

for k in dict: ...

这相当于，但速度要快得多

for k in dict.keys(): ...

只要不违反对字典修改的限制（无论是通过循环还是另一个线程）。

• 向字典添加明确返回不同类型迭代器的方法：

for key in dict.iterkeys(): ...

for value in dict.itervalues(): ...

for key, value in dict.iteritems(): ...

这意味着for x in dict是 的简写`for x in
dict.iterkeys()`。

在 Python 3 中，dict.iterkeys()和dict.itervalues()不再dict.iteritems()受支持。请改用dict.keys()、dict.values()和dict.items()。

解决方案 3：

迭代会dict不按特定顺序遍历其键，如您在此处所见：

（自 Python 3.6 以来，这种情况实际上不再存在，但请注意，自 Python 3.7 以来，这仅是保证的行为。）

>>> d = {'x': 1, 'y': 2, 'z': 3}
>>> list(d)
['y', 'x', 'z']
>>> d.keys()
['y', 'x', 'z']

对于您的示例，更好的想法是使用dict.items()：

>>> d.items()
[('y', 2), ('x', 1), ('z', 3)]

这将为您提供一个元组列表。当您像这样循环遍历它们时，每个元组都会自动解包k并v：

for k,v in d.items():
    print(k, 'corresponds to', v)

如果循环主体只有几行，则在循环时使用k和作为变量名是很常见的。对于更复杂的循环，使用更具描述性的名称可能是一个好主意：v`dict`

for letter, number in d.items():
    print(letter, 'corresponds to', number)

养成使用格式字符串的习惯是一个好主意：

for letter, number in d.items():
    print('{0} corresponds to {1}'.format(letter, number))

解决方案 4：

key只是一个变量。

对于Python 3.x：

>>> d = {'x': 1, 'y': 2, 'z': 3}
>>> for the_key, the_value in d.items():
...     print(the_key, 'corresponds to', the_value)
...
x corresponds to 1
y corresponds to 2
z corresponds to 3

对于Python 2.x：

>>> d = {'x': 1, 'y': 2, 'z': 3} 
>>> for my_var in d:
>>>     print my_var, 'corresponds to', d[my_var]

x corresponds to 1
y corresponds to 2
z corresponds to 3

...或者更好，

d = {'x': 1, 'y': 2, 'z': 3} 

for the_key, the_value in d.iteritems():
    print the_key, 'corresponds to', the_value

解决方案 5：

当您使用 -语法遍历字典时for .. in ..，它总是遍历键（可以使用 访问值dictionary[key]）。

要迭代键值对，请使用以下命令：

• for k,v in dict.iteritems()在 Python 2 中

• for k,v in dict.items()在 Python 3 中

解决方案 6：

这是一个非常常见的循环习惯用法。in是一个运算符。有关何时使用for key in dict以及何时必须使用，for key in dict.keys()请参阅David Goodger 的《惯用 Python 语言》文章（存档副本）。

解决方案 7：

我有一个用例，其中我必须遍历字典以获取键、值对以及指示我所在位置的索引。 这是我的方法：

d = {'x': 1, 'y': 2, 'z': 3} 
for i, (key, value) in enumerate(d.items()):
   print(i, key, value)

请注意，键和值周围的括号很重要，如果没有它们，您将得到ValueError“没有足够的值来解包”的结果。

解决方案 8：

要遍历字典，可以使用下面的代码。

dictionary= {1: "a", 2: "b", 3: "c"}

#To iterate over the keys
for key in dictionary.keys():
    print(key)

#To Iterate over the values
for value in dictionary.values():
    print(value)

#To Iterate both the keys and values
for key, value in dictionary.items():
    print(key, '    ', value)

解决方案 9：

使用 for 循环遍历字典

d = {'x': 1, 'y': 2, 'z': 3} 
for key in d:
    ...

Python 如何识别它只需要从字典中读取键？键在 Python 中是一个特殊词吗？还是它只是一个变量？

这不仅仅是for循环。这里的关键词是“迭代”。

字典是键到值的映射：

d = {'x': 1, 'y': 2, 'z': 3} 

每次迭代时，我们都会迭代键。变量名key仅用于描述 - 并且非常适合此目的。

这发生在列表推导中：

>>> [k for k in d]
['x', 'y', 'z']

当我们将字典传递给列表（或任何其他集合类型对象）时，就会发生这种情况：

>>> list(d)
['x', 'y', 'z']

Python 进行迭代的方式是，在需要的上下文中，它调用__iter__对象（在本例中为字典）的方法，该方法返回一个迭代器（在本例中为 keyiterator 对象）：

>>> d.__iter__()
<dict_keyiterator object at 0x7fb1747bee08>

我们不应该自己使用这些特殊方法，而是使用相应的内置函数来调用它iter：

>>> key_iterator = iter(d)
>>> key_iterator
<dict_keyiterator object at 0x7fb172fa9188>

迭代器有一个__next__方法 - 但我们用内置函数调用它next：

>>> next(key_iterator)
'x'
>>> next(key_iterator)
'y'
>>> next(key_iterator)
'z'
>>> next(key_iterator)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

当迭代器耗尽时，它会引发StopIteration。这就是 Python 知道退出循环for、列表推导、生成器表达式或任何其他迭代上下文的方式。一旦迭代器引发，StopIteration它就会一直引发它 - 如果您想再次迭代，则需要一个新的迭代器。

>>> list(key_iterator)
[]
>>> new_key_iterator = iter(d)
>>> list(new_key_iterator)
['x', 'y', 'z']

回到字典

我们已经在许多情况下看到了字典的迭代。我们看到的是，每次迭代字典时，我们都会得到键。回到原始示例：

d = {'x': 1, 'y': 2, 'z': 3} 
for key in d:

如果我们改变变量名，我们仍然可以得到键。我们来试试：

>>> for each_key in d:
...     print(each_key, '=>', d[each_key])
... 
x => 1
y => 2
z => 3

如果我们想要迭代这些值，我们需要使用.values字典的方法，或者两者一起使用.items：

>>> list(d.values())
[1, 2, 3]
>>> list(d.items())
[('x', 1), ('y', 2), ('z', 3)]

在给出的例子中，像这样迭代项目会更有效率：

for a_key, corresponding_value in d.items():
    print(a_key, corresponding_value)

但就学术目的而言，问题的例子就很好了。

解决方案 10：

你可以在 GitHub 上查看 CPython 的实现dicttype。这是实现 dict 迭代器的方法的签名：

_PyDict_Next(PyObject *op, Py_ssize_t *ppos, PyObject **pkey,
             PyObject **pvalue, Py_hash_t *phash)

CPython dictobject.c

解决方案 11：

要迭代键，使用 会比较慢，但效果会更好my_dict.keys()。如果您尝试执行如下操作：

for key in my_dict:
    my_dict[key+"-1"] = my_dict[key]-1

它会造成运行时错误，因为您在程序运行时更改了键。如果您绝对想减少时间，请使用此for key in my_dict方法，但您已收到警告。

解决方案 12：

如果您正在寻找一个清晰且直观的示例：

cat  = {'name': 'Snowy', 'color': 'White' ,'age': 14}
for key , value in cat.items():
   print(key, ': ', value)

结果：

name:  Snowy
color:  White
age:  14

解决方案 13：

这将按值升序排序后打印输出。

d = {'x': 3, 'y': 1, 'z': 2}

def by_value(item):
    return item[1]

for key, value in sorted(d.items(), key=by_value):
    print(key, '->', value)

输出：

y -> 1
z -> 2
x -> 3

解决方案 14：

如果要循环遍历字典并在迭代中对其进行修改（可能添加/删除键），在 Python 2 中，可以通过循环来实现my_dict.keys()。在 Python 3 中，迭代必须对键的显式副本进行（否则会抛出RuntimeError），因为my_dict.keys()返回字典键的视图，因此对的任何更改也会my_dict更改视图。

my_dict = {'a': 1, 'b': 2, 'c': 3}
for k in my_dict:
    my_dict.pop(k)        # <---- error


# remove keys from my_dict
for k in list(my_dict):
    my_dict.pop(k)        # <---- OK

解决方案 15：

Python 中的字典是键值对的集合。每个键都与一个值相连，您可以使用键来访问与该键关联的值。键的值可以是数字、字符串、列表，甚至是另一个字典。在这种情况下，将每个“键值对”视为表中的单独一行：d 是包含两列的表。键是第一列，key[value] 是第二列。for 循环是迭代表的标准方法。

解决方案 16：

让我们直入主题。如果 key 这个词只是一个变量，正如您提到的那样，那么要注意的主要一点是，当您在字典上运行“FOR LOOP”时，它只会运行“键”而忽略“值”。

d = {'x': 1, 'y': 2, 'z': 3} 
for key in d:
    print (key, 'corresponds to', d[key])

尝试一下这个：

d = {'x': 1, 'y': 2, 'z': 3} 
for i in d:
    print (i, 'corresponds to', d[i])

但如果你使用如下函数：

d = {'x': 1, 'y': 2, 'z': 3}
print(d.keys())

在上面的例子中，“keys”不仅仅是一个变量，它是一个函数。

解决方案 17：

当你循环遍历一个字典时，实际上会发生以下情况：

>>> d = {'x': 1, 'y': 2, 'z': 3}
>>> iter(d)
Out[408]: <dict_keyiterator at 0x2b240fc6d40>
>>> list(iter(d))
Out[409]: ['x', 'y', 'z']
>>> for key in iter(d):
        print(key)    
x
y
z