在Python中，你可以在一个列表推导式中有多个迭代器，比如
[(x,y) for x in a for y in b]
我知道Python的列表推导式的嵌套循环语义。
我的问题是:理解中的一个迭代器可以指向另一个迭代器吗?换句话说:我能得到这样的东西吗?
[x for x in a for a in b]
外部循环的当前值是内部循环的迭代器?
举个例子，如果我有一个嵌套列表:
a=[[1,2],[3,4]]
要实现这个结果，列表理解表达式是什么:
[1,2,3,4]
？? (请只列出理解性的答案，因为这是我想知道的)。
当前回答
在我第一次尝试的时候，我从来没有写过双表理解。读一读PEP202，你会发现原因是它的实施方式和你在英语中读到的完全相反。好消息是，这是一个逻辑上合理的实现，因此一旦您理解了结构，就很容易得到正确的实现。
设a, b, c, d是依次嵌套的对象。对我来说，扩展列表理解的直观方法是模仿英语:
# works
[f(b) for b in a]
# does not work
[f(c) for c in b for b in a]
[f(c) for c in g(b) for b in a]
[f(d) for d in c for c in b for b in a]
换句话说，你将从下往上阅读，即。
# wrong logic
(((d for d in c) for c in b) for b in a)
然而，这不是Python实现嵌套列表的方式。相反，实现将第一个块视为完全独立的块，然后从上到下(而不是从下到上)将for和in链接到单个块中，即。
# right logic
d: (for b in a, for c in b, for d in c)
请注意，嵌套最深的层(对于c中的d)距离列表(d)中的最后一个对象最远。这是因为Guido自己:
形式[…]x……y……]巢，最后一个索引变化最快，就像嵌套for循环一样。
使用Skam的文本示例，这变得更加清楚:
# word: for sentence in text, for word in sentence
[word for sentence in text for word in sentence]
# letter: for sentence in text, for word in sentence, for letter in word
[letter for sentence in text for word in sentence for letter in word]
# letter:
# for sentence in text if len(sentence) > 2,
# for word in sentence[0],
# for letter in word if letter.isvowel()
[letter for sentence in text if len(sentence) > 2 for word in sentence[0] for letter in word if letter.isvowel()]
其他回答
我觉得这样更容易理解
[row[i] for row in a for i in range(len(a))]
result: [1, 2, 3, 4]
ThomasH已经补充了一个很好的答案，但我想展示发生了什么:
>>> a = [[1, 2], [3, 4]]
>>> [x for x in b for b in a]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'b' is not defined
>>> [x for b in a for x in b]
[1, 2, 3, 4]
>>> [x for x in b for b in a]
[3, 3, 4, 4]
我猜Python是从左到右解析列表理解的。这意味着，发生的第一个for循环将首先执行。
第二个“问题”是b被“泄露”出了列表理解。在第一个成功的列表理解b ==[3,4]。
用你自己的建议来回答你的问题:
>>> [x for b in a for x in b] # Works fine
当你要求列表理解答案时，让我也指出优秀的itertools.chain():
>>> from itertools import chain
>>> list(chain.from_iterable(a))
>>> list(chain(*a)) # If you're using python < 2.6
在我第一次尝试的时候，我从来没有写过双表理解。读一读PEP202，你会发现原因是它的实施方式和你在英语中读到的完全相反。好消息是，这是一个逻辑上合理的实现，因此一旦您理解了结构，就很容易得到正确的实现。
设a, b, c, d是依次嵌套的对象。对我来说，扩展列表理解的直观方法是模仿英语:
# works
[f(b) for b in a]
# does not work
[f(c) for c in b for b in a]
[f(c) for c in g(b) for b in a]
[f(d) for d in c for c in b for b in a]
换句话说，你将从下往上阅读，即。
# wrong logic
(((d for d in c) for c in b) for b in a)
然而，这不是Python实现嵌套列表的方式。相反，实现将第一个块视为完全独立的块，然后从上到下(而不是从下到上)将for和in链接到单个块中，即。
# right logic
d: (for b in a, for c in b, for d in c)
请注意，嵌套最深的层(对于c中的d)距离列表(d)中的最后一个对象最远。这是因为Guido自己:
形式[…]x……y……]巢，最后一个索引变化最快，就像嵌套for循环一样。
使用Skam的文本示例，这变得更加清楚:
# word: for sentence in text, for word in sentence
[word for sentence in text for word in sentence]
# letter: for sentence in text, for word in sentence, for letter in word
[letter for sentence in text for word in sentence for letter in word]
# letter:
# for sentence in text if len(sentence) > 2,
# for word in sentence[0],
# for letter in word if letter.isvowel()
[letter for sentence in text if len(sentence) > 2 for word in sentence[0] for letter in word if letter.isvowel()]
这个记忆技巧对我帮助很大:
[< currend_value > < outer_loop1 > < inner_loop2 > < inner_loop3 >…]< OPTIONAL_IF >)
现在你可以考虑返回+外循环 作为唯一的正义秩序
知道了上面，列表综合的顺序即使是3个循环看起来也很简单:
c=[111, 222, 333]
b=[11, 22, 33]
a=[1, 2, 3]
print(
[
(i, j, k) # <RETURNED_VALUE>
for i in a for j in b for k in c # in order: loop1, loop2, loop3
if i < 2 and j < 20 and k < 200 # <OPTIONAL_IF>
]
)
[(1, 11, 111)]
因为上面只是一个:
for i in a: # outer loop1 GOES SECOND
for j in b: # inner loop2 GOES THIRD
for k in c: # inner loop3 GOES FOURTH
if i < 2 and j < 20 and k < 200:
print((i, j, k)) # returned value GOES FIRST
对于迭代一个嵌套的列表/结构，技术是相同的: 对于a这个问题:
a = [[1,2],[3,4]]
[i2 for i1 in a for i2 in i1]
which return [1, 2, 3, 4]
对于另一个嵌套级别
a = [[[1, 2], [3, 4]], [[5, 6], [7, 8, 9]], [[10]]]
[i3 for i1 in a for i2 in i1 for i3 in i2]
which return [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
等等
