Tuples vs. Lists: How to Use Python's Immutable Data Types and What's the Difference?

In Python, lists and tuples are two commonly used data containers. They look similar but have significant differences in usage and characteristics. Today, we’ll explore their distinctions and scenarios to help you decide when to use a list versus a tuple.

一、What are lists and tuples?¶

Think of them as “containers” for storing multiple elements. For example, to record a class list or weekly weather data, you can use either container.

List: Defined with square brackets [], like a “dynamic shopping list”—you can add, delete, or modify elements at any time.
Tuple: Defined with parentheses (), like a “non-modifiable contract”—elements cannot be added, deleted, or modified after creation (unless they contain mutable elements).

二、How to create lists and tuples?¶

Creating a List¶

Enclose elements in square brackets with commas:

# Empty list
empty_list = []

# List with elements
fruits = ["Apple", "Banana", "Orange"]
numbers = [1, 2, 3, 4]
mixed = ["Python", 3.14, True]  # Lists can hold mixed types

Creating a Tuple¶

Enclose elements in parentheses with commas:

# Empty tuple (rarely used)
empty_tuple = ()

# Tuple with elements
days = ("Monday", "Tuesday", "Wednesday")
scores = (90, 85, 95)
mixed = ("Python", 3.14, True)  # Tuples can also hold mixed types

Note: If a tuple has only one element, add a trailing comma to avoid being interpreted as a regular variable:

single_list = [10]  # This is a list with element 10
single_tuple = (10)  # This is an integer, not a tuple!
single_tuple = (10,)  # This is a tuple with element 10

三、Core Difference: Mutable vs. Immutable¶

The most fundamental distinction:
- List is Mutable: Elements can be modified (added, deleted, replaced) after creation.
- Tuple is Immutable: Elements cannot be directly modified, added, or deleted (unless they contain mutable elements, but the structure remains fixed).

Mutable Operations on Lists (Examples)¶

Lists support various modification operations:

# 1. Modify elements
fruits = ["Apple", "Banana", "Orange"]
fruits[0] = "Strawberry"  # Change the first element
print(fruits)  # Output: ['Strawberry', 'Banana', 'Orange']

# 2. Add elements (append)
fruits.append("Grape")  # Add to the end
print(fruits)  # Output: ['Strawberry', 'Banana', 'Orange', 'Grape']

# 3. Delete elements (pop)
fruits.pop(1)  # Remove the element at index 1 (Banana)
print(fruits)  # Output: ['Strawberry', 'Orange', 'Grape']

Immutable Operations on Tuples (Examples)¶

Attempting to modify a tuple like a list will throw an error:

# 1. Modify elements (error!)
days = ("Monday", "Tuesday", "Wednesday")
days[0] = "Sunday"  # Error: 'tuple' object does not support item assignment

# 2. Add elements (error!)
scores = (90, 85, 95)
scores.append(100)  # Error: 'tuple' object has no attribute 'append'

# 3. Delete elements (error!)
scores.pop(0)  # Error: 'tuple' object has no attribute 'pop'

Exception: If a tuple contains a list (mutable element), you can modify that list:

t = (1, [2, 3], 4)
t[1].append(5)  # Modify the list element inside the tuple
print(t)  # Output: (1, [2, 3, 5], 4)

However, this only modifies the content of the internal mutable element—not the tuple’s structure (position/quantity of elements remains unchanged).

四、When to Use List vs. Tuple?¶

When to Use a List:¶

Data that needs frequent modification (e.g., student scores, shopping lists, to-do items).
Data with an unpredictable length (dynamic addition/deletion of elements).

Example:

# Student score sheet (frequently updated)
scores = [90, 85, 95]
scores.append(88)  # Add new score
scores[1] = 80      # Update second student's score

When to Use a Tuple:¶

Data that is fixed after creation (e.g., weekly dates, configuration info, constants).
Data requiring “read-only” protection (prevent accidental modification, e.g., system config).
Tuples as dictionary keys (lists are unhashable; tuples are hashable).