Python List of Tuples: Guide & Examples

A list of tuples is a powerful Python data structure. It combines the flexibility of lists with the immutability of tuples.

This structure is ideal for storing rows of data. Each tuple can represent a record, like a student's name and grade.

What is a List of Tuples?

A list is a mutable, ordered collection. A tuple is an immutable, ordered collection. A list of tuples is simply a list where each element is a tuple.

This hybrid structure is common in real-world programming. It is often used to handle data from databases or CSV files.

For a deeper dive into the core concepts, see our guide on Python Tuples: Immutable Data Structures Explained.

Creating a List of Tuples

You can create a list of tuples in several ways. The simplest is to define it directly.

# Method 1: Direct definition
student_grades = [("Alice", 92), ("Bob", 85), ("Charlie", 78)]
print(student_grades)
    

[('Alice', 92), ('Bob', 85), ('Charlie', 78)]
    

You can also create it using the list() and tuple() functions. Or build it dynamically in a loop.

# Method 2: Using list() and tuple()
coordinates = list([tuple([1, 2]), tuple([3, 4])])
print(coordinates)

# Method 3: Building with a loop
data_points = []
for i in range(3):
    data_points.append((i, i**2))  # Tuple of (index, square)
print(data_points)
    

[(1, 2), (3, 4)]
[(0, 0), (1, 1), (2, 4)]
    

Accessing Elements

Accessing data uses double indexing. First, select the tuple from the list. Then, select the item from the tuple.

# Our list of tuples
inventory = [("apple", 50), ("banana", 30), ("orange", 25)]

# Access the first tuple
first_item = inventory[0]
print(f"First tuple: {first_item}")

# Access the quantity from the second tuple (index 1, element 1)
banana_quantity = inventory[1][1]
print(f"Banana quantity: {banana_quantity}")
    

First tuple: ('apple', 50)
Banana quantity: 30
    

You can also use unpacking in a loop. This is a clean way to work with each tuple's elements.

for product, count in inventory:
    print(f"Product: {product}, Stock: {count}")
    

Product: apple, Stock: 50
Product: banana, Stock: 30
Product: orange, Stock: 25
    

Modifying a List of Tuples

Remember, tuples are immutable. You cannot change a tuple's content directly. However, the list itself is mutable.

You can replace an entire tuple, add new ones, or remove them. This is a key distinction from a list of lists.

# Starting list
records = [("a", 1), ("b", 2)]

# 1. Replace a tuple (You cannot change ("a",1) but you can replace it)
records[0] = ("a", 99)
print(f"After replacement: {records}")

# 2. Append a new tuple
records.append(("c", 3))
print(f"After append: {records}")

# 3. Remove a tuple
records.remove(("b", 2))
print(f"After removal: {records}")
    

After replacement: [('a', 99), ('b', 2)]
After append: [('a', 99), ('b', 2), ('c', 3)]
After removal: [('a', 99), ('c', 3)]
    

To understand more about how tuples differ from lists in this regard, check out Python Tuple vs List: Key Differences Explained.

Common Operations and Sorting

Python provides built-in functions for lists and tuples. You can sort, find the length, and check for membership.

Sorting is a very common task. You can sort a list of tuples based on any element in the tuple.

# List of (name, score) tuples
players = [("Sara", 1200), ("John", 1500), ("Mike", 1100)]

# Sort by the second element (score) - ascending
players.sort(key=lambda x: x[1])
print(f"Sorted by score (low to high): {players}")

# Sort by the first element (name) - descending
players.sort(key=lambda x: x[0], reverse=True)
print(f"Sorted by name (Z to A): {players}")

# Using sorted() for a new list without modifying the original
by_score = sorted(players, key=lambda x: x[1])
print(f"New sorted list: {by_score}")
print(f"Original list unchanged: {players}")
    

Sorted by score (low to high): [('Mike', 1100), ('Sara', 1200), ('John', 1500)]
Sorted by name (Z to A): [('Sara', 1200), ('Mike', 1100), ('John', 1500)]
New sorted list: [('Mike', 1100), ('Sara', 1200), ('John', 1500)]
Original list unchanged: [('Sara', 1200), ('Mike', 1100), ('John', 1500)]
    

For more on combining and working with tuples, see Python Tuple Operations and Concatenation Guide.

Practical Use Cases

Lists of tuples are incredibly useful. They appear in many areas of Python development.

Data Tables: Represent rows from a database or spreadsheet. Each tuple is a row, each item in the tuple is a column value.

Coordinate Pairs: Store (x, y) coordinates for graphics or game development.

Function Return Values: Functions can return multiple related values as a tuple. Collecting results from multiple calls into a list is efficient.

# Simulating multiple function returns
def get_user_data(id):
    # Simulate a database fetch
    fake_db = {1: ("Alice", "NYC"), 2: ("Bob", "LA")}
    return fake_db.get(id, ("Unknown", "Unknown"))

# Collecting results in a list of tuples
all_users = []
for user_id in range(1, 4):
    all_users.append(get_user_data(user_id))

print("Collected user data:", all_users)
    

Collected user data: [('Alice', 'NYC'), ('Bob', 'LA'), ('Unknown', 'Unknown')]
    

Conclusion

A list of tuples is a fundamental and versatile Python structure. It provides a reliable way to group related, immutable data within a flexible container.

You now know how to create, access, and modify these structures. You also understand practical use cases like sorting and data collection.

Mastering this concept will improve your data handling skills. It is a stepping stone to more advanced topics like list comprehensions with tuples and working with structured data modules.