Skip to main content

How to Iterate Through Lists of Tuples in Python

Lists of tuples are a common data structure in Python, used to represent collections of related items.

This guide explores various methods for iterating through lists of tuples, covering basic looping, index access with enumerate(), tuple unpacking, and converting to dictionaries for specific use cases.

Basic Iteration with a for Loop​

The simplest way to iterate through a list of tuples is with a standard for loop:

my_list = [('a', 'one'), ('b', 'two'), ('c', 'three')]

for tup in my_list:    # Iterate over each *tuple*
    for item in tup:   # Iterate over each *item* in the tuple
        print(item)

Output:

a
one
b
two
c
three
  • The first loop will iterate through the list.
  • The inner loop iterates over the individual items within each tuple. This is useful if you need to process each element separately.

Iterating with Index Access (enumerate)​

If you need the index of each tuple within the list, use enumerate():

my_list = [('a', 'one'), ('b', 'two'), ('c', 'three')]

for index, tup in enumerate(my_list):
    print(index)  # Print the index of the tuple in the list
    print(tup[0]) # Access tuple elements by index
    print(tup[1])

Output:

0 a one
1 b two
2 c three
  • enumerate(my_list) returns an iterator that yields pairs of (index, tuple).
  • You can combine it with unpacking (see next section) or access the elements from each tuple with an index.

Iterating with Tuple Unpacking​

The most Pythonic and readable way to iterate when you need the individual elements of each tuple is to unpack the tuple directly in the for loop:

my_list = [('a', 'one'), ('b', 'two'), ('c', 'three')]

for first, second in my_list:  # Unpack each tuple
    print(first, second)

Output:

a one
b two
c three
  • for first, second in my_list:: Each tuple in my_list is unpacked into the variables first and second on each iteration. This is clear, concise, and efficient.

Handling Tuples of Varying Lengths​

If the tuples in your list have different lengths, direct unpacking will raise a ValueError. In this case, either use indexing, or you can use itertools.zip_longest (with caution, as it introduces None values if lists are of unequal length) or handle errors during unpacking:

list_of_lists = [
    ['tutorial', 1, 'a'],
    ['reference', 2, 'b'],
    ['com', 3, 'c', 'xyz', 123] # Different length
]

for sublist in list_of_lists:
    print(sublist[0], sublist[1], sublist[2]) # Access by Index

Output:

tutorial 1 a
reference 2 b
com 3 c
  • If there are nested sequences with various number of elements, and you need to access specific positions, it's safer and more readable to access the items with indexes.

Ignoring Specific Values During Unpacking​

Use the underscore _ to discard values you don't need during unpacking:

my_list = [('a', 'one'), ('b', 'two'), ('c', 'three')]

for first, _ in my_list:  # Ignore the second element
    print(first)

Output:

a
b
c
  • Underscore is a convention to indicate that a variable is not used.

Gathering multiple tuple elements​

You can store multiple tuple elements into a single variable:

my_list = [('a', 'one', 1), ('b', 'two', 2), ('c', 'three', 3)]
for first, *rest in my_list: # Store remaining items into the rest variable
    print(first, rest)

Output:

a ['one', 1]
b ['two', 2]
c ['three', 3]

Converting a List of Tuples to a Dictionary (and Iterating)​

If your list of tuples represents key-value pairs, you can convert it to a dictionary and then iterate:

my_list = [('a', 'one'), ('b', 'two'), ('c', 'three')]
my_dict = dict(my_list)  # Convert to a dictionary

print(my_dict) # Output: {'a': 'one', 'b': 'two', 'c': 'three'}

for key, value in my_dict.items(): # Iterate by key and value
    print(key, value)

Output:

a one
b two
c three
  • dict(my_list): This directly converts a list of two-item tuples into a dictionary.
  • my_dict.items(): This is the standard way to iterate over key-value pairs in a dictionary.

Table of Contents