“清单理解”有什么作用。和类似的意思？它如何工作，如何使用它？

Question

我有以下代码：

[x ** 2 for x in range(10)]

当我在python shell中运行它时，它返回：

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

我已经搜索了，看来这被称为 list consection ，同样似乎有设置/dict enlastions and dict enlastions和生成器表达。但是它如何工作？

Answer 1

来自 文档 ：

列表综合提供了一种创建列表的简洁方法。常见的应用程序是在每个元素上都是应用于其他序列或迭代序列的每个成员的结果的新列表，或者创建满足特定条件的元素的子序列。

---

关于您的问题，列表理解与以下“普通” python代码相同的事情：

>>> l = [] 
>>> for x in range(10):
...     l.append(x**2)
>>> l
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

如何将其写成一行？嗯...我们可以...可能...使用 map（ ） 与 ：

>>> list(map(lambda x: x**2, range(10)))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

但是，只使用列表理解越清楚，更简单吗？

>>> [x**2 for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

---

基本上，我们可以使用 x 来做任何事情。不仅 x ** 2 。例如，运行 x 的方法：

>>> [x.strip() for x in ('foo\n', 'bar\n', 'baz\n')]
['foo', 'bar', 'baz']

或使用 x 作为另一个函数的参数：

>>> [int(x) for x in ('1', '2', '3')]
[1, 2, 3]

例如，我们还可以使用 x 作为密钥 dict 对象的of。让我们看看：

>>> d = {'foo': '10', 'bar': '20', 'baz': '30'}
>>> [d[x] for x in ['foo', 'baz']]
['10', '30']

组合怎么样？

>>> d = {'foo': '10', 'bar': '20', 'baz': '30'}
>>> [int(d[x].rstrip('0')) for x in ['foo', 'baz']]
[1, 3]

等等。

---

您也可以在列表理解中使用或如果... else 在列表理解中使用。例如，您只需要范围（10）中的奇数数字。您可以做：

>>> l = []
>>> for x in range(10):
...     if x%2:
...         l.append(x)
>>> l
[1, 3, 5, 7, 9]

啊，太复杂了。那以下版本呢？

>>> [x for x in range(10) if x%2]
[1, 3, 5, 7, 9]

要使用，如果... else 三元表达式，您需要将放置... else ... 之后 x ， <代码>范围之后（10）：

>>> [i if i%2 != 0 else None for i in range(10)]
[None, 1, None, 3, None, 5, None, 7, None, 9]

---

您是否听说过 嵌套列表理解 ？您可以在一个列表理解中将的两个或多个放在一个中。例如：

>>> [i for x in [[1, 2, 3], [4, 5, 6]] for i in x]
[1, 2, 3, 4, 5, 6]

>>> [j for x in [[[1, 2], [3]], [[4, 5], [6]]] for i in x for j in i]
[1, 2, 3, 4, 5, 6]

让我们谈谈第一部分，<代码> x在[[1，2，3]，[4，5，6]] 中给出 [1，2，3] < /code>和 [4，5，6] 。然后，对于x 给出 1 ， 2 ， 3 和 4 ， 5 ， 6 。

警告：您始终需要在[[1，2，3]，[4，5，6]] 对于i在x 中的i：

>>> [j for j in x for x in [[1, 2, 3], [4, 5, 6]]]
Traceback (most recent call last):
  File "<input>", line 1, in <module>
NameError: name 'x' is not defined

---

我们还设置了设置综合， dict enlastions 和 Generator Expressions 。

设置综合和列表综合基本上是相同的，但是前者返回a set 而不是 list ：与

>>> {x for x in [1, 1, 2, 3, 3, 1]}
{1, 2, 3}

相同

>>> set([i for i in [1, 1, 2, 3, 3, 1]])
{1, 2, 3}

： a dict classence 看起来像设置的理解，但它使用 {键：键的值，in ...} 或 {i：i in ... in ...} 而不是 {i for I in ...} 。

例如：

>>> {i: i**2 for i in range(5)}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

它等于：

>>> d = {}
>>> for i in range(5):
...     d[i] = i**2
>>> d
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

（i在范围（5）中i）给出 tuple ？不！返回 Generator ：

>>> (i for i in range(5))
<generator object <genexpr> at 0x7f52703fbca8>

它与以下内容相同：

>>> def gen():
...     for i in range(5):
...         yield i
>>> gen()
<generator object gen at 0x7f5270380db0>

您可以将其用作生成器：

>>> gen = (i for i in range(5))
>>> next(gen)
0
>>> next(gen)
1
>>> list(gen)
[2, 3, 4]
>>> next(gen)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
StopIteration

注意：如果您在函数内使用列表clastension ，您不需要 [] 如果该功能可以通过生成器循环。例如， sum（） ：

>>> sum(i**2 for i in range(5))
30

< strong>相关（关于生成器）：了解Python中的生成器。

Answer 2

有列表，字典和设置综合，但没有元组综合（尽管确实探索了“生成器表达”）。

他们解决了python中传统循环是陈述（不要返回任何内容）而不是返回值的表达式的问题。

它们不是解决每个问题的解决方案，并且可以被重写为传统循环。当需要维护状态时，它们变得尴尬＆amp;在迭代之间进行了更新。

它们通常由：

[<output expr> <loop expr <input expr>> <optional predicate expr>]

但可以以许多有趣且奇怪的方式扭曲。

它们可以类似于传统 map（）和 filter（）仍然存在于Python中并继续使用的操作。

做得好时，它们具有很高的满足商。

Answer 3

如果您喜欢一种更视觉的方法来弄清楚发生了什么，那么也许这会有所帮助：

# for the example in the question...

y = []
for x in range(10):
    y += [x**2]

# is equivalent to...

y = [x**2 for x in range(10)]

# for a slightly more complex example, it is useful
# to visualize  where the various x's end up...

a = [1,2,3,4]
b = [3,4,5,6]
c = []

for x in a:
          if x in b:
                  c += [x]
#   \         \        /
#    \    _____\______/
#     \  /      \
#      \/        \
#      /\         \
#     /  \         \
#    /    \         \
c = [x for x in a if x in b]

print(c)

...产生输出 [3，4]

Answer 4

最近，我看到了很多关于清单综合工作方式的困惑（在其他问题和同事上）。数学教育的一段时间可以帮助为什么语法是这样的，以及清单的综合性真正含义。

语法

最好将列表的综合视为在集合/集合上的谓词，就像我们在数学中使用集合构建器符号一样。对我来说，符号实际上很自然，因为我拥有数学学位。但是忘了我，吉多·范·罗斯姆（Python的发明者）拥有数学硕士学位，并具有数学背景。

设置构建器符号速效课程

这是设置构建器符号的工作方式的（非常基础）：

所以，此集合构建器表示法代表严格肯定的数字集（即 [1,2， 3,4，...] ）。

混淆点

1） set构建器符号中的谓词过滤器仅指定我们要保留的项目，并列出理解谓词做同样的事情。您不必在省略项目，除非谓词包括在内，否则将省略它们。空谓词（即最后没有条件）包括给定集合中的所有项目。

2） set Builder符号中的谓词过滤器最终出现在列表综合中。（某些）初学者认为 [x＆lt; 5对于x范围（10）] 将为他们提供列表 [0,1,2,3,4] ，而实际上它输出是真的，正确，正确，错误，错误，false，false，false] 。我们获得输出 [真实，真实，真实，真实，真实，错误，false，false，false，false] ，因为我们要求Python评估 x＆lt; 5 <代码>范围（10）中的所有项目。没有谓词意味着我们从集合中获取所有内容（就像在集合构建器符号中一样）。

如果您在使用列表综合的同时将设置的构建器符号保持在脑海中，则它们更容易吞咽。

hth！

Answer 5

简介

列表理解是在Python中创建列表的高级，声明的方法。综合的主要好处是可读性和可维护性。很多人发现它们非常可读，甚至从未见过它们的开发人员通常都可以正确猜测它的含义。

# Snippet 1
squares = [n ** 2 for n in range(5)]

# Snippet 2
squares = []
for n in range(5):
    squares.append(n ** 2)

两个代码的两个片段都将产生 squares 等于 [0，1，4，9，16] 。

请注意，在第一个片段中，您的类型是在声明您想要的列表，而第二个则指定如何创建它。这就是为什么理解是高级和声明的原因。

语法

[EXPRESSION for VARIABLE in SEQUENCE]

表达式是任何python表达式，但通常具有一些变量是典型的。此变量在变量字段中说明。 sequence 定义值列举的值的来源。

考虑片段1， [n ** 2 for n范围（5）] ：

• expression is n ** 2
• variable /code> is n
• sequence 是 range> range（5）

请注意，如果您检查 Squares 的类型，您将了解列表理解只是一个常规列表：

>>> type(squares)
<class 'list'>

更多关于表达式

表达式可以是将任何降低到值的事物：

• 算术表达式，例如 n ** 2 + 3 * n + 1 < /code>
• 一个函数调用，例如 f（n）使用 n 作为变量的
• slice操作，例如 s [::- 1]
• 方法>方法调用<代码> bar.foo（）
• ...

一些示例：

>>> [2 * x + 3 for x in range(5)]
[3, 5, 7, 9, 11]
>>> [abs(num) for num in range(-5, 5)]
[5, 4, 3, 2, 1, 0, 1, 2, 3, 4]
>>> animals = ['dog', 'cat', 'lion', 'tiger']
>>> [animal.upper() for animal in animals]
['DOG', 'CAT', 'LION', 'TIGER']

过滤：

最终列表中元素的顺序由 sequence 的顺序确定。但是，您可以过滤出添加的元素，如果子句：

[EXPRESSION for VARIABLE in SEQUENCE if CONDITION]

条件是评估 true 或 false> false 的表达式。 。从技术上讲，条件不必依赖于变量，但通常使用它。

示例：

>>> [n ** 2 for n in range(5) if n % 2 == 0]
[0, 4, 16]
>>> animals = ['dog', 'cat', 'lion', 'tiger']
>>> [animal for animal in animals if len(animal) == 3]
['dog', 'cat']

另外，请记住，Python允许您编写除列表以外的其他综合：

• 字典综合
• 设置综合

Answer 6

对于那些寻找A 嵌套的内联操作员 ：

[(i,j) for i in range(8) for j in range(8)]

它等于 itertools.products.product ：

from itertools import product

list(product(range(8), range(8)))

对于其他上下文，这等同于以下嵌套循环：

results = []
for i in range(8):
    for j in range(8):
        coord = (i, j)
        results.append(coord)