Mutability vs. Immutability

• Mutable types (lists, dictionaries, sets) can be modified after creation
• Immutable types (tuples, strings, frozen sets) cannot be modified after creation

Hashability

• Hashable objects can be used as dictionary keys and set elements
• Only immutable types are hashable (strings, numbers, tuples, frozen sets)
• Mutable types (lists, dictionaries, sets) are not hashable

Ordering

• Ordered collections (lists, tuples, strings) maintain element order and support indexing
• Unordered collections (sets, frozen sets) don’t guarantee order
• Dictionaries maintain insertion order (Python 3.7+)

Common Sequence Operations

All sequences (lists, tuples, strings) support:

• Indexing: seq[index]
• Slicing: seq[start:stop:step]
• Membership: in and not in
• Length: len(seq)
• Concatenation: +
• Repetition: *
• Built-in functions: min(), max(), sum(), count(), index()

Lists

Lists are mutable, ordered sequences that can store elements of any type. They support indexing, slicing, and various methods for adding, removing, and modifying elements.

1
# Example: Working with lists
2
fruits = ["apple", "banana", "orange"]
3
fruits.append("grape")        # Add element
4
fruits.remove("banana")       # Remove element
5
print(fruits[0])              # Access by index: "apple"
6
print(fruits[1:3])            # Slice: ["orange", "grape"]

Tuples

Tuples are immutable, ordered sequences. Once created, they cannot be modified, making them hashable and suitable as dictionary keys. They support tuple packing and unpacking.

1
# Example: Tuple unpacking and using as dictionary keys
2
x, y = (10, 20)               # Unpacking
3
point = (10, 20)
4
locations = {point: "origin"} # Can be used as dictionary key
5
print(locations[(10, 20)])    # "origin"

Strings

Strings are immutable sequences of characters. They support all sequence operations plus specialized text manipulation methods and formatting.

1
# Example: String operations and formatting
2
text = "Hello World"
3
print(text.upper())           # "HELLO WORLD"
4
print(text.split())           # ["Hello", "World"]
5
name = "Alice"
6
age = 25
7
msg = f"My name is {name} and I am {age} years old"

Dictionaries

Dictionaries are mutable collections of key-value pairs. Keys must be immutable and hashable, while values can be of any type. They provide fast lookups by key.

1
# Example: Dictionary operations
2
student_grades = {"Alice": 95, "Bob": 87, "Charlie": 92}
3
print(student_grades["Alice"])           # 95 (fast lookup)
4
student_grades["David"] = 90             # Add new entry
5
for name, grade in student_grades.items():
6
    print(f"{name}: {grade}")

Sets

Sets are mutable, unordered collections of unique elements. All elements must be immutable and hashable. They excel at membership testing and mathematical set operations.

1
# Example: Set operations
2
set1 = {1, 2, 3, 4}
3
set2 = {3, 4, 5, 6}
4
print(set1 & set2)            # Intersection: {3, 4}
5
print(set1 | set2)            # Union: {1, 2, 3, 4, 5, 6}
6
print(3 in set1)              # Membership test: True

Frozen Sets

Frozen Sets are immutable versions of sets. Since they cannot be modified after creation, they are hashable and can be used as dictionary keys or as elements in other sets.

1
# Example: Using frozen sets as dictionary keys
2
edges = {
3
    frozenset([1, 2]): "edge_1_2",
4
    frozenset([2, 3]): "edge_2_3"
5
}
6
print(edges[frozenset([1, 2])])  # "edge_1_2"