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

要遍历键值对，请使用以下命令：

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

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())。

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

key只是一个变量。

对于python2. x：

>>> d = {'x': 1, 'y': 2, 'z': 3}>>> for my_var in d:>>>     print my_var, 'corresponds to', d[my_var]
x corresponds to 1y corresponds to 2z 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

对于python3. x：

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

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

在字典的情况下，它是在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是中x的简写dict.iterkeys（）.

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

迭代dict以没有特定顺序遍历其键，如您所见：

（这是在Python 3.6中不再是这种情况，但请注意，它是不能保证行为。

>>> 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)

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

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))

要迭代键，使用my_dict.keys()会慢一些，但更好。如果你尝试这样做：

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

这将创建一个运行时错误，因为您正在程序运行时更改键。如果您绝对设置为减少时间，请使用for key in my_dict方式，但您已被警告。

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

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

请注意，key， value周围的括号很重要，没有它们，你会得到一个ValueError“没有足够的值来解包”。

使用'for'循环迭代字典

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

Python如何识别它只需要从字典？key是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__方法（在本例中为字典），该方法返回一个迭代器（在本例中为键迭代器对象）：

>>> 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']

回到阴茎

我们已经看到dicts在许多上下文中迭代。我们所看到的是，每当我们迭代一个字典时，我们都会得到密钥。回到最初的例子：

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

如果我们更改变量名，我们仍然会得到密钥。让我们试试：

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

如果我们想迭代这些值，我们需要使用dicts的.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)

但出于学术目的，这个问题的例子很好。

您可以在GitHub上检查CPythondicttype的实现。这是实现字典迭代器的方法的签名：

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

CPython dictoject. c

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

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 -> 1z -> 2x -> 3

如果你正在寻找一个清晰直观的例子：

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

结果：

name:  Snowycolor:  Whiteage:  14

让我们直奔主题。如果单词key只是一个变量，正如您所提到的，那么需要注意的主要事情是，当您在字典上运行'for循环'时，它只运行钥匙而忽略价值观。

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())

在上面的情况下，钥匙不仅仅是一个变量，它是一个函数。

对于迭代字典，可以使用下面的代码。

dictionary= {1:"a", 2:"b", 3:"c"}
#To iterate over the keysfor key in dictionary.keys():print(key)
#To Iterate over the valuesfor value in dictionary.values():print(value)
#To Iterate both the keys and valuesfor key, value in dictionary.items():print(key,'\t', value)

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

使用项目关键字和for循环

key是一个简单的变量，您可以使用任何其他名称，如下例所示

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

使用项目，您可以在同一个for循环中获取值和键

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