Working with Dictionaries: Keys and Values

A Choice with Consequences

When Python needs to hold several related values, lists and tuples are both possible choices. The important difference is what happens after the collection is created. A list can be changed, while a tuple cannot be changed. That difference can make a list convenient for one task and risky for another.

Tracing a Mutation

tasks = ["read", "write"]
tasks.append("review")
print(tasks)

["read", "write", "review"]

The list has changed because the task required a collection that could grow. This is a useful form of mutability: a program can accumulate results, build a collection of inputs, filter data, or sort a collection in place.

Mutable Lists and Immutable Tuples

Mutability means that a collection can be changed after creation. Lists are mutable: their elements can be added, removed, or changed. Tuples are immutable: once created, their contents cannot be modified. Python therefore permits a modification operation on a list but stops a corresponding operation on a tuple with an error.

items = ["draft", "review"]
items[0] = "published"

fixed_items = ("draft", "review")
# Attempting fixed_items[0] = "published" produces an error

The different outcomes are intentional. A list is appropriate when later updates are part of the task. A tuple is appropriate when the values should remain fixed, because immutability prevents later modification rather than allowing it silently.

Three Reasons to Reach for a Tuple

Tuples are especially useful in three situations. First, dictionaries require immutable keys, so a tuple can be used as a key while a mutable list cannot. Second, tuples provide cleaner syntax when a function returns multiple values. Third, passing a tuple to a function guarantees that the function cannot modify the original tuple data, which helps prevent aliasing bugs.

locations = {
    ("north", 10): "warehouse"
}


def get_position():
    return (4, 7)


position = get_position()

In the first example, the tuple groups related values into one dictionary key. In the second, the function returns two related values together using tuple syntax. These are not merely stylistic alternatives to lists: immutability provides a specific guarantee in each case.

Choosing Under Constraints

1. Ask whether the collection must be updated after creation.
2. If items must be added, removed, or changed, choose a list.
3. If changes must be prevented, consider a tuple.
4. If the values must form a dictionary key, choose a tuple.
5. If a function returns several related values or must receive protected sequence data, consider a tuple.

Mistakes in Type Selection

• Using a tuple for a collection that must grow during a loop.

  The task requires adding items, but tuples are immutable.

  Fix: Use a list for a collection that must be built or updated.

• Using a list when the values must be a dictionary key.

  Dictionary keys must be immutable.

  Fix: Represent the fixed pair as a tuple.

• Choosing a list simply because it is familiar.

  A mutable collection does not communicate or guarantee that the data is protected from modification.

  Fix: Use a tuple when preventing modification is part of the task.

• Treating mutability as universally beneficial.

  Unwanted changes can create harder-to-debug problems.

  Fix: Treat immutability as a deliberate protection when the data should not change.

Decision Practice

The Deliberate Choice

1. Lists are mutable and are the default choice for most tasks because they can grow, shrink, and change.
2. Tuples are immutable, so they are useful when data must remain fixed.
3. Use tuples as dictionary keys because dictionary keys must be immutable.
4. Tuples provide cleaner syntax for returning multiple values from a function.
5. Passing a tuple can prevent a function from modifying the original data and help avoid aliasing bugs.