Advanced Data Structures

Choosing the Right Container

You already know how to store a single piece of information in a variable. But most real-world code deals with collections of data. Python offers several built-in structures for this, and while they might seem similar, choosing the right one can dramatically affect your program's efficiency and clarity. We'll explore the trade-offs between Python's four main collection types: lists, tuples, dictionaries, and sets.

Lists and Tuples

Lists are the workhorses of Python collections. They are ordered, mutable, and can hold items of different types. Their flexibility is their greatest strength. You can add, remove, or change items after the list is created.

Use a list when you have a collection of items that needs to change over time, like a to-do list or a list of users.

A common task is creating a new list based on an existing one. While a standard for loop works, list comprehensions offer a more concise and often faster way to do it. They read like plain English and pack the logic into a single line.

# Using a for loop
squares_loop = []
for x in range(10):
    squares_loop.append(x**2)

# Using a list comprehension
squares_comp = [x**2 for x in range(10)]

print(squares_loop)   # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(squares_comp)  # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Tuples are like lists, but with a crucial difference: they are immutable. Once you create a tuple, you cannot change its contents. This might seem like a limitation, but it's actually a powerful feature. Immutability guarantees that the data remains constant, which prevents accidental modification.

This also makes tuples slightly more memory-efficient than lists. If you have a large collection of data that won't change, using a tuple can save resources.

Use a tuple for data that shouldn't change, like coordinates (x, y), RGB color values, or days of the week.

Dictionaries and Sets

While lists and tuples are indexed by integers, dictionaries are indexed by keys. They store data as key-value pairs, allowing you to look up a value instantly if you know its key. This makes them incredibly fast for retrieving data.

The magic behind this speed is a process called hashing. Python takes a key, runs it through a hash function to get an address, and stores the value at that address. To work as a key, an object must be —meaning its hash value never changes during its lifetime. This is why you can use strings and tuples as keys, but not lists.

# A dictionary of user roles
user_roles = {
    'alice': 'admin',
    'bob': 'editor',
    'charlie': 'viewer'
}

# Fast lookup by key
print(user_roles['bob']) # Output: editor

Sets are like dictionaries but without the values. They are unordered collections of unique, hashable items. Their main strength is highly optimized membership testing. Checking if an item exists in a set is extremely fast, regardless of the set's size. This is what we call an O(1) lookup or constant time operation.

Operation	List	Set
`item in collection`	Slow (O(n))	Fast (O(1))
Element storage	Duplicates allowed	Only unique items

Sets also provide powerful mathematical operations like union, intersection, and difference right out of the box.

Use a set when you need to quickly check for an item's existence or find the unique items from a collection.

Copying Collections

When you assign a collection to a new variable, you aren't creating a new copy; you're just creating another reference to the same object in memory. Modifying one will affect the other. This leads to a crucial concept: .

A shallow copy creates a new collection object, but populates it with references to the original items. This is fine for collections of immutable objects like numbers or strings. But if your list contains other mutable objects, like other lists, the shallow copy will still reference the original inner lists.

import copy

# Original list with a nested list
original = [1, 2, [3, 4]]

# Shallow copy
shallow = copy.copy(original)

# Deep copy
deep = copy.deepcopy(original)

# Modify the nested list in the shallow copy
shallow[2][0] = 'X'

print(f"Original: {original}") # Output: Original: [1, 2, ['X', 4]]
print(f"Shallow:  {shallow}")  # Output: Shallow:  [1, 2, ['X', 4]]
print(f"Deep:     {deep}")     # Output: Deep:     [1, 2, [3, 4]]

A deep copy, on the other hand, recursively creates new copies of all objects inside the original collection. This ensures the new collection is completely independent. Understanding this distinction is vital for preventing subtle bugs where you accidentally modify data you thought was safe.

Quiz Questions 1/6

You are storing a collection of configuration settings for an application that should not be changed while the program is running. Which data structure is the most appropriate choice for this task?

Quiz Questions 2/6

Why can a list NOT be used as a key in a Python dictionary?

Choosing the right data structure is a key step in writing clean, efficient Python code. By understanding the unique strengths of lists, tuples, sets, and dictionaries, you can select the perfect tool for the job.

Mastering Practical Python Foundations