What is the difference between "list" and "tuple" in Python?

Question

Jayant Kumar · Accepted Answer

Table of Contents
Introduction
In Python, both lists and tuples are used to store collections of items, but they have distinct characteristics that make them suitable for different use cases. The main difference between a list and a tuple lies in their mutability—lists are mutable, while tuples are immutable. This article explores the differences between lists and tuples in Python and offers practical examples to clarify their usage.
Key Differences Between List and Tuple
1. Mutability

List: A list is mutable, meaning you can change its content after its creation (e.g., adding, removing, or modifying elements).
Tuple: A tuple is immutable, which means that once it is created, you cannot change its elements.

Example:
# List (mutable)
my_list = [1, 2, 3]
my_list[1] = 5  # Modifying an element
print(my_list)  # Output: [1, 5, 3]

# Tuple (immutable)
my_tuple = (1, 2, 3)
my_tuple[1] = 5  # This will raise an error: TypeError: 'tuple' object does not support item assignment

2. Syntax

List: Lists are defined using square brackets [ ].
Tuple: Tuples are defined using parentheses ( ).

Example:
# List
my_list = [1, 2, 3, 4]

# Tuple
my_tuple = (1, 2, 3, 4)

3. Performance

List: Since lists are mutable, they have more overhead. Lists tend to be slightly slower than tuples for operations such as iteration and access.
Tuple: Tuples are faster than lists because they are immutable. Python optimizes for immutability by caching tuples, making them more efficient in certain scenarios.

Example:
import time

# List performance
start_time = time.time()
my_list = list(range(1000000))  # Creating a large list
end_time = time.time()
print("List creation time:", end_time - start_time)

# Tuple performance
start_time = time.time()
my_tuple = tuple(range(1000000))  # Creating a large tuple
end_time = time.time()
print("Tuple creation time:", end_time - start_time)

4. Use Cases

List: Lists are ideal for scenarios where you need to modify the collection during runtime. This includes operations like appending, deleting, or modifying elements.
Tuple: Tuples are best suited for read-only collections, where data integrity must be maintained. They are often used for returning multiple values from functions or storing fixed data.

Example:
# List for dynamic content
shopping_list = ["milk", "bread", "eggs"]
shopping_list.append("butter")
print(shopping_list)  # Output: ['milk', 'bread', 'eggs', 'butter']

# Tuple for fixed content
coordinates = (50.123, -5.567)
# coordinates[0] = 45  # This will raise an error: TypeError

Practical Examples
Example : Using a List for Dynamic Content
# Creating a list of favorite movies
favorite_movies = ["Inception", "The Matrix", "Interstellar"]
favorite_movies.append("Tenet")  # Adding a new movie
favorite_movies.remove("The Matrix")  # Removing a movie
print(favorite_movies)  # Output: ['Inception', 'Interstellar', 'Tenet']

Example : Using a Tuple for Fixed Data
# Using a tuple to store RGB color values (constant data)
rgb_color = (255, 0, 0)  # Red color in RGB format
print(rgb_color)  # Output: (255, 0, 0)

# Trying to modify the tuple will raise an error
# rgb_color[0] = 128  # TypeError: 'tuple' object does not support item assignment

Conclusion
In Python, lists and tuples are both used to store collections of items, but they differ in their mutability, syntax, and performance. Lists are mutable and allow modification of their elements, making them ideal for dynamic collections. Tuples, on the other hand, are immutable and provide faster performance, making them suitable for fixed data. By understanding these differences, you can choose the right data structure for your Python program based on your specific needs.

What is the difference between "list" and "tuple" in Python?

Similar Questions