We’ve now been introduced to two of Python’s sequence types: the mutable list (Post #46) and the immutable tuple (Post #58). They seem very similar—both are ordered collections that can hold various data types. This often leads to a common question for new programmers: which one should I use, and when?
This post is a practical guide to help you make that decision. We’ll recap their key difference and provide clear guidelines and use cases for each.
The Core Difference: Mutability
The decision almost always comes down to one fundamental concept we discussed in Post #49: mutability.
- Lists are mutable: You can add, remove, and change items in a list after it has been created. They are dynamic and designed to be modified.
- Tuples are immutable: Tuples are unchangeable. Once created, their contents are locked in. They are static and designed to guarantee data integrity.
This single difference in design philosophy dictates when you should use one over the other.
When to Use a List
You should use a list when you have a collection of items that you expect to grow, shrink, or change over the course of your program’s execution.
Think of a shopping cart, a list of users currently logged into a website, or the tasks in our to-do list project from Post #57. These are all dynamic collections where the number of items and the items themselves are not fixed.
Conventionally, lists are often used to store a collection of similar items (a list of numbers, a list of names, etc.), but this is not a strict rule.
# A list of scores that will grow as players play the game
high_scores = [100, 95, 80]
# We expect to add more scores later
high_scores.append(105) When to Use a Tuple
You should use a tuple when you have a collection of values that represents a single, fixed record or entity. The data is a constant and is not meant to be changed.
Think of an (x, y) coordinate pair like (10, 20), an RGB color value like (255, 0, 0), or a person’s fixed record like ('Alice', 30). In these cases, it wouldn’t make sense to add a ‘z’ value to the 2D coordinate or remove the ‘green’ value from the RGB color. The structure is fixed.
As we saw in Post #61, returning multiple values from a function is a perfect use case for a tuple, as you are returning a single, fixed package of data.
# A tuple representing a fixed point in 2D space
start_position = (0, 0)
# It would be an error to try and change this coordinate
# start_position[0] = 5 # This would cause a TypeErrorConventionally, tuples are often used to store a collection of different types of data that, together, describe one thing.
A Simple Rule of Thumb
When you’re starting a new project and need to choose, ask yourself this simple question:
“Will the size or content of this collection need to change while my program is running?”
- If the answer is YES, use a List.
- If the answer is NO, use a Tuple.
What’s Next?
Choosing between a list and a tuple is a matter of communicating your intent. Using a list says, “This is a dynamic collection that can change.” Using a tuple says, “This is a fixed piece of data that should not be changed.” Making the right choice will make your code safer and more readable.
We’ve established that tuples are great for data integrity. But what are the other practical benefits of using an immutable collection? In Post #63, we’ll take a closer look at tuples in action and discuss how their immutability can also lead to performance benefits.
Author
Experienced Cloud & DevOps Engineer with hands-on experience in AWS, GCP, Terraform, Ansible, ELK, Docker, Git, GitLab, Python, PowerShell, Shell, and theoretical knowledge on Azure, Kubernetes & Jenkins. In my free time, I write blogs on ckdbtech.com