How to unzip a list of tuples into individual lists?

python

list-comprehension

map-function

zip-function

byAlex Kataev·Feb 22, 2025

To split a list of tuples into separate lists, you'd utilize the zip function in tandem with the unpacking operator *. This technique is showcased in a simple, runnable example below:

# List of tuples
tuples = [(1, 'a'), (2, 'b'), (3, 'c')]

# Let the unzipping magic begin
nums, chars = zip(*tuples)

# Quick check
print(nums)  # (1, 2, 3)
print(chars) # ('a', 'b', 'c')

This small script transforms a list of pairs into two discrete lists. The tuples are effectively unpacked using the * operator, and the indexed items are subsequently recombined using zip.

Unzipping into Lists and Generators

For more dynamic output formats, and to create mutable list objects, you can bring map() or list comprehension into the fold along with zip():

# List of tuples
tuples = [(1, 'a'), (2, 'b'), (3, 'c')]  # We love consistency, don't we?

# Using map for zip and list, like peas and carrots!
nums, chars = map(list, zip(*tuples))

# Or, if you're a 'list comprehension' kind of Pythonista:
nums, chars = [list(t) for t in zip(*tuples)]

# Quick check
print(nums)  # [1, 2, 3]
print(chars) # ['a', 'b', 'c']

Use list comprehension for ready-to-go lists or map(list, zip(*tuples)) to generate a generator of lists, the latter proving more memory-efficient for large datasets.

Adapting for Different Tuple Structures

Handling tuples of varying lengths

The zip(*l) function can truncate to the shortest tuple's length if your list has tuples of varying lengths. Use itertools.zip_longest to fill empty spots:

from itertools import zip_longest

tuples = [(1, 'a'), (2, 'b', 'extra'), (3,)]  # This one can't handle peer pressure

nums, chars = zip_longest(*tuples, fillvalue=None)  # None shall pass!

print(list(nums))  # [1, 2, 3]
print(list(chars)) # ['a', 'b', None]  # Well, None has passed here...

For large datasets

For large datasets, the map() function teamed with generators will do a better job at memory management. Generators create items one by one, reducing the need for extensive memory.

Wrapper function for error handling

Ensure to validate your input to avoid a dead silent zip(*l) if given an empty list. As they say "We've updated our privacy policy" , we should update our error handling:

def safe_unzip(tuples):
    # Check for empty list
    if not tuples: return []
    # Unzip
    return zip(*tuples)

Practical usage of unzip and zip in real-world scenarios

Processing CSV data

The zip(*l) function is a life-saver when dealing with CSV data. Transpose rows into columns for more efficient data processing:

import csv

# Open the CSV file
with open('data.csv', 'r') as f:
    # Use csv.reader to do the heavy lifting
    reader = csv.reader(f)
    # Time to transpose the rows with that zip swag
    columns = zip(*reader)

# Now `columns` has each column as a tuple - like peas in a pod!

Plotting with matplotlib

In data visualization tasks with Matplotlib, unbundling data into x and y coordinates can be extremely handy:

import matplotlib.pyplot as plt

# We have a list of (x, y) tuples
points = [(1, 5), (3, 7), (4, 9)]  # Trifecta of points!

# Unzip those points like a new pair of boots
x, y = zip(*points)

# Plot and show off
plt.scatter(x, y)
plt.show()

Parallel computation with multiprocessing

During parallel data processing, unzipping can be instrumental in efficiently distributing data among worker functions.

from multiprocessing import Pool

# Tuples to be thrown to worker functions—like a boss
work_data = [('data1', 'opt1'), ('data2', 'opt2')]

def worker(input_data, option):  # The worker bee function
    # Process data
    pass

# Unzip work_data because we love neatness 
inputs, options = zip(*work_data)

# Get to work
with Pool() as pool:
    results = pool.starmap(worker, zip(inputs, options))