Skip to content
CodeMDD.io | Coding Tutorials

Effortlessly Iterate Through a Python Dictionary

[

How to Iterate Through a Dictionary in Python

Dictionaries are fundamental data structures in Python that are used to store and organize data. They are highly versatile and widely used in Python programming. Understanding how to iterate through a dictionary is essential for effectively manipulating and extracting information from this data structure.

In this tutorial, we will explore various methods and techniques for iterating through dictionaries in Python. We will provide step-by-step explanations and executable sample code to make it easy for you to follow along.

Getting Started With Python Dictionaries

Before we dive into dictionary iteration, let’s briefly review the fundamentals of using dictionaries in Python. A dictionary is a collection of key-value pairs enclosed in curly braces {}. Each key-value pair is separated by a colon :. Here’s an example of a dictionary:

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

In the above example, 'name', 'age', and 'city' are the keys, and 'John', 30, and 'New York' are the corresponding values.

Understanding How to Iterate Through a Dictionary in Python

There are several ways to iterate through a dictionary in Python. In this section, we will explore four methods for dictionary iteration:

  1. Traversing a Dictionary Directly
  2. Looping Over Dictionary Items: The .items() Method
  3. Iterating Through Dictionary Keys: The .keys() Method
  4. Walking Through Dictionary Values: The .values() Method

Traversing a Dictionary Directly

The simplest way to iterate through a dictionary is by traversing it directly using a for loop. This method allows you to access both the keys and values of the dictionary. Here’s an example:

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


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

Output:

name John
age 30
city New York

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

Looping Over Dictionary Items: The .items() Method

The .items() method allows you to loop over the items of a dictionary, providing access to both the keys and values in a single iteration. This method returns a view object that contains tuples of key-value pairs. Here’s an example:

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


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

Output:

name John
age 30
city New York

In the above code, the key and value variables represent each key-value pair in the dictionary.

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:

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


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

Output:

name
age
city

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

Walking Through Dictionary Values: The .values() Method

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:

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


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

Output:

John
30
New York

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

Changing Dictionary Values During Iteration

When iterating through a dictionary, you can modify its values. However, you should be cautious when doing so, as it may lead to unexpected behavior. To safely modify dictionary values during iteration, you can create a new dictionary and update it accordingly. Here’s an example:

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


for key, value in my_dict.items():
    new_dict[key] = value + 1


print(new_dict)

Output:

{'name': 'John1', 'age': 31, 'city': 'New York1'}

In the above code, we create a new dictionary new_dict and assign the modified values by adding 1 to each original value.

Safely Removing Items From a Dictionary During Iteration

Similar to modifying values, removing items from a dictionary while iterating can lead to unexpected behavior. To safely remove items from a dictionary, you can create a new dictionary and exclude the items you want to remove. Here’s an example:

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


for key, value in my_dict.items():
    if key != 'city':
        new_dict[key] = value


print(new_dict)

Output:

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

In the above code, we create a new dictionary new_dict and exclude the item with the key 'city'. The result is a dictionary without the excluded item.

Iterating Through Dictionaries: for Loop Examples

In this section, we will explore some common examples of iterating through dictionaries using a for loop.

Filtering Items by Their Value

You can filter dictionary items based on their values. For example, you can extract all items with a value greater than a certain threshold. Here’s an example:

my_dict = {'a': 10, 'b': 20, 'c': 30, 'd': 40}


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

Output:

c 30
d 40

In the above code, we filter the dictionary items based on their values being greater than 25.

Running Calculations With Keys and Values

You can perform calculations using the keys and values of a dictionary. For example, you can calculate the sum or average of the values. Here’s an example:

my_dict = {'a': 10, 'b': 20, 'c': 30, 'd': 40}
sum = 0


for key, value in my_dict.items():
    sum += value


print("Sum:", sum)
print("Average:", sum / len(my_dict))

Output:

Sum: 100
Average: 25.0

In the above code, we calculate the sum and average of the dictionary values.

Swapping Keys and Values Through Iteration

You can swap the keys and values of a dictionary by iterating through its items and creating a new dictionary. Here’s an example:

my_dict = {'a': 10, 'b': 20, 'c': 30, 'd': 40}
new_dict = {}


for key, value in my_dict.items():
    new_dict[value] = key


print(new_dict)

Output:

{10: 'a', 20: 'b', 30: 'c', 40: 'd'}

In the above code, we create a new dictionary new_dict with the keys and values swapped from the original dictionary.

Iterating Through Dictionaries: Comprehension Examples

Python comprehensions allow you to create new dictionaries based on existing ones in a concise and readable way. In this section, we will explore some examples of dictionary comprehension for iteration.

Filtering Items by Their Value: Revisited

We can use dictionary comprehension to filter items based on their values. Here’s a concise way to achieve the same result as in the previous example:

my_dict = {'a': 10, 'b': 20, 'c': 30, 'd': 40}


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


print(filtered_dict)

Output:

{'c': 30, 'd': 40}

In the above code, we use a dictionary comprehension to create a new dictionary filtered_dict, containing only the items with values greater than 25.

Swapping Keys and Values Through Iteration: Revisited

We can also use dictionary comprehension to swap the keys and values of a dictionary. Here’s a concise way to achieve the same result as in the previous example:

my_dict = {'a': 10, 'b': 20, 'c': 30, 'd': 40}


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


print(swapped_dict)

Output:

{10: 'a', 20: 'b', 30: 'c', 40: 'd'}

In the above code, we use a dictionary comprehension to create a new dictionary swapped_dict, with the keys and values swapped from the original dictionary.

Traversing a Dictionary in Sorted and Reverse Order

By default, dictionaries are unordered in Python. However, if you need to traverse a dictionary in sorted or reverse order, you can use some additional techniques.

Iterating Over Sorted Keys

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

my_dict = {'c': 30, 'a': 10, 'b': 20, 'd': 40}


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

Output:

a 10
b 20
c 30
d 40

In the above code, we use the sorted() function to obtain a sorted list of keys and then iterate through them using a for loop.

Looping Through Sorted Values

If you need to traverse a dictionary based on its values in sorted order, you can use the sorted() function with the .items() method. Here’s an example:

my_dict = {'a': 10, 'b': 20, 'd': 40, 'c': 30}


for key, value in sorted(my_dict.items(), key=lambda x: x[1]):
    print(key, value)

Output:

a 10
b 20
c 30
d 40

In the above code, we use the sorted() function with a key argument that specifies the sorting criterion as the second element of each item tuple. This allows us to traverse the dictionary based on the sorted values.

Sorting a Dictionary With a Comprehension

Alternatively, you can use a dictionary comprehension to create a new dictionary with the items sorted based on their values. Here’s an example:

my_dict = {'c': 30, 'a': 10, 'b': 20, 'd': 40}


sorted_dict = {key: value for key, value in sorted(my_dict.items(), key=lambda x: x[1])}


print(sorted_dict)

Output:

{'a': 10, 'b': 20, 'c': 30, 'd': 40}

In the above code, we use a dictionary comprehension to create a new dictionary sorted_dict with the items sorted based on their values.

Iterating Through a Dictionary in Reverse-Sorted Order

To traverse a dictionary in reverse-sorted order, you can reverse the sorted list of keys using the reversed() function. Here’s an example:

my_dict = {'c': 30, 'a': 10, 'b': 20, 'd': 40}


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

Output:

d 40
c 30
b 20
a 10

In the above code, we reverse the sorted list of keys using the reversed() function and then iterate through them using a for loop.

Traversing a Dictionary in Reverse Order

If you simply need to traverse a dictionary in reverse order, you can use the .items() method with the reversed() function. Here’s an example:

my_dict = {'c': 30, 'a': 10, 'b': 20, 'd': 40}


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

Output:

d 40
b 20
a 10
c 30

In the above code, we convert the dictionary items to a list using the list() function, reverse the list using the reversed() function, and then iterate through them using a for loop.

Iterating Over a Dictionary Destructively With .popitem()

The .popitem() method allows you to iterate over a dictionary destructively, meaning that it removes and returns items from the dictionary in an arbitrary order. Here’s an example:

my_dict = {'a': 10, 'b': 20, 'c': 30, 'd': 40}


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

Output:

d 40
c 30
b 20
a 10

In the above code, the while loop continues until the dictionary is empty. During each iteration, we use the .popitem() method to remove and return an item, which we then print.

Using Built-in Functions to Implicitly Iterate Through Dictionaries

Python’s built-in functions map() and filter() can be leveraged to implicitly iterate through dictionary items and perform certain operations.

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

The map() function allows you to apply a transformation to each item in a dictionary. Here’s an example:

my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}


transformed_dict = {key: value * 2 for key, value in map(lambda x: (x[0], x[1] * 2), my_dict.items())}


print(transformed_dict)

Output:

{'a': 2, 'b': 4, 'c': 6, 'd': 8}

In the above code, we use the map() function with a lambda function that multiplies each value by 2. The result is a new dictionary transformed_dict with the transformed values.

Filtering Items in a Dictionary: filter()

The filter() function allows you to selectively filter items from a dictionary based on a condition. Here’s an example:

my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}


filtered_dict = {key: value for key, value in filter(lambda x: x[1] % 2 == 0, my_dict.items())}


print(filtered_dict)

Output:

{'b': 2, 'd': 4}

In the above code, we use the filter() function with a lambda function that checks if the value is even. The result is a new dictionary filtered_dict with only the items that satisfy the filtering condition.

Traversing Multiple Dictionaries as One

In some cases, you may need to iterate through multiple dictionaries as if they were a single dictionary. Python provides two methods to achieve this: ChainMap and chain().

Iterating Through Multiple Dictionaries With ChainMap

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

from collections import ChainMap


dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}


combined_dict = ChainMap(dict1, dict2)


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

Output:

c 3
d 4
a 1
b 2

In the above code, we create two dictionaries dict1 and dict2, and then combine them using the ChainMap class. We can then iterate through the combined dictionary and access its items.

Iterating Through a Chain of Dictionaries With chain()

The chain() function from the itertools module allows you to iterate through multiple dictionaries in a sequential manner. Here’s an example:

from itertools import chain


dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}


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


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

Output:

a 1
b 2
c 3
d 4

In the above code, we use the chain() function to combine the items of dict1 and dict2. We can then iterate through the combined items and access their keys and values.

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

If you have multiple dictionaries and want to merge them into a single dictionary, you can use the unpacking operator **. Here’s an example:

dict1 = {'name': 'John', 'age': 30}
dict2 = {'city': 'New York', 'country': 'USA'}


merged_dict = {**dict1, **dict2}


print(merged_dict)

Output:

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

In the above code, we use the unpacking operator ** to merge the items of dict1 and dict2 into a single dictionary merged_dict.

Key Takeaways

Iterating through dictionaries is a crucial skill in Python programming. In this tutorial, we covered various methods and techniques for dictionary iteration, including:

  • Traversing a Dictionary Directly
  • Looping Over Dictionary Items: The .items() Method
  • Iterating Through Dictionary Keys: The .keys() Method
  • Walking Through Dictionary Values: The .values() Method
  • Changing Dictionary Values During Iteration
  • Safely Removing Items From a Dictionary During Iteration
  • Iterating Through Dictionaries: for Loop Examples
  • Iterating Through Dictionaries: Comprehension Examples
  • Traversing a Dictionary in Sorted and Reverse Order
  • Iterating Over a Dictionary Destructively With .popitem()
  • Using Built-in Functions to Implicitly Iterate Through Dictionaries
  • Traversing Multiple Dictionaries as One
  • Looping Over Merged Dictionaries: The Unpacking Operator (**)

By mastering these techniques, you will be able to efficiently manipulate and extract information from dictionaries in your Python programs. Happy coding!