Comparing and Sorting Data Structures

A Sequence That Locks Its Contents

Tuples look similar to lists because both are sequences whose elements are accessed by integer positions. The important difference is what happens after creation. A list is flexible: its items can be added, removed, or modified. A tuple is fixed: once it exists, its elements cannot be changed. This makes a tuple useful when a group of related values should stay together and should not be accidentally modified.

Think of a tuple as an ordered record whose positions are permanent. The order matters, and each value remains associated with its position. This fixed structure is useful for related data such as coordinates or RGB color values, where changing one part accidentally could create a bug.

Mapping Positions to Values

Tuple access follows the same integer-index idea used with lists. The bracket operator selects an element by position. Index 0 refers to the first element. Positive indices continue from the beginning, while index -1 refers to the last element. The index does not describe the value itself; it describes where that value appears in the ordered sequence.

What Immutability Prevents

After a tuple is created, its elements cannot be modified. The same constraint applies to changing the sequence by adding or removing elements. In contrast, lists are designed for situations where items need to be added, removed, or modified frequently.

Comparing Tuples by Order

Tuples support equality and ordering comparisons. Python compares tuples element by element from left to right. For equality, two tuples must have the same length and all corresponding elements must be equal. For ordering, Python compares the first elements. If those elements are equal, it moves to the second elements, continuing from left to right until the comparison is decided.

The same sequence supports other common operations as well. Tuples can be concatenated, repeated, checked for membership, and sliced. These operations work with the tuple sequence, while the immutability rule still prevents changing the existing tuple's elements.

Tuples as Dictionary Keys

A tuple's immutability makes it hashable. Because tuples are hashable, they can be used as dictionary keys. This allows a fixed sequence of values to identify a dictionary value. Lists do not have this capability among the sequence types discussed here.

Mistakes to Avoid

• Treating a tuple like a list that can be edited in place.

  Tuples are immutable, so their elements cannot be changed after creation.

  Fix: Choose a list when the sequence must change frequently. Choose a tuple when the contents should remain fixed.

• Forgetting that tuple access is position-based.

  Tuple elements are accessed using integer positions and the bracket operator.

  Fix: Count from index 0 for the first element, and use index -1 for the last element.

• Comparing only the final elements of two tuples.

  Tuple ordering comparisons proceed from left to right, and the first unequal position decides the ordering.

  Fix: Compare corresponding elements beginning with the first position.

• Using a list when a fixed sequence must be a dictionary key.

  Tuples are hashable because they are immutable; lists do not have this capability among the sequence types discussed here.

  Fix: Use a tuple when the sequence should act as a dictionary key.

Practice Check

Key Takeaways

1. Tuples are ordered sequences indexed by integers.
2. Index 0 selects the first element, and index -1 selects the last element.
3. Tuples are immutable, so their elements cannot be changed after creation.
4. Tuple comparisons proceed element by element from left to right.
5. Immutability makes tuples hashable and suitable as dictionary keys, while lists are better when sequence contents must change.