Effortlessly Iterating through Python Dictionaries: Explained!

How to Iterate Through a Dictionary in Python

Solid knowledge of dictionary iteration will help you write better, more robust code. In your journey through dictionary iteration, you’ll write several examples that will help solidify your understanding.

Getting Started With Python Dictionaries

Before diving into dictionary iteration, let’s first understand the basics of Python dictionaries. A dictionary is an unordered collection of key-value pairs. Each key is unique, and it is used to access its corresponding value. Dictionaries in Python are enclosed in curly braces {}, and key-value pairs are separated by colons :. Here’s an example:

person = {"name": "John", "age": 30, "city": "New York"}

In this example, person is a dictionary with keys "name", "age", and "city", and their corresponding values are "John", 30, and "New York". You can access the values in a dictionary by using the keys. For example:

name = person["name"]
print(name)  # Output: John

To iterate through a dictionary, you will use different methods and techniques that we will explore in the following sections.

Understanding How to Iterate Through a Dictionary in Python

There are multiple ways to iterate through a dictionary in Python. In this tutorial, we will cover the most commonly used methods and techniques.

Traversing a Dictionary Directly

One simple way to iterate through a dictionary is by traversing it directly using a for loop. This allows you to access each key in the dictionary and perform any desired operations. Here’s an example:

person = {"name": "John", "age": 30, "city": "New York"}

for key in person:
    print(key)

Output:

name
age
city

In this example, the for loop iterates through the keys of the person dictionary and prints each key.

Looping Over Dictionary Items: The .items() Method

To iterate over both the keys and values of a dictionary simultaneously, you can use the .items() method. This method returns a view object that contains tuples of the key-value pairs. Here’s an example:

person = {"name": "John", "age": 30, "city": "New York"}

for key, value in person.items():
    print(key, ":", value)

Output:

name : John
age : 30
city : New York

In this example, the person.items() method produces a view object that contains the key-value pairs of the person dictionary. The for loop then unpacks each tuple into the variables key and value, allowing you to access and print both the keys and values.

Iterating Through Dictionary Keys: The .keys() Method

If you only need to iterate through the keys of a dictionary, you can use the .keys() method. This method returns a view object that contains the keys of the dictionary. Here’s an example:

person = {"name": "John", "age": 30, "city": "New York"}

for key in person.keys():
    print(key)

Output:

name
age
city

In this example, the person.keys() method produces a view object that contains the keys of the person dictionary. The for loop then iterates through each key and prints it.

Walking Through Dictionary Values: The .values() Method

Similarly, if you only need to iterate through the values of a dictionary, you can use the .values() method. This method returns a view object that contains the values of the dictionary. Here’s an example:

person = {"name": "John", "age": 30, "city": "New York"}

for value in person.values():
    print(value)

Output:

John
30
New York

In this example, the person.values() method produces a view object that contains the values of the person dictionary. The for loop then iterates through each value and prints it.

Changing Dictionary Values During Iteration

In some cases, you may need to modify the values of a dictionary while iterating through it. However, modifying the dictionary’s values directly within the loop can lead to unexpected results. To avoid these issues, you can iterate over a copy of the dictionary’s keys or values instead. Here’s an example:

person = {"name": "John", "age": 30, "city": "New York"}

for key in list(person.keys()):
    person[key] += 10

print(person)

Output:

{'name': 'John', 'age': 40, 'city': 'New York'}

In this example, a list of the dictionary’s keys is created using the list() method. This allows you to iterate through a copy of the keys while modifying the values of the original dictionary.

Safely Removing Items From a Dictionary During Iteration

Similar to modifying values, removing items from a dictionary while iterating through it can also lead to unexpected results. To safely remove items from a dictionary during iteration, you can use a list to store the keys you want to remove, and then remove them outside of the loop. Here’s an example:

person = {"name": "John", "age": 30, "city": "New York"}

keys_to_remove = []

for key, value in person.items():
    if value == 30:
        keys_to_remove.append(key)

for key in keys_to_remove:
    del person[key]

print(person)

Output:

{'name': 'John', 'city': 'New York'}

In this example, a list called keys_to_remove is used to store the keys that need to be removed from the dictionary. After iterating through the dictionary and identifying the keys to be removed, the keys are then deleted outside of the loop.

Iterating Through Dictionaries: for Loop Examples

Now that you have a solid understanding of the basics of iterating through a dictionary, let’s explore some examples that demonstrate different use cases and techniques.

Filtering Items by Their Value

You can use a for loop to filter the items of a dictionary based on their values. Here’s an example:

prices = {"apple": 0.5, "banana": 0.25, "orange": 0.75}

for item, price in prices.items():
    if price < 0.5:
        print(item)

Output:

banana

In this example, the for loop iterates through the key-value pairs of the prices dictionary. The if statement filters the items based on their price, printing only the items with a price less than 0.5.

Running Calculations With Keys and Values

You can also perform calculations using the keys and values of a dictionary. Here’s an example that calculates the total price of all items:

prices = {"apple": 0.5, "banana": 0.25, "orange": 0.75}
total_price = 0

for item, price in prices.items():
    total_price += price

print(total_price)

Output:

1.5

In this example, the for loop iterates through the key-value pairs of the prices dictionary. The total_price variable is updated by adding the value of each item.

Swapping Keys and Values Through Iteration

If you need to swap the keys and values of a dictionary, you can do so by creating a new dictionary inside the loop. Here’s an example:

person = {"name": "John", "age": 30, "city": "New York"}
new_person = {}

for key, value in person.items():
    new_person[value] = key

print(new_person)

Output:

{'John': 'name', 30: 'age', 'New York': 'city'}

In this example, the for loop iterates through the key-value pairs of the person dictionary. The new_person dictionary is updated by assigning the value as the key and the key as the value.

Iterating Through Dictionaries: Comprehension Examples

There is a more concise way to iterate through a dictionary using comprehension. Dictionary comprehension allows you to create a new dictionary by specifying the key-value pairs you want to include. Here are a couple of examples:

Filtering Items by Their Value: Revisited

You can use dictionary comprehension to filter the items of a dictionary based on their values. Here’s an example:

prices = {"apple": 0.5, "banana": 0.25, "orange": 0.75}

filtered_prices = {item: price for item, price in prices.items() if price < 0.5}

print(filtered_prices)

Output:

{'banana': 0.25}

In this example, dictionary comprehension is used to create a new dictionary called filtered_prices. The comprehension includes only the items with a price less than 0.5.

Swapping Keys and Values Through Iteration: Revisited

You can also use dictionary comprehension to swap the keys and values of a dictionary. Here’s an example:

person = {"name": "John", "age": 30, "city": "New York"}

new_person = {value: key for key, value in person.items()}

print(new_person)

Output:

{'John': 'name', 30: 'age', 'New York': 'city'}

In this example, dictionary comprehension is used to create a new dictionary called new_person. The comprehension swaps the keys and values of the person dictionary.

Traversing a Dictionary in Sorted and Reverse Order

In addition to iterating through a dictionary in its natural order, you may sometimes need to traverse it in a sorted or reverse-sorted order. Python provides several techniques to accomplish this.

Iterating Over Sorted Keys

To traverse a dictionary in sorted order based on its keys, you can use the sorted() function. Here’s an example:

person = {"name": "John", "age": 30, "city": "New York"}

for key in sorted(person.keys()):
    print(key)

Output:

age
city
name

In this example, the sorted() function is used to sort the dictionary’s keys. The for loop then iterates through the sorted keys and prints them.

Looping Through Sorted Values

Similarly, you can traverse a dictionary in sorted order based on its values by using the sorted() function within the for loop. Here’s an example:

person = {"name": "John", "age": 30, "city": "New York"}

for value in sorted(person.values()):
    print(value)

Output:

30
John
New York

In this example, the sorted() function is used within the for loop to sort the dictionary’s values. The for loop then iterates through the sorted values and prints them.

Sorting a Dictionary With a Comprehension

You can also use dictionary comprehension to create a new dictionary that is sorted based on either the keys or values of the original dictionary. Here’s an example that sorts based on the keys:

person = {"name": "John", "age": 30, "city": "New York"}

sorted_person = {key: person[key] for key in sorted(person.keys())}

print(sorted_person)

Output:

{'age': 30, 'city': 'New York', 'name': 'John'}

In this example, dictionary comprehension is used to create a new dictionary called sorted_person. The comprehension iterates through the sorted keys of the original person dictionary and includes the corresponding key-value pairs in the new dictionary.

Iterating Through a Dictionary in Reverse-Sorted Order

To traverse a dictionary in reverse-sorted order based on its keys or values, you can use the reversed() function. Here’s an example:

person = {"name": "John", "age": 30, "city": "New York"}

for key in reversed(sorted(person.keys())):
    print(key)

Output:

name
city
age

In this example, the sorted() function is used to sort the dictionary’s keys, and the reversed() function is used to reverse the order. The for loop then iterates through the reverse-sorted keys and prints them.

Traversing a Dictionary in Reverse Order

In Python 3.7 and later versions, dictionaries maintain the order in which the items were added. This allows you to traverse a dictionary in reverse order by using the .items() method and the reversed() function. Here’s an example:

person = {"name": "John", "age": 30, "city": "New York"}

for key, value in reversed(person.items()):
    print(key, ":", value)

Output:

city : New York
age : 30
name : John

In this example, the .items() method is used to produce a view object that contains the key-value pairs of the person dictionary. The reversed() function is then used to reverse the order of the key-value pairs. The for loop iterates through the reversed key-value pairs and prints them.

Iterating Over a Dictionary Destructively With .popitem()

The .popitem() method allows you to iterate over a dictionary destructively, meaning that the items are removed as you iterate through them. Here’s an example:

person = {"name": "John", "age": 30, "city": "New York"}

while person:
    key, value = person.popitem()
    print(key, ":", value)

Output:

city : New York
age : 30
name : John

In this example, the while loop continues until the person dictionary is empty. During each iteration, the .popitem() method is used to remove an item from the dictionary and return its key-value pair. The key and value are then printed.

Using Built-in Functions to Implicitly Iterate Through Dictionaries

Python provides a couple of built-in functions, map() and filter(), that allow you to implicitly iterate through dictionaries by applying transformations or filtering items based on certain conditions.

Applying a Transformation to a Dictionary’s Items: map()

The map() function applies a transformation to each item of a dictionary. Here’s an example:

prices = {"apple": 0.5, "banana": 0.25, "orange": 0.75}

discounted_prices = map(lambda item: (item[0], item[1] * 0.9), prices.items())

for item, price in discounted_prices:
    print(item, ":", price)

Output:

apple : 0.45
banana : 0.225
orange : 0.675

In this example, the map() function applies a lambda function to each item of the prices dictionary. The lambda function multiplies the price by 0.9, effectively applying a 10% discount. The for loop then iterates through the transformed items and prints them.

Filtering Items in a Dictionary: filter()

The filter() function allows you to filter the items of a dictionary based on certain conditions. Here’s an example:

prices = {"apple": 0.5, "banana": 0.25, "orange": 0.75}

cheap_items = filter(lambda item: item[1] < 0.5, prices.items())

for item, price in cheap_items:
    print(item, ":", price)

Output:

banana : 0.25

In this example, the filter() function applies a lambda function to each item of the prices dictionary. The lambda function filters the items based on the price being less than 0.5. The for loop then iterates through the filtered items and prints them.

Traversing Multiple Dictionaries as One

Sometimes, you may need to iterate through multiple dictionaries simultaneously as if they were a single dictionary. In Python, you can achieve this using the ChainMap and chain() functions from the collections module.

Iterating Through Multiple Dictionaries With ChainMap

The ChainMap function combines multiple dictionaries into a single dictionary-like object. Here’s an example:

prices_1 = {"apple": 0.5, "banana": 0.25}
prices_2 = {"orange": 0.75, "grape": 0.35}

merged_prices = collections.ChainMap(prices_1, prices_2)

for item, price in merged_prices.items():
    print(item, ":", price)

Output:

grape : 0.35
orange : 0.75
apple : 0.5
banana : 0.25

In this example, the ChainMap() function combines the prices_1 and prices_2 dictionaries into a single dictionary-like object called merged_prices. The for loop then iterates through the key-value pairs of the merged dictionary and prints them.

Iterating Through a Chain of Dictionaries With chain()

The chain() function allows you to iterate through multiple dictionaries one after the other, as if they were concatenated. Here’s an example:

prices_1 = {"apple": 0.5, "banana": 0.25}
prices_2 = {"orange": 0.75, "grape": 0.35}

merged_prices = itertools.chain(prices_1.items(), prices_2.items())

for item, price in merged_prices:
    print(item, ":", price)

Output:

apple : 0.5
banana : 0.25
orange : 0.75
grape : 0.35

In this example, the chain() function is used to iterate through the key-value pairs of the prices_1 and prices_2 dictionaries as if they were concatenated. The for loop then iterates through the merged key-value pairs and prints them.

Looping Over Merged Dictionaries: The Unpacking Operator (**)

Python provides a convenient syntax known as the unpacking operator (**) that allows you to merge multiple dictionaries into a single dictionary literal. Here’s an example:

prices_1 = {"apple": 0.5, "banana": 0.25}
prices_2 = {"orange": 0.75, "grape": 0.35}

merged_prices = {**prices_1, **prices_2}

for item, price in merged_prices.items():
    print(item, ":", price)

Output:

apple : 0.5
banana : 0.25
orange : 0.75
grape : 0.35

In this example, the dictionaries prices_1 and prices_2 are merged into a single dictionary literal called merged_prices using the unpacking operator (**). The for loop then iterates through the key-value pairs of the merged dictionary and prints them.

Key Takeaways

Iterating through dictionaries in Python is an essential skill that allows you to work with the key-value pairs of a dictionary effectively. In this tutorial, you learned several methods and techniques for dictionary iteration, including:

• Using a for loop to traverse a dictionary directly
• Looping over dictionary items with the .items() method
• Iterating through dictionary keys with the .keys() method
• Walking through dictionary values with the .values() method
• Safely modifying and removing items from a dictionary during iteration
• Using comprehension for filtering, transforming, and sorting dictionary items
• Destructive iteration using .popitem()
• Implicitly iterating through dictionaries using built-in functions
• Traversing multiple dictionaries as one with ChainMap and chain()
• Merging dictionaries using the unpacking operator (**)

With these techniques at your disposal, you’ll be able to handle a wide range of scenarios that involve iterating through dictionaries in Python.