6 Python Collections

Choosing the right collection

Python collections group multiple values so that a program can store, retrieve, and process related data. The main built-in choices differ in order, mutability, uniqueness, and lookup style.

• Choose a list when order matters and the contents may change.

• Choose a tuple for a fixed group of related values.

• Choose a dictionary when values should be found through meaningful keys.

• Choose a set when unique values and membership tests matter more than position.

A useful first question is whether the program needs positional access, key-based access, or uniqueness. A second question is whether the collection itself must change after creation.

Takeaway: Select the collection based on the behavior the data needs, not merely on the number of values it contains.

Lists and concise transformations

A list preserves the order in which its elements are stored and can be changed after creation. Common operations add one item, add several items, insert before a position, remove a matching value, remove and return an item, sort the values, reverse the order, and count the elements.

The in operator tests whether a value is present. Removing a value that is absent raises ValueError, while removing an item from an invalid position or an empty list with pop() raises IndexError.

A list comprehension is a concise way to transform or filter an iterable. For example, squares = [n * n for n in range(1, 6)] produces the squares of the integers from $1$ through $5$. A regular loop is clearer when the logic is complex or requires several statements.

Takeaway: Lists are flexible ordered containers; use their methods for direct changes and comprehensions for simple transformations.

Tuples, positions, and unpacking

A tuple is ordered like a list but cannot have its own elements replaced or deleted. Commas create tuples, so a one-item tuple needs a trailing comma, as in (42,); (42) is just a parenthesized value.

Tuples are useful for fixed structures such as a point or a record. Unpacking assigns tuple elements to separate variables, and extended unpacking can collect several middle elements into a list. A tuple can contain a mutable object, such as a list; the tuple's position remains fixed, but the inner list can still change.

Zero-based indexing applies to both lists and tuples. The first item is at index $0$, and a negative index counts from the end, so -1 identifies the last item. Assigning through an index is valid for a list but raises TypeError for a tuple.

Takeaway: Use a tuple when the structure should remain fixed, and a list when its elements need to be reassigned or resized.

Slicing, copying, and references

Slicing selects a range from a sequence with start:stop:step. The start position is included and the stop position is excluded. For example, numbers[1:4] selects the elements at positions $1$, $2$, and $3$; omitted boundaries select from the beginning or through the end, and a negative step can reverse a sequence.

For lists, a slice creates a new outer list. This is a shallow copy, so appending to the new list does not change the original list's length, but changes to a shared nested list are visible through both collections. Slice assignment can replace, insert, or delete several list elements. The step cannot be zero, and extended slice replacement must satisfy additional length requirements.

Assignment normally creates another reference to the same object rather than a copy. If second refers to first, changing second also changes first. Use slicing, .copy(), or a constructor for a shallow copy; use deepcopy() from the copy module when nested objects must be copied recursively.

Takeaway: Distinguish a new outer container from independent nested data before modifying a collection.

Iteration, mappings, and unique values

Collections are iterable when they can provide their elements one at a time to a for loop. Use enumerate() when both an index and a value are needed, and use zip() to process related collections in parallel.

Dictionaries iterate over keys by default. The .items(), .keys(), and .values() methods make the intended part of the dictionary explicit. Avoid changing a collection's size while iterating over it; instead, iterate over a copy or construct a new collection, such as a filtered list.

A dictionary maps unique hashable keys to values. Assigning to an existing key replaces its value, while assigning to a new key adds a pair. .get() supplies a fallback when a key may be absent and avoids KeyError. Dictionary comprehensions construct mappings concisely.

A set stores unique hashable values and supports membership tests without positional indexing. Its operators express union, intersection, difference, and symmetric difference. frozenset() provides an immutable, hashable set when a set must be used as a dictionary key or as an element of another set.

Takeaway: Iteration expresses how data is processed, dictionaries express key-based relationships, and sets express uniqueness and set algebra.