为什么x，y = zip（* zip（a，b））在Python中有效？

好的，我喜欢Python的zip()功能。一直使用它，非常棒。我时不时地想做相反的事情zip()，想想“我曾经知道怎么做”，然后用google python解压缩，然后记住，有人用这种魔术*来解压缩一个元组的压缩列表。像这样：

x = [1,2,3]
y = [4,5,6]
zipped = zip(x,y)
unzipped_x, unzipped_y = zip(*zipped)
unzipped_x
    Out[30]: (1, 2, 3)
unzipped_y
    Out[31]: (4, 5, 6)

到底是怎么回事？那神奇的星号在做什么？它还能在其他地方应用？Python中还有哪些其他令人赞叹的令人敬畏的事物如此神秘且难以谷歌搜索？

Python教程中的解压缩参数列表下记录了Python中的星号。

星号执行apply（如Lisp和Scheme中所知）。基本上，它接受您的列表，并以该列表的内容作为参数来调用该函数。

对于多个参数也很有用：

def foo(*args):
  print args

foo(1, 2, 3) # (1, 2, 3)

# also legal
t = (1, 2, 3)
foo(*t) # (1, 2, 3)

而且，您可以对关键字参数和字典使用双星号：

def foo(**kwargs):
   print kwargs

foo(a=1, b=2) # {'a': 1, 'b': 2}

# also legal
d = {"a": 1, "b": 2}
foo(**d) # {'a': 1, 'b': 2}

当然，您可以将这些结合起来：

def foo(*args, **kwargs):
   print args, kwargs

foo(1, 2, a=3, b=4) # (1, 2) {'a': 3, 'b': 4}

很整洁和有用的东西。

它并不总是有效：

>>> x = []
>>> y = []
>>> zipped = zip(x, y)
>>> unzipped_x, unzipped_y = zip(*zipped)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: need more than 0 values to unpack

糟糕！我认为它需要一块头骨才能使其正常工作：

>>> unzipped_x, unzipped_y = zip(*zipped) or ([], [])
>>> unzipped_x
[]
>>> unzipped_y
[]

在python3中，我认为您需要

>>> unzipped_x, unzipped_y = tuple(zip(*zipped)) or ([], [])

因为zip现在返回的生成器函数不是False-y。

我是Python的新手，所以最近才使我震惊，但是它与示例的呈现方式和强调内容之间的关系更多。

使我无法理解zip示例的问题是zip调用返回值的处理不对称。也就是说，第一次调用zip时，将返回值分配给单个变量，从而创建列表引用（包含创建的元组列表）。在第二个调用中，它利用Python的功能将列表（或集合？）返回值自动解包到多个变量引用中，每个引用都是单独的元组。如果某人不熟悉Python的工作方式，那么很容易迷失实际发生的事情。

>>> x = [1, 2, 3]
>>> y = "abc"
>>> zipped = zip(x, y)
>>> zipped
[(1, 'a'), (2, 'b'), (3, 'c')]
>>> z1, z2, z3 = zip(x, y)
>>> z1
(1, 'a')
>>> z2
(2, 'b')
>>> z3
(3, 'c')
>>> rezipped = zip(*zipped)
>>> rezipped
[(1, 2, 3), ('a', 'b', 'c')]
>>> rezipped2 = zip(z1, z2, z3)
>>> rezipped == rezipped2
True

@bcherry答案的附录：

>>> def f(a2,a1):
...  print a2, a1
... 
>>> d = {'a1': 111, 'a2': 222}
>>> f(**d)
222 111

因此，它不仅适用于关键字参数（严格意义上来说），而且也适用于命名参数（即位置参数）。

(x, y) == tuple(zip(*zip(x,y))) 当且仅当以下两个语句为真时，才为true：

• x并且y具有相同的长度
• x并且y是元组

一种了解发生了什么的好方法是在每个步骤打印：

x = [1, 2, 3]
y = ["a", "b", "c", "d"]

print("1) x, y = ", x, y)
print("2) zip(x, y) = ", list(zip(x, y)))
print("3) *zip(x, y) = ", *zip(x, y))
print("4) zip(*zip(x,y)) = ", list(zip(*zip(x,y))))

哪个输出：

1) x, y =            [1, 2, 3] ['a', 'b', 'c', 'd']
2) zip(x, y) =       [(1, 'a'), (2, 'b'), (3, 'c')]
3) *zip(x, y) =       (1, 'a')  (2, 'b')  (3, 'c')
4) zip(*zip(x,y)) =  [(1, 2, 3), ('a', 'b', 'c')]

基本上就是这样：

2. x和y中的项目根据其各自的索引进行配对。
3. 线对解包到3个不同的对象（元组）
4. 将对传递到zip，zip将再次根据索引对每个项目进行配对：
   • 来自所有输入的第一项配对： (1, 2, 3)
   • 来自所有输入的第二项配对： ('a', 'b', 'c')

现在您可以了解(x, y) == tuple(zip(*zip(x,y)))在这种情况下为什么为假：

• 由于y的长度大于x，因此第一个压缩操作从中删除了多余的项目y（因为无法配对），因此此更改显然在第二个压缩操作中重新执行
• 类型不同，一开始我们有两个列表，现在我们有两个元zip组，而在元组而不是列表中配对项目也是如此

如果您不是100％不确定要如何zip工作，我在这里为这个问题写了一个答案：解压缩和*运算符