Skip to content
CodeMDD.io | Coding Tutorials

Python: Effortlessly Iterating Over a Dictionary

CodeMDD.io

How to Iterate Through a Dictionary in Python

Dictionaries are fundamental data structures in Python that allow you to store and organize data in key-value pairs. They are widely used and can be found in almost every Python program. When working with dictionaries, it is common to need to iterate through the key-value pairs, keys, or values of the dictionary.

In this tutorial, you will learn various methods to iterate through a dictionary in Python. Each method will be explained in detail and accompanied by step-by-step sample code. Let’s get started!

Getting Started With Python Dictionaries

Before we dive into iterating through dictionaries, let’s first understand the basics of Python dictionaries.

A dictionary is created by enclosing key-value pairs in curly braces {}. Each key-value pair is separated by a colon :. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}

In the above example, name, age, and country are the keys, and 'John', 30, and 'USA' are the corresponding values.

Understanding How to Iterate Through a Dictionary in Python

Traversing a Dictionary Directly

The most straightforward way to iterate through a dictionary is by using a for loop. This will iterate over the keys of the dictionary. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


for key in my_dict:
    print(key, my_dict[key])

Output:

name John
age 30
country USA

In the above code, key represents each key in the dictionary, and my_dict[key] gives the corresponding value.

Looping Over Dictionary Items: The .items() Method

The .items() method of a dictionary allows you to iterate over both the keys and values simultaneously. It returns a tuple of key-value pairs. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


for key, value in my_dict.items():
    print(key, value)

Output:

name John
age 30
country USA

In the above code, key represents each key in the dictionary, and value represents the corresponding value.

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. It returns a view object that contains all the keys of the dictionary. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


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

Output:

name
age
country

In the above code, the key variable represents each key in the dictionary.

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. It returns a view object that contains all the values of the dictionary. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


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

Output:

John
30
USA

In the above code, the value variable represents each value in the dictionary.

Changing Dictionary Values During Iteration

It is important to note that you can modify dictionary values while iterating through them. However, modifying the dictionary structure itself (adding or removing keys) during iteration can lead to unexpected results or errors. Here’s an example of changing values during iteration:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


for key in my_dict:
    my_dict[key] = my_dict[key].upper()


print(my_dict)

Output:

{'name': 'JOHN', 'age': '30', 'country': 'USA'}

In the above code, the .upper() method is used to convert the values to uppercase.

Safely Removing Items From a Dictionary During Iteration

If you need to remove items from a dictionary while iterating, it is best to create a copy of the dictionary or generate a list of keys to be removed. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


keys_to_remove = []


for key in my_dict:
    if 'a' in key:
        keys_to_remove.append(key)


for key in keys_to_remove:
    del my_dict[key]


print(my_dict)

Output:

{'name': 'John'}

In the above code, the keys that contain the letter ‘a’ are stored in the keys_to_remove list. Then, a second loop is used to delete these keys from the dictionary.

Iterating Through Dictionaries: for Loop Examples

The for loop provides flexibility for iterating through dictionaries. In this section, we will explore some common examples.

Filtering Items by Their Value

You can filter dictionary items based on their values. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


for key, value in my_dict.items():
    if value == 'USA':
        print(key, value)

Output:

country USA

In the above code, only the items with the value 'USA' are printed.

Running Calculations With Keys and Values

You can perform calculations using the keys and values of a dictionary during iteration. Here’s an example:

inventory = {'apple': 10, 'banana': 15, 'orange': 20}
total_items = 0


for item, quantity in inventory.items():
    print(f"There are {quantity} {item}s")
    total_items += quantity


print(f"Total items in inventory: {total_items}")

Output:

There are 10 apples
There are 15 bananas
There are 20 oranges
Total items in inventory: 45

In the above code, the total_items variable is incremented by the quantity for each item in the inventory.

Swapping Keys and Values Through Iteration

You can swap the keys and values of a dictionary during iteration by creating a new dictionary. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


reversed_dict = {value: key for key, value in my_dict.items()}


print(reversed_dict)

Output:

{'John': 'name', 30: 'age', 'USA': 'country'}

In the above code, the reversed_dict dictionary is created by swapping the keys and values of my_dict.

Iterating Through Dictionaries: Comprehension Examples

List comprehensions are a concise way to iterate through and transform data in Python. They can also be used with dictionaries.

Filtering Items by Their Value: Revisited

Using a dictionary comprehension, you can filter items by their values in a more compact way. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


filtered_dict = {key: value for key, value in my_dict.items() if value == 'USA'}


print(filtered_dict)

Output:

{'country': 'USA'}

In the above code, the filtered_dict dictionary is created by keeping only the items with the value 'USA'.

Swapping Keys and Values Through Iteration: Revisited

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

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


reversed_dict = {value: key for key, value in my_dict.items()}


print(reversed_dict)

Output:

{'John': 'name', 30: 'age', 'USA': 'country'}

In the above code, the reversed_dict dictionary is created by swapping the keys and values of my_dict using a dictionary comprehension.

Traversing a Dictionary in Sorted and Reverse Order

By default, dictionaries are unordered in Python. However, you can iterate through a dictionary in sorted or reverse order using additional methods.

Iterating Over Sorted Keys

To iterate through a dictionary in sorted key order, you can use the sorted() function together with the .keys() method. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


for key in sorted(my_dict.keys()):
    print(key, my_dict[key])

Output:

age 30
country USA
name John

In the above code, the sorted() function is used to sort the keys of the dictionary alphabetically before iterating through them.

Looping Through Sorted Values

To iterate through a dictionary in sorted value order, you can use the sorted() function together with the .values() method. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


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

Output:

30
John
USA

In the above code, the sorted() function is used to sort the values of the dictionary before iterating through them.

Sorting a Dictionary With a Comprehension

To sort a dictionary by keys or values and create a new sorted dictionary, you can use a dictionary comprehension together with the sorted() function. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


sorted_dict = {key: my_dict[key] for key in sorted(my_dict)}


print(sorted_dict)

Output:

{'age': 30, 'country': 'USA', 'name': 'John'}

In the above code, the sorted_dict dictionary is created by iterating through the sorted keys of my_dict.

Iterating Through a Dictionary in Reverse-Sorted Order

To iterate through a dictionary in reverse-sorted key order, you can use the reversed() function together with the sorted() function. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


for key in reversed(sorted(my_dict.keys())):
    print(key, my_dict[key])

Output:

name John
country USA
age 30

In the above code, the reversed() function is used to reverse the sorted keys of the dictionary before iterating through them.

Traversing a Dictionary in Reverse Order

To iterate through a dictionary in reverse order without sorting, you can use the reversed() function together with the .keys() method. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


for key in reversed(list(my_dict.keys())):
    print(key, my_dict[key])

Output:

country USA
age 30
name John

In the above code, the reversed() function is used to reverse the order of the keys of the dictionary before iterating through them.

Iterating Over a Dictionary Destructively With .popitem()

The .popitem() method of a dictionary removes and returns an arbitrary key-value pair. It can be used in a loop to iteratively remove items from the dictionary until it is empty. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


while my_dict:
    key, value = my_dict.popitem()
    print(key, value)

Output:

country USA
age 30
name John

In the above code, the .popitem() method is used inside a while loop to remove and print key-value pairs until the dictionary is empty.

Using Built-in Functions to Implicitly Iterate Through Dictionaries

Python provides built-in functions like map() and filter() that can be used to implicitly iterate through dictionaries.

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

The map() function can be used to apply a transformation to a dictionary’s key-value pairs. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


new_dict = dict(map(lambda item: (item[0], item[1].upper()), my_dict.items()))


print(new_dict)

Output:

{'name': 'JOHN', 'age': '30', 'country': 'USA'}

In the above code, the lambda function is used to convert the values to uppercase using the upper() method.

Filtering Items in a Dictionary: filter()

The filter() function can be used to filter items in a dictionary based on a condition. Here’s an example:

my_dict = {'name': 'John', 'age': 30, 'country': 'USA'}


new_dict = dict(filter(lambda item: 'a' in item[0], my_dict.items()))


print(new_dict)

Output:

{'name': 'John', 'age': 30}

In the above code, the lambda function is used to filter dictionary items based on whether the key contains the letter ‘a’.

Traversing Multiple Dictionaries as One

Python provides several methods to traverse multiple dictionaries as one.

Iterating Through Multiple Dictionaries With ChainMap

The ChainMap class from the collections module allows you to combine multiple dictionaries into a single view object. Here’s an example:

from collections import ChainMap


dict1 = {'name': 'John', 'age': 30}
dict2 = {'country': 'USA', 'job': 'developer'}


combined_dict = ChainMap(dict1, dict2)


for key, value in combined_dict.items():
    print(key, value)

Output:

name John
age 30
country USA
job developer

In the above code, the ChainMap class merges dict1 and dict2 into a single view object called combined_dict.

Iterating Through a Chain of Dictionaries With chain()

The chain() function from the itertools module can be used to iterate through a chain of dictionaries. Here’s an example:

from itertools import chain


dict1 = {'name': 'John', 'age': 30}
dict2 = {'country': 'USA', 'job': 'developer'}


combined_dict = chain(dict1.items(), dict2.items())


for key, value in combined_dict:
    print(key, value)

Output:

name John
age 30
country USA
job developer

In the above code, the chain() function combines the items of dict1 and dict2 into a single iterable object.

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

Python provides the unpacking operator ** to merge dictionaries during iteration. Here’s an example:

dict1 = {'name': 'John', 'age': 30}
dict2 = {'country': 'USA', 'job': 'developer'}


combined_dict = {**dict1, **dict2}


for key, value in combined_dict.items():
    print(key, value)

Output:

name John
age 30
country USA
job developer

In the above code, {**dict1, **dict2} creates a new dictionary by unpacking and merging dict1 and dict2.

Key Takeaways

  • Python dictionaries are versatile data structures that allow you to store data in key-value pairs.
  • To iterate through a dictionary, you can use a for loop, the .items() method, the .keys() method, or the .values() method.
  • You can modify dictionary values during iteration, but modifying the dictionary structure itself can lead to unexpected results or errors.
  • When removing items from a dictionary during iteration, it is safer to create a copy of the dictionary or generate a list of keys to be removed.
  • List comprehensions provide concise ways to iterate through dictionaries and perform operations such as filtering and swapping keys and values.
  • You can iterate through a dictionary in sorted or reverse order using functions like sorted() and reversed().
  • Python provides built-in functions like map() and filter() that can be used to implicitly iterate through dictionaries.
  • Multiple dictionaries can be traversed as one using classes like ChainMap or functions like chain().
  • The unpacking operator ** can be used to merge dictionaries during iteration.

Now you have a thorough understanding of how to iterate through a dictionary in Python. This knowledge will empower you to write more efficient and effective code when working with dictionaries in your Python programs. Happy coding!