Collections and Complex Logic

Beyond Simple Sequences

Lists and tuples are perfect for storing ordered sequences of items, like a list of steps in a recipe or the coordinates for a point in space. But what happens when the relationship between your data is more important than the order? What if you need to look up a phone number by a person's name, or quickly find all the unique tags on a blog post? For these jobs, we need more specialized tools: dictionaries and sets.

Think of a dictionary as a digital address book. You don't flip through it page by page; you look up a person's name (the key) to find their information (the value). This structure is incredibly efficient for retrieval. Let's model a simple product inventory.

inventory = {
  "apples": 430,
  "bananas": 312,
  "oranges": 525,
  "pears": 217
}

# Access the value using its key
print(f"We have {inventory['oranges']} oranges.")

# Add a new item
inventory['grapes'] = 150

# Update an existing item
inventory['apples'] -= 20 # We sold 20 apples

print(inventory)

Notice that the keys ("apples", "bananas") must be unique and are typically strings or numbers. The values can be anything: numbers, strings, lists, or even other dictionaries.

Working with Dictionaries

Dictionaries come with powerful methods for accessing their contents. You can get just the keys, just the values, or the key-value pairs together. These methods don't return simple lists; they return special that provide a dynamic window into the dictionary's entries. If you add or remove an item from the dictionary, the view object reflects that change instantly.

print(inventory.keys())   # dict_keys(['apples', 'bananas', 'oranges', 'pears', 'grapes'])
print(inventory.values()) # dict_values([410, 312, 525, 217, 150])
print(inventory.items())  # dict_items([('apples', 410), ('bananas', 312), ...])

# Loop through key-value pairs
for fruit, quantity in inventory.items():
  print(f"{fruit.capitalize()}: {quantity}")

The magic of dictionaries comes from their performance. Checking if a key exists is extremely fast, regardless of how many items are in the dictionary. This is thanks to an underlying structure called a hash table, which can compute the location of a key instead of searching for it one by one. Testing for "apples" in inventory is nearly instantaneous, whereas searching a million-item list could take a moment.

Sets for Uniqueness

Now, let's consider a different problem. Imagine you have a list of tags from a series of blog posts, and you want to compile a single list of all unique tags used. A list might contain duplicates, but a set cannot. A set is an unordered collection of unique items.

tags = ['python', 'data', 'code', 'python', 'tutorial', 'data']

# Convert the list to a set to get unique items
unique_tags = set(tags)
print(unique_tags) # {'tutorial', 'code', 'data', 'python'}

# Check for membership (this is very fast!)
print('python' in unique_tags) # True

Like dictionaries, sets are also built on hash tables, so checking for membership is incredibly fast. Their real power, however, lies in their ability to perform mathematical set operations.

Suppose you have two sets of users: those who liked an article and those who commented on it. You can easily find users who did both, one or the other, or just one.

liked_users = {'alice', 'bob', 'charlie', 'dave'}
commented_users = {'charlie', 'dave', 'eve'}

# Union: users who liked OR commented (or both)
print(liked_users.union(commented_users)) 
# {'eve', 'dave', 'bob', 'alice', 'charlie'}

# Intersection: users who liked AND commented
print(liked_users.intersection(commented_users))
# {'dave', 'charlie'}

# Difference: users who liked but did NOT comment
print(liked_users.difference(commented_users))
# {'bob', 'alice'}

Combining Data

Sometimes you have separate but related lists. The zip() function is a handy tool for pairing them up. It takes multiple lists and returns an iterator that bundles their corresponding elements into tuples. This is perfect for creating a dictionary from two lists.

fruits = ['apples', 'bananas', 'oranges']
prices = [1.50, 0.75, 1.25]

# Create a dictionary from two lists
price_map = dict(zip(fruits, prices))
print(price_map)
# {'apples': 1.5, 'bananas': 0.75, 'oranges': 1.25}

Another useful function is enumerate(), which adds a counter to an iterable. Instead of manually tracking an index in a for loop, enumerate() gives you both the index and the item.

top_scorers = ['LeBron', 'Kareem', 'Karl Malone']

for rank, name in enumerate(top_scorers, start=1):
  print(f"Rank {rank}: {name}")

By nesting these structures, you can model complex data. For example, a dictionary of students where each value is another dictionary containing their grades and attendance.

students = {
    'Alice': {
        'grades': [95, 88, 92],
        'attendance': {'present': 18, 'absent': 2}
    },
    'Bob': {
        'grades': [78, 81, 85],
        'attendance': {'present': 20, 'absent': 0}
    }
}

# Get Alice's first grade
print(students['Alice']['grades'][0]) # 95

Mastering dictionaries and sets moves you beyond simple data storage. You can now build structures that map relationships, ensure uniqueness, and perform lookups with remarkable speed.

Practical Python and Modular Design