Pourquoi ne x,y = zip(*zip(a,b)) travail en Python?

OK j'adore Python zip() fonction. L'utiliser tout le temps, c'est génial. Chaque maintenant et encore, je veux faire le contraire de zip(), pense "que j'ai utilisé pour savoir comment le faire", puis google python décompressez, puis rappelez-vous que l'on utilise cette magique * pour décompresser une zippée liste de tuples. Comme ceci:

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)

Ce qui sur terre se passe? Ce qui est magique astérisque faire? Où d'autre peut-il être appliqué et que d'autres belles choses incroyables en Python sont si mystérieux et difficile à google?

  • Dupliquer: stackoverflow.com/questions/2233204/...
  • oh ouais. C'est exactement le problème, la recherche de stackoverflow pour zip(* python n'a pas de retour de la double question sur la première page, et googler pour python * ou python zip(* ne retourne pas beaucoup j'imagine, parce que la (* est ignoré? Vous avez raison de bien, quelqu'un d'autre aussi pensé que c'était génial. Dois-je supprimer la question?
  • Je n'aurais pas le supprimer car il les rangs supérieur à la recherche pour une raison quelconque. Fermeture elle permettrait d'assurer une redirection.
  • J'ai trouvé le lien dans ma réponse par la recherche "site:docs.python.org astérisque". Le mot "astérisque" est beaucoup plus facile pour les moteurs de recherche que d'une réelle astérisque. 🙂
  • "ce que d'autres belles choses incroyables en Python sont si mystérieux et difficile à google?" Découvrez: stackoverflow.com/questions/101268/hidden-features-of-python pour la réponse 🙂
InformationsquelleAutor Mike Dewar | 2010-03-24
  1. 39

    L'astérisque en Python est décrite dans le tutoriel Python, sous Déballage Des Listes D'Arguments.

    InformationsquelleAutor Daniel Stutzbach
  2. 18

    L'astérisque effectue apply (comme il est connu en Lisp et Scheme). Fondamentalement, il faut que votre liste, et appelle la fonction avec la liste du contenu en tant qu'arguments.

    • Python2 de la série a toujours un apply fonction, mais je ne pense pas qu'il existe des cas d'utilisation qui ne peuvent pas être couverts par *. Je crois qu'il a été retiré de Python3
    • Confirmé. apply est répertorié dans le python.org/dev/peps/pep-0361, sous la rubrique Warnings for features removed in Py3k:
    • Appliquer n'existe que parce que l'astérisque a été ajouté plus tard.
    InformationsquelleAutor Chris Jester-Young
  3. 8

    Il est également utile pour plusieurs args:

    def foo(*args):
  print args

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

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

    Et, vous pouvez utiliser l'astérisque double pour le mot-clé arguments et les dictionnaires:

    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}

    Et bien sûr, vous pouvez combiner ces:

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

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

    Très soigné et des trucs utiles.

    InformationsquelleAutor bcherry
  4. 6

    Il ne fonctionne pas toujours:

    >>> 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

    Oups! Je pense qu'il a besoin d'un crâne à l'effrayer en travail:

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

    En python3, je pense que vous avez besoin

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

    depuis zip retourne maintenant un générateur de fonction qui n'est pas Faux-y.

    • Ou tout simplement utiliser un générateur de unzipped_x = (z[0] for z in zipped). Si zipped est lui-même un générateur de convertir une liste en premier, de sorte que vous pouvez parcourir à nouveau pour unzipped_y. Il n'y a pas de coût supplémentaire contre zip(*zipped), car ce dernier se convertit également zipped à une liste dans le processus de déballage de l'argumentation.
    InformationsquelleAutor BenAnhalt
  5. 2

    Je suis extrêmement Python donc ce tout récemment trébuché moi, mais il doit en plus faire avec la façon dont l'exemple a été présenté et ce qui a été souligné.

    Ce qui m'a donné des problèmes avec la compréhension de la zip exemple a été l'asymétrie dans le traitement de la zip de retour d'appel de valeur(s). C'est, lorsque le zip est appelée la première fois, la valeur de retour est affecté à une seule variable, afin de créer une liste de référence (contenant le créé tuple de la liste). Dans le deuxième appel, il exploite Python possibilité de décompresser automatiquement une liste (ou d'une collection?) valeur de retour dans de multiples références à des variables, chaque référence étant la personne tuple. Si quelqu'un n'est pas familier avec la façon qui fonctionne en Python, il est plus facile de se perdre à ce qui se passe réellement.

    >>> 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
    InformationsquelleAutor user3447701
  6. 0

    Additif à @bcherry réponse:

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

    De sorte qu'il fonctionne non seulement avec le mot-clé arguments (dans ce sens strict), mais avec des arguments nommés trop (aka de position arguments).

    InformationsquelleAutor Evgeni Sergeev
  7. 0

    (x, y) == tuple(zip(*zip(x,y))) est vrai si et seulement si les deux énoncés suivants sont vrais:

    • x et y ont la même longueur
    • x et y sont des n-uplets

    Un bon moyen de comprendre ce qui se passe est de l'impression à chaque étape: 

    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))))

    Sorties:

    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')]

    Fondamentalement, ce est ce qui se passe:

    1. Éléments de x et y sont jumelés en fonction de leurs indices respectifs.
    2. Paires sont déballés à 3 objets différents (tuples)
    3. Paires sont passés à zip, qui sera de nouveau, paire tous les éléments basés sur des indices:
      • les premiers éléments de toutes les entrées sont associées: (1, 2, 3)
      • deuxième éléments de toutes les entrées sont associées: ('a', 'b', 'c')

    Maintenant vous pouvez comprendre pourquoi (x, y) == tuple(zip(*zip(x,y))) est faux dans ce cas:

    • depuis y est plus que x, le premier zip opération supprimé l'élément supplémentaire de y (comme il ne pouvait pas être jumelés), ce changement est évidemment repercuted sur la deuxième opération de compression
    • types différents, au début nous avons eu deux listes, nous avons maintenant deux tuples, comme zip n'paire d'éléments de n-uplets et pas dans les listes

    Si vous n'êtes pas 100% certain de comprendre comment zip travail, j'ai écrit une réponse à cette question ici: la Décompression et l'opérateur *

    InformationsquelleAutor cglacet