web-dev-qa-db-fra.com

Listes ZIP dans Python

J'essaie d'apprendre à "compresser" des listes. À cette fin, j'ai un programme où, à un moment donné, je fais ce qui suit:

x1, x2, x3 = stuff.calculations(withdataa)

Cela me donne trois listes, x1, x2 et x3, chacune de taille 20.

Maintenant oui:

zipall = Zip(x1, x2, x3)

Cependant, quand je le fais:

print "len of zipall %s" % len(zipall)

J'en ai 20, ce qui n'est pas ce à quoi je m'attendais. Je m'attendais à trois. Je pense que je fais quelque chose de fondamentalement faux.

pythonpython-2.7
133
AJW

Lorsque vous Zip() réunissez trois listes contenant chacune 20 éléments, le résultat contient vingt éléments. Chaque élément est un triple.

Voir par vous-même:

In [1]: a = b = c = range(20)

In [2]: Zip(a, b, c)
Out[2]: 
[(0, 0, 0),
 (1, 1, 1),
 ...
 (17, 17, 17),
 (18, 18, 18),
 (19, 19, 19)]

Pour connaître le nombre d'éléments contenus dans chaque tuple, vous pouvez examiner la longueur du premier élément:

In [3]: result = Zip(a, b, c)

In [4]: len(result[0])
Out[4]: 3

Bien sûr, cela ne fonctionnera pas si les listes étaient vides pour commencer.

201
NPE

Zip prend un tas de listes j'aime

a: a1 a2 a3 a4 a5 a6 a7...
b: b1 b2 b3 b4 b5 b6 b7...
c: c1 c2 c3 c4 c5 c6 c7...

et les "zippe" dans une liste dont les entrées sont 3-tuples (ai, bi, ci). Imaginez dessiner une fermeture à glissière horizontalement de gauche à droite.

55
Katriel

Dans Python2.7, cela aurait peut-être bien fonctionné:

>>> a = b = c = range(20)
>>> Zip(a, b, c)

Mais dans Python3.4 il devrait l'être (sinon, le résultat sera quelque chose comme <Zip object at 0x00000256124E7DC8>):

>>> a = b = c = range(20)
>>> list(Zip(a, b, c))
31
Ajay

Zip crée une nouvelle liste, remplie de nuplets contenant des éléments à partir des arguments itérables:

>>> Zip ([1,2],[3,4])
[(1,3), (2,4)]

Je m'attends à ce que vous essayiez de créer un tuple où chaque élément est une liste.

25
StoryTeller

Fondamentalement, la fonction Zip fonctionne sur les listes, les n-uplets et les dictionnaires en Python. Si vous utilisez IPython, tapez simplement zip? Et vérifiez en quoi consiste Zip ().

Si vous n'utilisez pas IPython, installez-le simplement: "pip install ipython"

Pour les listes

a = ['a', 'b', 'c']
b = ['p', 'q', 'r']
Zip(a, b)

La sortie est [('a', 'p'), ('b', 'q'), ('c', 'r')

Pour dictionnaire:

c = {'gaurav':'waghs', 'nilesh':'kashid', 'ramesh':'sawant', 'anu':'raje'}
d = {'amit':'wagh', 'swapnil':'dalavi', 'anish':'mane', 'raghu':'rokda'}
Zip(c, d)

La sortie est:

[('gaurav', 'amit'),
 ('nilesh', 'swapnil'),
 ('ramesh', 'anish'),
 ('anu', 'raghu')]
14
Wagh

Source: Mon blog (meilleure mise en forme)

Exemple 

numbers = [1,2,3]
letters = 'abcd'

Zip(numbers, letters)
# [(1, 'a'), (2, 'b'), (3, 'c')]

Entrée

Zéro ou plusieurs iterables [1] (ex. Liste, chaîne, tuple, dictionnaire)

Sortie (liste)

1er tuple = (élément_1 de nombres, élément_1 de lettres)

2e tuple = (e_2 chiffres, e_2 lettres)

…

nième th = = (e_n nombres, e_n lettres)

  1. Liste de n-uplets: n est la longueur de l'argument le plus court (entrée)
    • len (nombres) == 3 <len (lettres) == 4 → court = 3 → retour 3 tuples
  2. Longueur de chaque tuple = nombre d'arguments (Tuple prend un élément de chaque argument)
    • args = (chiffres, lettres); len (args) == 2 → Tuple à 2 éléments
  3. ith Tuple = (élément_i arg1, élément_i arg2…, élément_i argn)

Cas Edge

1) Chaîne vide: len (str) = 0 = pas de tuples

2) Chaîne unique: len (str) == 2 tuples avec len (arguments) == 1 élément (s)

Zip()
# []
Zip('')
# []
Zip('hi')
# [('h',), ('i',)]

Zip en action!

1. Construisez un dictionnaire [2] sur deux listes 

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( Zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]
  • Zip est une solution élégante, claire et concise

2. Imprimer des colonnes dans un tableau

"*" [3] est appelé "décompression": f(*[arg1,arg2,arg3]) == f(arg1, arg2, arg3)

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = Zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

Crédit supplémentaire: décompression

Zip(*args) est appelé “décompression” car il a l'effet inverse de Zip

numbers = (1,2,3)
letters = ('a','b','c')

zipped = Zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = Zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]
  • unzipped: Tuple_1 = e1 de chaque tuple compressé. Tuple_2 = e2 de chaque zipped

Notes de bas de page

  1. Un objet capable de retourner ses membres un à un (ex. List [1,2,3], chaîne de caractères 'I like codin', Tuple (1,2,3), dictionary {'a': 1, 'b' : 2})
  2. {clé1: valeur1, clé2: valeur2 ...}
  3. “Déballage” (*)

* Code:

# foo - function, returns sum of two arguments
def foo(x,y):
    return x + y
print foo(3,4)
# 7

numbers = [1,2]
print foo(numbers)
# TypeError: foo() takes exactly 2 arguments (1 given)

print foo(*numbers)
# 3

* a pris numbers (1 argument) et a "décompacté" ses 2 éléments en 2 arguments

12
JBallin

Par souci de complétude.

Lorsque la longueur des listes compressées n'est pas la même. La longueur de la liste de résultats deviendra la plus courte sans qu'aucune erreur ne se produise

>>> a = [1]
>>> b = ["2", 3]
>>> Zip(a,b)
[(1, '2')]
8
transang

Dans PythonZip renvoie un itérateur à la place et doit être passé à une fonction de liste pour obtenir les n-uplets compressés:

x = [1, 2, 3]; y = ['a','b','c']
z = Zip(x, y)
z = list(z)
print(z)
>>> [(1, 'a'), (2, 'b'), (3, 'c')]

Ensuite, pour unzip revenir en arrière, il suffit de conjuguer l’itérateur compressé:

x_back, y_back = Zip(*z)
print(x_back); print(y_back)
>>> (1, 2, 3)
>>> ('a', 'b', 'c')

Si la forme originale de liste est nécessaire à la place de tuples:

x_back, y_back = Zip(*z)
print(list(x_back)); print(list(y_back))
>>> [1,2,3]
>>> ['a','b','c']
7
Hamidreza

Je ne pense pas que Zip renvoie une liste. Zip renvoie un générateur. Vous devez faire list(Zip(a, b)) pour obtenir une liste de n-uplets.

x = [1, 2, 3]
y = [4, 5, 6]
zipped = Zip(x, y)
list(zipped)
1
Ankur Kothari