Python 列表（dict）和dict.keys（）之间的差异？

假设我有一个口述：

foo = {'a': 1}

---

list（foo）

和

foo.keys（）

返回相同的内容。两者之间有什么区别？

Python 3中有一个区别

foo.keys（）

返回键的迭代器，这是Python 2中的

foo.iterkeys（）

所做的，而

list（foo）

返回键的列表

---

如下所述，

foo.keys（）

在Python3中并不完全返回迭代器。它返回一个

dict_keys

对象（或视图），在其操作中，该对象允许迭代。您还可以做一些有趣的事情，例如集合操作和多次迭代。它仍然有惰性求值的概念，这使得迭代器非常强大。

python 2中没有真正的区别，这就是为什么我怀疑

dict.keys

更改为在python3中返回视图，而

dict.viewkeys

被删除的原因

在python 3中：

In [3]: foo = dict((k,k) for k in range(4))

In [4]: foo
Out[4]: {0: 0, 1: 1, 2: 2, 3: 3}

In [5]: foo.keys?
Type:        builtin_function_or_method
String form: <built-in method keys of dict object at 0x7f45d8667708>
Docstring:   D.keys() -> a set-like object providing a view on D's keys

In [6]: foo.keys()
Out[6]: dict_keys([0, 1, 2, 3])

In [7]: type(foo.keys())
Out[7]: dict_keys

In [8]: for i in foo.keys():
   ...:     del foo[i]
   ...:     
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-8-659d5446ab29> in <module>()
----> 1 for i in foo.keys():
      2     del foo[i]
      3 

RuntimeError: dictionary changed size during iteration

In [9]: for i in list(foo):
    del foo[i]

In [10]: foo
Out[10]: {}

[3]中的

foo=dict（（k，k）表示范围（4）中的k）
在[4]中：foo
Out[4]：{0:0，1:1，2:2，3:3}
在[5]：foo.keys？
类型：内置函数或方法
字符串形式：
Docstring:D.keys（）->提供D键视图的类似集合的对象
在[6]中：foo.keys（）
Out[6]：dict_键（[0,1,2,3]）
在[7]中：键入（foo.keys（））
Out[7]：dict_键
在[8]中：对于foo.keys（）中的i：
…：德福[i]
...:     
---------------------------------------------------------------------------
运行时错误回溯（上次最近调用）
在（）
---->1表示foo.keys（）中的i：
2德福[i]
3.
RuntimeError:字典在迭代期间更改了大小
In[9]：对于列表中的i（foo）：
德福[i]
在[10]中：foo
Out[10]：{}

最后两件事基本上就是您需要了解python3中

dict.keys

和

list（dictionary）

之间的区别

dict.keys

只是键的一个视图，因此检查dictionary.keys（）中的

项是O（1），但不能迭代dictionary.keys（）

并同时修改字典

它们都是迭代器，因为它们都实现了Python3:

从官方

调用foo.keys（）将返回字典视图对象。它支持 成员资格测试和迭代之类的操作，但其内容是 不独立于原始词典-它只是一个视图

其实,

type(foo.keys())

给予

给予

---

在Python3中，由

.keys（）

返回的

dict_keys

对象只指向实际的字典键（并且在更改字典时会更改），而

list

命令创建键的副本。 因此，

dict_键

更轻巧、更快。在迭代字典键的同时修改字典时，应使用

列表

。字典

foo

有点荒谬的例子：

>>> for kw in foo.keys():
...   foo.pop(kw)

导致

运行时错误：字典在迭代过程中更改了大小
，而以下操作有效：

>>> for kw in list(foo):
...   foo.pop(kw)

在python3中，
foo.keys（）
返回一个
视图
注意，
list（）
调用基本上会迭代
\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
调用将运行新的
\uuu iter\uuu
。在Python2中，
list（foo）
本质上调用
foo.iterkeys（）
并从其内容创建一个列表，就像
foo.iterkeys（）
和
iter（foo）
返回相同的对象一样。是的，请检查文档--脚注中的最后一点
dict.keys（）
返回字典视图对象（而不是迭代器）。
list（foo）
为您提供一个完整的新列表对象，对吗？这就是为什么你可以从中删除项目，我想：）是的，这就是为什么你可以迭代并从字典中删除。什么是
foo.keys？
符号？这对我来说似乎不起作用。这很神奇，请看这里的第四点：。它基本上相当于调用
help（foo.keys）
<type 'list'>

>>> for kw in foo.keys():
...   foo.pop(kw)

>>> for kw in list(foo):
...   foo.pop(kw)

      'duration': [120.0, 240.0, 90.0, 16.0, 48.0],
      'rate': [0.11, 0.06, 0.08, 0.14, 0.07],
      'down_payment': [100000.0, 0.0, 8900.0, 0.0, 4300.0]} ```

data.keys()

dict_keys(['amount', 'duration', 'rate', 'down_payment'])

dict.keys produce a dictkeys. that we can only read . not can do change