5 Collections and String Processing

The Collection Landscape

Python collections organize groups of values. The main built-in choices are strings, lists, tuples, dictionaries, and sets. The best choice depends on whether order, mutability, duplicates, positional access, key-based lookup, or uniqueness matters.

A useful first distinction is between sequences and mappings or sets:

• Sequences keep values in an order and support positional operations. Strings, lists, and tuples are sequences.

• Dictionaries find values through keys rather than numeric positions.

• Sets store distinct values without providing positional access.

Before choosing a collection, ask:

1. Does order matter?

2. Must the data be changed after creation?

3. Are duplicate values meaningful?

4. Will values be found by position, by a key, or by membership?

5. Is slicing required?

Takeaway: Choose a collection according to the operations the program needs, not merely according to the shape of the sample data.

Strings and Text Processing

Strings represent textual data and are immutable sequences of Unicode characters. They can be indexed, sliced, iterated over, and tested for membership.

Common string operations include:

• lower() and upper() for case conversion.

• strip(), lstrip(), and rstrip() for surrounding whitespace.

• replace() for substitution.

• split() for turning text into a list of pieces.

• join() for combining strings with a separator.

• find() for locating a substring, returning -1 when it is absent.

• count() for counting non-overlapping occurrences.

• startswith() and endswith() for prefix and suffix checks.

For example, splitting "Ada,Grace,Linus" at commas produces a list of names, and joining that list with " | " produces formatted text. Formatted string literals, also called f-strings, make it convenient to place values inside readable output.

Because strings are immutable, an operation such as text.upper() returns a new string. To retain the result, assign it back to a variable or store it elsewhere.

Takeaway: Treat a string as text that can be inspected and transformed, but not edited in place.

Editable and Fixed Sequences

Lists and tuples are both ordered sequences, so both support indexing, slicing, iteration, membership tests, and length checks. Their central difference is mutability.

A list is appropriate for an editable sequence. Methods such as append(), extend(), insert(), remove(), pop(), sort(), and reverse() operate on a list. Lists can also act as stacks: add items with append() and remove the most recently added item with pop().

A tuple is appropriate for a fixed group of related values. For example, a coordinate can be represented as (3, 4), and its values can be unpacked into separate variables. Tuple elements cannot be replaced after creation.

Use a list when:

• order and position matter;

• the collection must change;

• duplicates should remain; or

• items will be added or removed.

Use a tuple when:

• the group should remain fixed;

• the values form one logical record; or

• an immutable, hashable group is needed as a dictionary key or set element, provided all contents are hashable.

Takeaway: Lists represent changeable ordered data; tuples represent fixed ordered data.

Key-Based Lookup and Unique Values

Dictionaries and sets solve different lookup problems. A dictionary associates each unique, hashable key with a value. A set stores distinct, hashable values without associated values.

Dictionaries are useful for records and lookups. A student record might map "name" to a name and "age" to an age. Assigning to an existing key updates its value, while assigning to a new key adds a pair. Accessing a missing key with subscription raises KeyError; get() can provide a default instead. Use keys(), values(), and items() when iterating explicitly over dictionary contents.

A common counting pattern starts with an empty dictionary and updates each item using get() with a default count. This is useful for counting letters, grouping records, or tallying categories.

Sets are useful when duplicates should disappear or when membership testing and set relationships are central. The union combines values from two sets, the intersection keeps shared values, the difference keeps values present in one set but not the other, and the symmetric difference keeps values present in exactly one set. Sets do not support indexing or slicing.

Use remove() when a missing set item should be treated as an error, and discard() when missing is acceptable.

Takeaway: Use a dictionary to map keys to values and a set to represent unique membership.

Iteration, Comprehensions, and Selection

Iteration provides a common way to process strings, lists, tuples, dictionaries, sets, ranges, and many other iterable objects. A for loop visits each item in turn.

Use enumerate() when both a position and its value are needed. Use zip() when corresponding items from multiple iterables should be processed together. For dictionaries, iterate over keys by default, over values with values(), or over key–value pairs with items().

Comprehensions make common transformations concise. A list comprehension can transform or filter items, a set comprehension creates unique results, and a dictionary comprehension creates key–value pairs. For example, a list comprehension can create squares from a range of numbers, while a set comprehension can collect the distinct lengths of several words.

Prefer a regular loop when a comprehension would require several nested loops, complicated conditions, or side effects. Readability is more important than compactness.

A final selection guide is:

• Use str for textual data.

• Use list for an ordered, editable sequence.

• Use tuple for an ordered, fixed sequence.

• Use dict for lookup by key or structured associations.

• Use set for unique values and membership operations.

• Use collections.deque when efficient additions and removals at both ends are required.

Takeaway: Clear iteration patterns and an appropriate collection make transformations easier to read, maintain, and reason about.