Python zip() Function

Spread the love

The zip() function in Python is a built-in function that aggregates elements from two or more iterables (like lists, tuples, sets, etc.) and returns an iterator of tuples. Each tuple contains the elements from each iterable that are at the same position. This function can be extremely useful for parallel iteration over multiple sequences in a concise and readable way.


The basic syntax of the zip() function is as follows:



*iterables – two or more iterables (e.g., lists, tuples, sets, etc.) of equal or different lengths.

Return Value:

It returns an iterator from two or more iterators.

Python zip() with lists

The zip() function in Python is often used with lists to perform parallel iterations, which means iterating over two or more lists in a single loop. When you zip lists together, zip() pairs up the corresponding elements from each list and returns an iterator of tuples. Each tuple consists of one element from each of the lists, matched by their index.

Basic Example of zip( ) with Lists

Here is a simple example:

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
zipped = zip(list1, list2)
zipped_list = list(zipped)  # Convert to a list of tuples
print(zipped_list)  # Output: [(1, 'a'), (2, 'b'), (3, 'c')]

In the example above, list1 and list2 are combined into a list of tuples, where the first element of each tuple is from list1 and the second is from list2.

Handling Lists of Different Lengths

When using zip() with lists of different lengths, zip() stops when the shortest list is exhausted. For example:

list1 = [1, 2, 3, 4]
list2 = ['a', 'b', 'c']
zipped = zip(list1, list2)
zipped_list = list(zipped)
print(zipped_list)  # Output: [(1, 'a'), (2, 'b'), (3, 'c')]

Notice that the last element of list1 (4) does not appear in the output because list2 does not have a corresponding fourth element.

Using zip( ) in Loops

One of the most common use cases for zip() is iterating over multiple lists in a loop:

for number, letter in zip(list1, list2):
    print(f'Number: {number}, Letter: {letter}')

This code would print:

Number: 1, Letter: a
Number: 2, Letter: b
Number: 3, Letter: c

This approach is much cleaner than using indices to access elements in each list.

Unzipping Lists

You can also “unzip” lists. This is done by passing a zipped list to zip() with the * operator, which unpacks the list:

zipped_list = [(1, 'a'), (2, 'b'), (3, 'c')]
numbers, letters = zip(*zipped_list)
print(list(numbers))  # Output: [1, 2, 3]
print(list(letters))  # Output: ['a', 'b', 'c']

Here, the zipped list of tuples is separated back into two lists, effectively reversing the zipping process.

Nested zip( )

You can use zip() in nested structures to perform more complex operations:

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
list3 = [0.1, 0.2, 0.3]
zipped = zip(list1, zip(list2, list3))
zipped_list = list(zipped)
print(zipped_list)  # Output: [(1, ('a', 0.1)), (2, ('b', 0.2)), (3, ('c', 0.3))]

In this nested zip, the second element of each tuple is itself a tuple.

Practical Use Cases

  • Simultaneous Iterations: zip() is handy when you need to iterate over multiple lists at the same time and perform actions that require elements from each list.
  • Data Structuring: When handling tabular data, zip() can transpose rows and columns, making it easy to reformat data without explicit loops.
  • Parallel Sorting: Lists can be sorted in parallel using zip(). First, you zip lists together, sort the zipped list, and then unzip them.

Python zip() with enumerate

The zip() function in Python is often used in conjunction with enumerate() when you need to iterate over multiple sequences and also keep track of the index within the loop. Combining zip() and enumerate() is a powerful technique for accessing elements from multiple iterables (like lists or tuples) simultaneously while also keeping an index counter.

The enumerate( ) Function

Before diving into the combined use, let’s recap what enumerate() does. enumerate() is a built-in function that takes an iterable and returns an iterator that produces tuples of an index and the value from the iterable:

for index, value in enumerate(['a', 'b', 'c']):
    print(index, value)

This would output:

0 a
1 b
2 c

Combining zip( ) and enumerate( )

When you combine zip() and enumerate(), you can iterate over two or more sequences and have an automatic counter that tells you the current position in the loop:

list1 = ['a', 'b', 'c']
list2 = [1, 2, 3]

for index, (item1, item2) in enumerate(zip(list1, list2)):
    print(f'Index: {index}, List1 item: {item1}, List2 item: {item2}')

This would output:

Index: 0, List1 item: a, List2 item: 1
Index: 1, List1 item: b, List2 item: 2
Index: 2, List1 item: c, List2 item: 3

In the combined use of enumerate(zip(list1, list2)), zip() pairs the corresponding elements from list1 and list2 into tuples, and enumerate() provides the current index with each pair.

Python zip() with Dictionary

The zip() function in Python is versatile and can be used with various data structures, including dictionaries. When working with dictionaries, zip() can be particularly useful for creating dictionaries or iterating over them in a way that involves their keys and values simultaneously.

Creating Dictionaries with zip( )

One common use of zip() with dictionaries is to combine two lists or tuples into a single dictionary. Here’s an example:

keys = ['name', 'age', 'gender']
values = ['Alice', 30, 'Female']

# Create a dictionary by zipping keys and values together
person_info = dict(zip(keys, values))
print(person_info)  # Output: {'name': 'Alice', 'age': 30, 'gender': 'Female'}

In this example, zip() pairs up ‘name’ with ‘Alice’, ‘age’ with 30, and ‘gender’ with ‘Female’ to form key-value pairs, which dict() then turns into a dictionary.

Iterating Over a Dictionary with zip( )

When iterating over a dictionary, you might only have access to keys or values at one time. However, if you have two dictionaries with the same keys, you can use zip() to iterate over them in parallel:

dict1 = {'name': 'Alice', 'age': 30, 'gender': 'Female'}
dict2 = {'name': 'Bob', 'age': 25, 'gender': 'Male'}

for (k1, v1), (k2, v2) in zip(dict1.items(), dict2.items()):
    print(f"{k1}: {v1}, {k2}: {v2}")

This would output:

name: Alice, name: Bob
age: 30, age: 25
gender: Female, gender: Male

Here, dict1.items() and dict2.items() create a view object of key-value pairs, which zip() then combines into tuples. This allows you to iterate through both dictionaries at the same time, assuming they have the same structure and keys.

Zipping Dictionary Keys and Values Separately

You can also zip the keys and values of a dictionary separately if you need to switch their places or if you need to manipulate them in parallel:

my_dict = {'name': 'Alice', 'age': 30, 'gender': 'Female'}

# Zipping keys and values separately
keys = my_dict.keys()
values = my_dict.values()

zipped_keys_values = zip(keys, values)
print(list(zipped_keys_values))  # Output: [('name', 'Alice'), ('age', 30), ('gender', 'Female')]

This zipping is helpful when you want to manipulate dictionary entries before creating a new dictionary from them.

Inverting a Dictionary Using zip( )

If you want to invert a dictionary (make keys become values and values become keys), and the dictionary values are unique, you can use zip():

my_dict = {'name': 'Alice', 'age': 30, 'gender': 'Female'}

# Inverting the dictionary
inverted_dict = dict(zip(my_dict.values(), my_dict.keys()))
print(inverted_dict)  # Output: {'Alice': 'name', 30: 'age', 'Female': 'gender'}

This is done by zipping the values with the keys and then converting the zipped tuples back into a dictionary.

Python zip() with Tuple

The zip() function in Python can be seamlessly used with tuples, just as with lists. Since tuples are ordered collections of items, zip() can combine tuples by taking corresponding elements from each tuple and forming new tuples. This can be particularly handy when you have related data in separate tuples and you need to process them together.

Basic Usage of zip( ) with Tuples

Let’s start with a simple example:

tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')
zipped = zip(tuple1, tuple2)
zipped_list = list(zipped)  # Convert to a list of tuples
print(zipped_list)  # Output: [(1, 'a'), (2, 'b'), (3, 'c')]

In this example, tuple1 and tuple2 are passed to zip(), which returns an iterator that, when converted to a list, shows pairs of combined elements from both tuples.

Working with Tuples of Different Lengths

Similar to lists, when the tuples passed to zip() are of different lengths, zip() stops combining elements when the shortest tuple is exhausted:

tuple1 = (1, 2, 3, 4)
tuple2 = ('a', 'b', 'c')
zipped = zip(tuple1, tuple2)
print(list(zipped))  # Output: [(1, 'a'), (2, 'b'), (3, 'c')]

Here, the element 4 from tuple1 is not included in the result because there is no corresponding element in tuple2.

Iterating Over Zipped Tuples

You can iterate over the zipped object directly without converting it to a list first:

for num, letter in zip(tuple1, tuple2):
    print(f'Number: {num}, Letter: {letter}')

This will print:

Number: 1, Letter: a
Number: 2, Letter: b
Number: 3, Letter: c

Using zip( ) in Conjunction with * Operator

The * operator can be used to unzip a sequence, which is effectively the opposite of zip():

zipped_tuples = zip(tuple1, tuple2)
unzipped_tuples = zip(*zipped_tuples)
tuple1_unzipped, tuple2_unzipped = list(unzipped_tuples)  # Convert each to a tuple
print(tuple1_unzipped)  # Output: (1, 2, 3)
print(tuple2_unzipped)  # Output: ('a', 'b', 'c')

Here, zip(*zipped_tuples) unzips the zipped tuples back into separate sequences.

Advanced Usage – Zipping More Than Two Tuples

zip() is not limited to two iterables; you can zip together as many iterables as you need:

tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')
tuple3 = (0.1, 0.2, 0.3)

zipped = zip(tuple1, tuple2, tuple3)
print(list(zipped))  # Output: [(1, 'a', 0.1), (2, 'b', 0.2), (3, 'c', 0.3)]

The zip_longest( ) Function from itertools

For cases where you need to zip iterables of different lengths without truncation, you can use itertools.zip_longest():

from itertools import zip_longest

numbers = [1, 2, 3]
letters = ['a', 'b']
zipped_longest = zip_longest(numbers, letters, fillvalue=None)
print(list(zipped_longest))  # Output: [(1, 'a'), (2, 'b'), (3, None)]

Here, zip_longest() fills in the missing values with None or any other specified fillvalue.


The zip() function is an elegant tool in Python that allows for the combination of multiple iterables into a single iterator of tuples, facilitating parallel iteration and complex data manipulations with minimal code. It promotes writing cleaner and more Pythonic code and supports the ethos of simplicity and readability in Python programming. The function’s versatility, coupled with its memory-efficient design, makes it an invaluable feature for Python developers working with collections of data.

Leave a Reply