Python 使用2 for循环列出理解行为

下面是模拟python zip函数的代码

def myzip(*args):
    return [tuple(a[i] for a in args) for i in range(len(min(args, key=len)))]

print(myzip([10, 20,30], 'abc'))   

#output: [(10, 'a'), (20, 'b'), (30, 'c')]

如果我删除tuple（），输出将是：[10,20,30，'a'，'b'，'c']

当我们仅仅添加tuple（）时，我不太理解列表理解是如何工作的

所以在每2个循环之后，它会产生一个值并自动将其添加到内部列表中，然后再转换为元组，最后将它们添加到外部列表中

例如：

环路1:10 循环2:a 添加到[10，a]->tuple（[10，a]）->（10，a）

环路2:20 回路2:b 添加到[20，b]->tuple（[20，b]）->（20，b）

---

..

如果删除

元组，则不再生成单独的子列表（或元组），并且更改了理解中的内部循环与外部循环

这种理解是有效的（类似于
元组（a[i]表示args中的a）
）：

因为
[a[i]对于args中的a]
是在下一个
i
之前执行的；也就是说，每个
a
中的每个
i
第四个索引依次添加到子列表中，并且这些结果的子列表添加到结果列表中。因此，
[a[i]对于args中的a]
是内环，而
对于范围内的i（len（min（args，key=len））
是外环

但这是：

 [a[i] for a in args for i in range(len(min(args, key=len)))]
 # [10, 20, 30, 'a', 'b', 'c'] with myzip([10,20,30],'abc')

在转到args中的下一个
a
之前，先排出
i
列表。然后重新启动
i
列表，并解释为什么您得到
[10,20,30'，a'，b'，c']
而不是
[（10，'a'），（20，'b'），（30，'c'）]
删除
[]
或
元组（）
现在已使
内循环和
a[i]对于a，in args
现在已成为外部循环


这是：

[(a[i] for a in args) for i in range(len(min(args, key=len)))]

创建生成器列表

如果我删除tuple（），输出将是：[10,20,30，'a'，'b'，'c']

我想你是说

>>> def myzip(*args):
...     return [a[i] for a in args for i in range(len(min(args, key=len)))]
...
>>> print(myzip([10, 20,30], 'abc'))
[10, 20, 30, 'a', 'b', 'c']

这相当于

>>> def myzip(*args):
...     results = []
...     for a in args:
...         for i in range(len(min(args, key=len))):
...             results.append(a[i])
...     return results
...
>>> print(myzip([10, 20,30], 'abc'))
[10, 20, 30, 'a', 'b', 'c']

这实际上是将
args
中的嵌套列表展平。有关“嵌套”列表理解的详细信息，请参见。
这与列表理解表达式不同部分的位置有关

使用
tuple（）
调用，调用
tuple
函数并传递生成器
（a[i]表示参数中的a）
。因此，自动地，参数中a的
部分将被视为内部循环。因此，
[（10，'a'），（20，'b'），（30，'c'）]

这可以扩展到：

>ret=[]
>>>对于范围内的i（len（min（args，key=len））：
sub=[]
对于args中的a：
附款（a[i]）
ret.append（元组（子））
>>>ret
[（10，'a'），（20，'b'），（30，'c'）]

如果没有
tuple（）
调用，则范围内i的
部分（len（min（args，key=len））
将成为内部循环。因此，
[10,20,30，'a'，'b'，'c']

这可以扩展到：

>ret=[]
>>>对于args中的a：
对于范围内的i（len（min（args，key=len））：
ret.append（a[i]）
>>>ret
[10,20,30，'a'，'b'，'c']

如果您是两个，请切换两个循环以实现此目的：

[a[i]表示范围内的i（len（min（args，key=len））表示范围内的a]

现在，args中a的
部分返回到内部循环。因此，
[10，'a'，20，'b'，30，'c']

这可以扩展到：

>ret=[]
>>>对于范围内的i（len（min（args，key=len））：
对于args中的a：
ret.append（a[i]）
>>>ret
[10，'a'，20，'b'，30，'c']
这是个好问题。我认为你的解释不正确。python似乎执行了整个2个完整的循环，并以某种方式将值保存在内存中。在两个循环之后，添加到同一个元组中，不同参数但索引相同的值“使用2个for循环进行列表理解”被称为嵌套列表理解…当你说“移除元组（）”时，你的意思是“但是保持嵌套列表理解”，因此：
[a[i]对于a in args对于i in range（…）]
谢谢。现在我看到for循环的顺序如何影响最终结果。但在您的扩展示例中，我们仍然需要处理2个列表。通过列表理解，它如何准确地处理每个值？因为元组是不可变的，所以我们不能只添加“10”，然后再添加“a”。
tuple（）
函数不会创建空元组并向其添加值。相反，它接受一个iterable（列表、字符串等）并返回这些值的元组。在这种情况下，iterable是一个生成器（括号中的任何列表理解表达式而不是brakets都是生成器），并且
tuple（）
返回从该生成器生成的值的元组。
>>> def myzip(*args):
...     results = []
...     for a in args:
...         for i in range(len(min(args, key=len))):
...             results.append(a[i])
...     return results
...
>>> print(myzip([10, 20,30], 'abc'))
[10, 20, 30, 'a', 'b', 'c']