Introduction to Python Containers

List Mutability

Lists are mutable, meaning you can change, add, or remove elements after the list has been created. You can overwrite an element by assigning a new value to an index (e.g., a[1] = 'text') or remove elements using the del statement.

Exam Tip: When assigning one list to another (e.g., b = a), both variables point to the same object. If you modify b, a will also change. To create a completely independent copy, use "cloning" via a[:] or a.copy().

Strings: Sequences of Characters

Strings are a specialized type of sequence container that holds textual characters. Like lists, strings are ordered and support indexing and slicing. However, there is a fundamental difference: strings are immutable. Once a string is created, you cannot change an individual character within it; attempting to do so will result in an error.

String Traversal

Processing a string one character at a time is a common programming pattern known as traversal. You can perform a traversal using a while loop with an index or, more concisely, a for loop:

# Example of string traversal using a for loop
fruit = "banana"
for char in fruit:
    print(char)

Tuples: The Immutable Alternative

A tuple is similar to a list in that it is an ordered container of elements. Syntactically, tuples are often defined using parentheses (), though they can also be created by separating values with commas.

The defining characteristic of a tuple is immutability. Once a tuple is defined, its contents cannot be changed.

When should you use a tuple instead of a list?

1. Safety: To prevent accidental changes to data that should remain constant.
2. Clarity: To signal to other programmers that the object is intended to be fixed.
3. Efficiency: Python can handle tuples more efficiently in memory than lists.

Dictionaries: Key-Value Mapping

Unlike lists or strings, dictionaries are not "sequences" because they do not rely on a numerical order. Instead, they are an unordered collection of key-value pairs. You use a unique "key" to look up a corresponding "value," much like looking up a word in a physical dictionary.

Dictionary Rules

To function correctly, dictionaries must follow two strict rules:

1. Keys must be immutable: You can use strings, integers, or tuples as keys, but you cannot use a list as a key.
2. Keys must be unique: If you attempt to assign a value to a key that already exists, the old value will be overwritten.

While keys must be unique, values do not have to be. A single value can be associated with many different keys.

Sets: Unordered Uniqueness

A set is an unordered collection of unique elements. This means that if you attempt to create a set from a list that contains duplicate items, the set will automatically discard the duplicates.

Sets are particularly useful for:

• Checking for membership (is an item in this group?).
• Removing duplicates from a collection.
• Generating a collection of unique items.

Because sets are unordered, you cannot access elements using an index like my_set[0]; you can only check if an item exists within the set or iterate through the items using a loop.