Lists and Tuples

Why Multiple Values Need a Home

Imagine you need to store a shopping list, a sequence of measurements, or a collection of names. You could create separate variables for each item, but that quickly becomes unwieldy. Python provides built-in data structures designed to hold multiple objects together. The two most fundamental of these are lists and tuples. While they seem similar on the surface, they have a crucial difference that makes each one suited to different tasks.

What Lists and Tuples Are

A list is an ordered collection of items enclosed in square brackets, where each item can be of any type. A tuple is also an ordered collection of items, but it is enclosed in parentheses. Both structures allow you to store multiple objects and access them by their position. The critical distinction is that lists are mutable—you can change, add, or remove items after creation—while tuples are immutable, meaning once created, they cannot be modified.

How Indexing Locates Elements

Both lists and tuples use the same indexing mechanism to access individual elements. You specify the item's position within square brackets using zero-based indexing, meaning the first item is at position 0, the second at position 1, and so on. This works identically for lists and tuples, so the syntax and logic are the same regardless of which structure you are using.

In the diagram above, the list animals contains four items. To access the third item (bird), you would use animals[2]. The index always refers to the position in the sequence, starting from zero. This same principle applies to tuples.

Nested Structures: Lists and Tuples Within Lists and Tuples

A list within a list does not lose its identity—lists are not flattened. The same applies to a tuple within a tuple, or a tuple within a list, or a list within a tuple. As far as Python is concerned, they are just objects stored using another object. When you nest structures, you can access deeply nested items by chaining index operations.

To access the third item in the third item of the new_zoo tuple, you would specify new_zoo[2][2]. This chaining of index operations works because each index operation returns the object at that position, and if that object is itself a list or tuple, you can index into it again.

The Mutability Divide: Lists vs. Tuples in Action

The most important practical difference between lists and tuples is mutability. Let's trace through what happens when you try to modify each one.

When to Use Lists and When to Use Tuples

Use a list when you need a collection that may change—when you might add, remove, or modify items. Lists are flexible and provide many built-in methods for manipulation. Use a tuple when you want to ensure that a collection of items remains constant. Tuples are also useful as dictionary keys (lists cannot be keys) and are slightly more memory-efficient than lists.

• Use lists for shopping lists, to-do items, or any collection that grows or shrinks
• Use tuples for fixed data like coordinates (x, y), RGB color values, or function return values that should not be accidentally modified
• Use tuples as dictionary keys when you need a composite key
• Use tuples when passing immutable collections to functions that should not modify the original data

Common Mistakes with Lists and Tuples

• Forgetting that indexing starts at zero

  Python uses zero-based indexing, so the first item is always at index 0, the second at index 1, and so on

  Fix: Remember: the index is always one less than the position. The first item is at index 0, the second at index 1, etc.

• Attempting to modify a tuple

  Tuples are immutable by design. Once created, their contents cannot be changed

  Fix: If you need to modify the collection, use a list instead. If you need a modified version of a tuple, create a new tuple

• Confusing the syntax for creating lists and tuples

  Lists use square brackets [] and tuples use parentheses (). Using the wrong syntax creates the wrong data type

  Fix: Remember: lists are [like this], tuples are (like this)

• Not understanding nested indexing

  Each index operation returns an element; if that element is itself a list or tuple, you can index into it again, but you must understand the structure

  Fix: Trace through the structure step by step: nested_list[2] gets the third item, then [1] gets the second item within that, then [0] gets the first item within that

Worked Example: Building and Accessing a Zoo Inventory

Understanding the Four Built-in Data Structures

Python provides four built-in data structures: lists, tuples, dictionaries, and sets. Each serves a different purpose. Lists and tuples are ordered collections accessed by position. Dictionaries are unordered collections accessed by key. Sets are unordered collections of unique items with no indexing. Understanding when to use each one is essential for writing efficient and clear code.

Practice: Working with Lists and Tuples

Key Takeaways

Lists and tuples are both ordered collections that allow you to store multiple items and access them by position using zero-based indexing. The fundamental difference is that lists are mutable—you can change, add, or remove items—while tuples are immutable and cannot be modified after creation. Both can contain nested structures, allowing you to build complex hierarchies of data. Understanding when to use each one—lists for dynamic collections and tuples for fixed, protected data—is essential for writing effective Python code. Remember that Python provides four built-in data structures in total: lists, tuples, dictionaries, and sets, each with its own purpose and use cases.