Listy Zip w Pythonie

zip takes a bunch of list likes

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

I "zamyka" je w jedną listę, której wpisy są 3-krotkami (ai, bi, ci). Wyobraź sobie rysowanie zamka poziomo od lewej do prawej.

W Pythonie 2.7 to mogło zadziałać dobrze:

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

Ale w Pythonie 3.4 powinno być (w przeciwnym razie wynik będzie podobny <zip object at 0x00000256124E7DC8>):

>>> a = b = c = range(20)
>>> list(zip(a, b, c))

zip tworzy nową listę, wypełnioną krotkami zawierającymi elementy z argumentów iteracyjnych:

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

Spodziewam się, że spróbujesz stworzyć krotkę, w której każdy element jest listą.

Źródło: mój wpis na blogu (lepsze formatowanie)

Przykład

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

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

Input

Zero lub więcej iterabli [1] (ex. list, string, tuple, dictionary)

Output (list)

Pierwsza krotka = (element_1 liczb, element_1 liter)

Druga krotka = (liczby e_2, litery e_2)

…

N-ta krotka = (liczby e_n, litery e_n)

1. lista N krotki: n jest długością najkrótszego argumentu (wejście)
   • len(liczby) == 3
2. Długość każdej krotki = # args (krotka pobiera element z każdego arg)
   • args = (liczby, litery); len(args) = = 2 → krotka z 2 elementami
3. ith tuple = (element_i arg1, element_i arg2..., element_i arg n)

Edge Cases

1) Empty String: len (str)= 0 = brak krotek

2) pojedynczy ciąg znaków: len (str) == 2 krotki z len(args) = = 1 element(Y)

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

Zip w akcji!

1. Zbuduj słownik [2] z dwóch list

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]

• Jest eleganckim, przejrzystym i zwięzłym rozwiązaniem.]}

2. Drukowanie kolumn w tabeli

"*" [3] nazywa się "rozpakowywanie": 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')

Dodatkowy Kredyt: Rozpakowanie

zip(*args) nazywa się " rozpinanie" ponieważ ma efekt odwrotny 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: krotka_1 = e1 każdej krotki. tuple_2 = E2 każdego zipped

Przypisy

1. obiekt zdolny do zwracania swoich członków pojedynczo (ex. lista [1,2,3], string 'I like codin', tuple (1,2,3), dictionary {'a':1, 'b':2})
2. {key1: value1, key2: value2...}
3. "rozpakowywanie" (*)

* kod:

# 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

* taken numbers (1 arg) i "unpaked" its ' 2 elements into 2 args

W Python 3 zip zamiast tego zwraca iterator i musi zostać przekazany do funkcji list, aby uzyskać zipped krotki:

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

Następnie do unzip je z powrotem wystarczy podłączyć zipped iterator:

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

Jeśli potrzebna jest oryginalna forma listy zamiast krotek:

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

Zasadniczo funkcja zip działa na listach, krotkach i słownikach w Pythonie. Jeśli używasz IPython to po prostu wpisz zip? I sprawdź o co chodzi z zip ().

Dla list

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

Wyjście to [('a', 'p'), ('b', 'q'), ('c', 'r')

Dla słownika:

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

Wyjście To:

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

Dla kompletności.

Gdy długość listy nie jest równa. Długość listy wynikowej będzie Najkrótsza bez wystąpienia błędu

>>> a = [1]
>>> b = ["2", 3]
>>> zip(a,b)
[(1, '2')]

Warto dodać tutaj, ponieważ jest to tak wysoko oceniane pytanie na zip. zip jest świetnym, idiomatycznym Pythonem-ale nie skaluje się zbyt dobrze w przypadku dużych list.

Zamiast:

books = ['AAAAAAA', 'BAAAAAAA', ... , 'ZZZZZZZ']
words = [345, 567, ... , 672]

for book, word in zip(books, words):
   print('{}: {}'.format(book, word))

Użyj izip. W przypadku nowoczesnego przetwarzania przechowuje go w pamięci podręcznej L1 i jest znacznie bardziej wydajny dla większych list. Użyj go tak po prostu, jak dodanie i:

for book, word in izip(books, words):
   print('{}: {}'.format(book, word))

Myślę, że zip nie zwraca listy. zip zwraca generator. Musisz zrobić list(zip(a, b)), aby uzyskać listę krotek.

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