Функция zip() в Python, объединить элементы в список кортежей.

Объединяет элементы последовательностей в список кортежей.

Синтаксис:

zip(*iterables, strict=False)

Параметры:

• *iterables - последовательность аргументов или итераций.
• strict=False - отвечает за проверку длин переданных итераций. Доступен с версии Python 3.10.

Возвращаемое значение:

• итератор кортежей.

Описание:

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
...     print(item)

# (1, 'sugar')
# (2, 'spice')
# (3, 'everything nice')

1. По умолчанию функция zip() останавливается, когда исчерпывается самая короткая итерация. Она проигнорирует оставшиеся элементы в более длинных итерациях, обрезая результат до длины самой короткой итерации:

   >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
   # [(0, 'fee'), (1, 'fi'), (2, 'fo')]
   

2. Функция zip() часто используется в тех случаях, когда предполагается, что итерации имеют одинаковую длину. В таких случаях рекомендуется использовать параметр strict=True (доступен с версии Python 3.10). Вывод будет такой же, как и у обычного zip():

   >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
   # [('a', 1), ('b', 2), ('c', 3)]
   

   В отличие от поведения по умолчанию параметр strict=True (доступен с версии Python 3.10), проверяет идентичность длин итераций, вызывая ошибку ValueError, если они не совпадают:

   >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True))
   # Traceback (most recent call last):
   #   ...
   # ValueError: zip() argument 2 is longer than argument 1
   

   Без аргумента strict=True (доступен с версии Python 3.10), любая ошибка, приводящая к итерациям разной длины, будет заглушена, что может проявиться как трудно обнаруживаемая ошибка в другой части программы.
3. Более короткие итерации можно дополнить постоянным значением, чтобы все итерации имели одинаковую длину. Это делает itertools.zip_longest().

• Порядок оценки итераций слева направо гарантируется. Это делает возможной идиому для кластеризации ряда данных в группы длиной n с использованием zip(*[iter(s)]*n, strict=True). Это повторяет один и тот же итератор n раз, так что каждый выходной кортеж имеет результат n вызовов итератора. Это приводит к разделению входных данных на блоки длиной n.
• zip() в сочетании с оператором * можно использовать для распаковки списка:

  >>> x = [1, 2, 3]
  >>> y = [4, 5, 6]
  >>> list(zip(x, y))
  # [(1, 4), (2, 5), (3, 6)]
  >>> x2, y2 = zip(*zip(x, y))
  >>> x == list(x2) and y == list(y2)
  # True
  

Как и где можно использовать функцию zip()

• Распаковка списка кортежей на отдельные списки;
• Сортировка нескольких связанных между собой списков;
• Функция zip() в циклах for/in;
• Создание словаря из двух списков;

Распаковка списка кортежей на отдельные списки.

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
# объединим два списка 
>>> zipped = zip(x, y)
>>> list(zipped)
# [(1, 4), (2, 5), (3, 6)]

# распакуем полученный список кортежей
>>> x2, y2 = zip(*zipped)
# сравниваем полученные списки
# с их исходными значениями
>>> list(x2) == x and list(y2) == y
# True

Сортировка нескольких связанных между собой списков.

>>> from random import shuffle
# приготовим первый список
>>> x = list(range(6))
# перемешаем его
>>> shuffle(x)
# приготовим второй список
>>> y = list(range(6))
# третий список пусть будет перевернутый `y` 
>>> z = list(reversed(y))
# распечатаем для наглядности
>>> print(f'x: {x}\ny: {y}\nz: {z}')
# x: [3, 5, 2, 1, 4, 0], 
# y: [0, 1, 2, 3, 4, 5], 
# z: [5, 4, 3, 2, 1, 0])

# сортируем по первому списку `x`
>>> x, y, z = zip(*sorted(zip(x, y, z), key=lambda tpl: tpl[0]))
>>> print(f'{list(x)}\n{list(y)}\n{list(z)}')
# [0, 1, 2, 3, 4, 5]
# [5, 3, 2, 0, 4, 1]
# [0, 2, 3, 5, 1, 4]

# теперь сортируем по последнему списку `z`
# обратите внимание, что меняется только 
# аргумент `key` в функции `sorted()`
>>> x, y, z = zip(*sorted(zip(x, y, z), key=lambda tpl: tpl[2]))
>>> print(f'{list(x)}\n{list(y)}\n{list(z)}')
# [0, 4, 1, 2, 5, 3]
# [5, 4, 3, 2, 1, 0]
# [0, 1, 2, 3, 4, 5]

Функция zip() в циклах for/in.

for i in range(len(list1))
    a, b, c = list1[i], list2[i], list3[i]

# или

for i, a in enumerate(list1)
    b, c = list2[i], list3[i]

>>> lst1 = [0, 1, 2, 3, 4, 5]
>>> lst2 = [5, 3, 2, 0, 4, 1]
>>> lst3 = ['zero', 'one', 'two', 'three', 'four', 'five']
>>> for a, b, c in zip(lst1, lst2, lst3):
...     print(f'{c}:\t{a} + {b} = {a + b}')
...
# zero:   0 + 5 = 5
# one:    1 + 3 = 4
# two:    2 + 2 = 4
# three:  3 + 0 = 3
# four:   4 + 4 = 8
# five:   5 + 1 = 6

Создание словаря из двух списков.

>>> lst1 = [0, 1, 2, 3, 4, 5]
>>> lst2 = ['zero', 'one', 'two', 'three', 'four', 'five']
# создаем словарь при помощи `dict()`
>>> dict(zip(lst1, lst2))
# {0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}

# создаем словарь при помощи выражения генератора 
# словаря, при этом меняем элементы списков местами
>>> d = {y: x for x, y in zip(lst1, lst2)}
>>> d
# {'zero': 0, 'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}