Python 使用'迭代字典；对于'；循环

我对以下代码有点困惑：

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

---

我不明白的是

键

部分。Python如何认识到它只需要从字典中读取密钥？

key

在Python中是一个特殊的词吗？或者它只是一个变量？

当您使用for.的

遍历字典时。。在..

-语法中，它总是迭代键（可以使用

字典[key]

访问值）

---

要在键值对上迭代，在Python 2中对k使用

，在s.iteritems（）中使用v

，在Python 3中对k使用

，在s.items（）中使用v

键

只是一个变量名

for key in d:

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

对于Python 3.x：

for key, value in d.items():

对于Python2.x：

for key, value in d.iteritems():

要自己测试，请将单词

键

更改为

poop

在Python3.x中，

iteritems（）

被替换为简单的

items（）

，它返回一个由dict支持的类似集合的视图，类似于

iteritems（）

，但更好。 这在2.7中也可用作

viewitems（）

---

操作

items（）

将同时适用于2和3，但在2中，它将返回字典的

（键、值）

对的列表，这不会反映调用

items（）

后发生的dict更改。如果希望在3.x中使用2.x行为，可以调用

list（d.items（））

这是一种非常常见的循环习惯用法<中的代码>是一个运算符。有关何时将

用于输入dict

以及何时必须将

用于输入dict.keys（）

请参见。

键

只是一个变量

对于Python2.X：

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

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

。。。或者更好

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 my_var in d:
    print my_var, 'corresponds to', d[my_var]

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

---

键不是一个特殊的词，而是字典实现了迭代器协议。您可以在类中执行此操作，例如，有关如何构建类迭代器的信息，请参阅

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

• 字典实现一个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(): ...
  

  这意味着dict中x的

  是dict中x的
  的缩写
  dict.iterkeys（）
  

---

在Python 3中，

dict.iterkeys（）

、

dict.itervalues（）

和

dict.iteritems（）

不再受支持。使用

dict.keys（）

、

dict.values（）

和

dict.items（）

。

迭代一个

dict

并没有特定顺序地迭代它的键，如您在这里所见：

（这是，但请注意，还不能保证其行为。）

例如，最好使用

dict.items（）

：

这将为您提供一个元组列表。当您像这样循环它们时，每个元组将自动解压为

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 a_key, corresponding_value in d.items():
    print(a_key, corresponding_value)

---

它将创建一个运行时错误，因为您正在程序运行时更改密钥。如果您绝对希望缩短时间，请以my_dict的方式使用键的

，但您已经收到了警告。
我有一个用例，我必须迭代dict以获取键、值对，以及指示我所在位置的索引。我就是这样做的：

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

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

使用“for”循环迭代字典
Python如何认识到它只需要从
字典？关键字在Python中是一个特殊的词吗？还是仅仅是一个问题
变量

这不仅仅是循环的
。这里最重要的一个词是“迭代”

字典是键到值的映射：

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

任何时候我们迭代它，我们迭代键。变量名
key
仅用于描述，并且非常适合用于此目的

这在列表中发生：

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

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

Python迭代的方式是，在需要的上下文中，它调用对象（在本例中为字典）的
\uuu iter\uuuuu
方法，该方法返回迭代器（在本例中为keyiterator对象）：

迭代器有一个
\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu

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

回到口述
我们已经看到dicts在许多上下文中反复出现。我们所看到的是，每当我们在dict上迭代时，我们都会得到键。回到原始示例：

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

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

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

如果我们想迭代这些值，我们需要使用dicts的
.values
方法，或者同时使用
.items
：

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

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

在给出的示例中，对如下项进行迭代会更有效：

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

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

但出于学术目的，这个问题是
>>> 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)

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

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

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

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