4 Lists and tuples

This chapter introduces Python’s built-in sequence collections—lists and tuples—and focuses on how and when to use each. Lists are mutable and suited to sequences of similar items, while tuples are immutable and often used as lightweight records holding different kinds of data. Both are sequences, so they support iteration, membership tests, indexing, and slicing (with strings as the third sequence type). The discussion emphasizes practical selection between the two, noting that lists offer rich methods for modification and reordering, whereas tuples excel as fixed, structured containers.

A central theme is writing generic, type-agnostic code by exploiting the common sequence protocol. The chapter contrasts single-element indexing (which returns whatever is stored) with slicing (which always returns the same sequence type), enabling solutions that preserve input types. This idea powers an exercise that returns the first and last elements using slices, and another that reimplements a flexible summation via a variadic function that works for numbers, strings, lists, and tuples. Along the way, it reinforces Python’s dynamic typing and truthiness rules for empty sequences, shows how slices avoid index errors and enable concise sub-sequence processing, and highlights tools like range, list comprehensions, and function-passing idioms.

The chapter then applies these ideas to everyday tasks: sorting a list of dictionaries by a specific field with the key parameter to sorted, using either small inline functions or operator.itemgetter (including multi-key sorts); counting repeated letters in words with collections.Counter and selecting winners via max with a key function; and formatting tuple-based records into aligned, human-friendly columns with str.format and argument unpacking. It also briefly explains why Python lists aren’t fixed-size arrays, how they grow under the hood, and encourages readable, reusable solutions that compose core sequence operations with standard-library helpers.

Individual elements (from the Python Tutor)

Retrieving slices from a list (from the Python Tutor)

Retrieving slices from a tuple (from the Python Tutor)

Naive, incorrect adding of slices (from the Python Tutor)

Working solution (from the Python Tutor)

After assigning the first element to output (from the Python Tutor)

After adding elements to output (from the Python Tutor)

• Lists are mutable and tuples are immutable, but the real difference between them is how they’re used: lists are for sequences of the same type, and tuples are for records that contain different types.
• You can use the built-in sorted function to sort either lists or tuples. You’ll get a list back from your call to sorted.
• You can modify the sort order by passing a function to the key parameter. This function will be invoked once for each element in the sequence, and the output from the function will be used in ordering the elements.
• If you want to count the number of items contained in a sequence, try using the Counter class from the collections module. It not only lets us count things quickly and easily, and provides us with a most_common method, but also inherits from dict, giving us all of the dict functionality we know and love.

FAQ