How to Iterate Through a Dictionary in Python

Traversing a Dictionary Directly

Python’s dictionaries have some special methods that Python uses internally to perform some operations. These methods use the naming convention of adding a double underscore at the beginning of and at the end of the method’s name.

You can use the built-in dir() function to get a list of methods and attributes that any Python object provides. If you run dir() with an empty dictionary as an argument, then you’ll get all the methods and attributes of the dict class:

>>> dir({})
['__class__', '__contains__', '__delattr__', ... , '__iter__', ...]

A closer look at the previous output reveals the '__iter__' entry, which is a method that Python automatically calls when you require an iterator for a container data type. This method should return a new iterator object, which allows you to iterate through all the items in the underlying container type.

For Python dictionaries, .__iter__() allows direct iteration over the keys by default. This means that if you use a dictionary directly in a for loop, Python will automatically call .__iter__() on that dictionary, and you’ll get an iterator that goes over its keys:

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}

>>> for key in likes:
...     print(key)
...
color
fruit
pet

Python is smart enough to know that likes is a dictionary and that it implements .__iter__(). In this example, Python calls .__iter__() automatically, and this allows you to iterate over the keys of likes without further effort on your side.

This is the primary way to iterate through a dictionary in Python. You just need to put the dictionary directly into a for loop, and you’re done!

If you use this approach along with the [key] operator, then you can access the values of your dictionary while you loop through the keys:

>>> for key in likes:
...     print(key, "->", likes[key])
...
color -> blue
fruit -> apple
pet -> dog

In this example, you use key and likes[key] at the same time to access your target dictionary’s keys and the values, respectively. This technique enables you to perform different operations on both the keys and the values of likes.

Even though iterating through a dictionary directly is pretty straightforward in Python, you’ll often find that dictionaries provide more convenient and explicit tools to achieve the same result. That’s the case with the .items() method, which defines a quick way to iterate over the items or key-value pairs of a dictionary.

Looping Over Dictionary Items: The .items() Method

When you’re working with dictionaries, iterating over both the keys and values at the same time may be a common requirement. The .items() method allows you to do exactly that. The method returns a view object containing the dictionary’s items as key-value tuples:

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}

>>> likes.items()
dict_items([('color', 'blue'), ('fruit', 'apple'), ('pet', 'dog')])

Dictionary view objects provide a dynamic view of the dictionary’s items. Here, dynamic means that when the dictionary changes, the views reflect those changes.

Views are iterable, so you can iterate through the items of a dictionary using the view object that results from calling .items(), as you can see in the example below:

>>> for item in likes.items():
...     print(item)
...
('color', 'blue')
('fruit', 'apple')
('pet', 'dog')

In this example, .items() returns a view object that yields key-value pairs one at a time and allows you to iterate through them.

If you take a closer look at the individual items that .items() yields, then you’ll note that they’re tuple objects:

>>> for item in likes.items():
...     print(item)
...     print(type(item))
...
('color', 'blue')
<class 'tuple'>
('fruit', 'apple')
<class 'tuple'>
('pet', 'dog')
<class 'tuple'>

In this updated loop, you use the built-in type() function to check the data type of every item that .items() yields. As you can confirm in the loop’s output, all the items are tuples. Once you know this, you can use tuple unpacking to iterate through the keys and values in parallel.

To achieve parallel iteration through keys and values, you just need to unpack the elements of every item into two different variables, one for the key and another for the value:

>>> for key, value in likes.items():
...     print(key, "->", value)
...
color -> blue
fruit -> apple
pet -> dog

The key and value variables in the header of your for loop do the unpacking. Every time the loop runs, key gets a reference to the current key, and value gets a reference to the value. This way, you have more control over the dictionary content. Therefore, you’ll be able to process the keys and values separately in a readable and Pythonic manner.

Iterating Through Dictionary Keys: The .keys() Method

Python dictionaries offer a second way for you to iterate through their keys. Apart from using the target dictionary directly in a loop, you can also use the .keys() method. This method returns a view object containing only the dictionary keys:

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}

>>> likes.keys()
dict_keys(['color', 'fruit', 'pet'])

The .keys() method returns an object that provides a dynamic view of the keys in likes. You can use this view object to iterate through the dictionary keys. To do this, call .keys() in the header of a for loop:

>>> for key in likes.keys():
...     print(key)
...
color
fruit
pet

When you call .keys() on likes, you get a view of keys. Python knows that view objects are iterable, so it starts looping.

You might wonder why you’d use .keys() instead of just iterating over the dictionary directly. The quick answer is that using .keys() explicitly allows you to better communicate the intention of iterating over the keys only.

Walking Through Dictionary Values: The .values() Method

Another common need that you’ll face when iterating through dictionaries is to loop over the values only. The way to do that is to use the .values() method, which returns a view with the values in the underlying dictionary:

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}

>>> likes.values()
dict_values(['blue', 'apple', 'dog'])

In this code, .values() returns a view object that yields values from likes. As with other view objects, the result of .values() is also iterable, so you can use it in a loop:

>>> for value in likes.values():
...     print(value)
...
blue
apple
dog

Using .values(), you only have access to the values of your target dictionary, likes. Note that this iteration tool doesn’t give you access to the key associated with each value. So, you should use this technique if you only need to access the values in the target dictionary.

Filtering Items by Their Value

Sometimes, you’ll be in situations where you have a dictionary and want to create a new one that only contains the data that satisfies a given condition. You can do this with a conditional statement while you traverse the dictionary. Consider the following toy example:

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}

>>> small_numbers = {}

>>> for key, value in numbers.items():
...     if value <= 2:
...         small_numbers[key] = value
...

>>> small_numbers
{'one': 1, 'two': 2}

In this example, you filter the items with a value less than 2 and add them to your small_numbers dictionary. This new dictionary only contains the items that satisfy the condition value <= 2, which is your filtering condition.

There’s another technique that you can use to filter items from a dictionary. Key view objects are like Python sets. So, they support set operations, such as union, intersection, and difference. You can take advantage of this set-like behavior to filter certain keys from a dictionary.

For example, in the code below, you use a set difference to filter out the citrus from your fruits dictionary:

>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}

>>> fruits.keys() - {"orange"}
{'apple', 'banana'}

When you run fruits.keys() - {"orange"}, you’re really running a set difference operation. You can use this trick to create a new dictionary without citrus fruits:

>>> non_citrus = {}

>>> for key in fruits.keys() - {"orange"}:
...     non_citrus[key] = fruits[key]
...

>>> non_citrus
{'apple': 0.4, 'banana': 0.25}

In this example, you build a new dictionary out of the set of keys that you get from computing the difference between your dictionary’s keys and a set of unwanted keys.

The fact that key view objects behave like sets is a little-known feature that can be useful in some situations. So, keep it in your tool kit.

Running Calculations With Keys and Values

Running calculations with a dictionary’s values while you iterate through the dictionary itself is another common task. Suppose you’ve stored the data for your company’s sales in a dictionary, and now you want to know the year’s total income.

To solve this problem, you can use an accumulator variable with an initial value of zero. Then, you can accumulate every value in your dictionary in that variable:

>>> incomes = {"apple": 5600.00, "orange": 3500.00, "banana": 5000.00}
>>> total_income = 0.00

>>> for income in incomes.values():
...     total_income += income
...

>>> total_income
14100.0

Here, you iterate through the values in your incomes dictionary and sequentially accumulate them in total_income. The augmented assignment total_income += income does the magic, and at the end of the loop, you get the total income for the year.

As with many tasks in Python, you’ll have a better way to do the same computation, as in the example below. You can use the built-in sum() function:

>>> sum(incomes.values())
14100.0

In this example, you pass the values in your incomes dictionary directly as an argument to sum(). The function implicitly iterates over the values and computes their sum in the process.

Even though the sum() solution is concise, fast, and readable, the loop solution is more generic and allows you to perform computations other than just summing up the values.

Swapping Keys and Values Through Iteration

Suppose you have a dictionary and need to turn keys into values and values into keys. In this situation, you can use a for loop to iterate through the original dictionary while you build the new one with swapped keys and values:

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> swapped = {}

>>> for key, value in numbers.items():
...     swapped[value] = key
...

>>> swapped
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

The expression swapped[value] = key does the hard work for you by swapping the keys and values in a new dictionary. Note that for this code to work, the data stored in the values of your original dictionary must be of a hashable data type. Otherwise, you’ll get an error.

Again, Python has other tools that allow you to write the previous example in a more concise way. This time, you can use the built-in zip() function along with the dict() constructor:

>>> dict(zip(numbers.values(), numbers.keys()))
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

In this example, you use zip() to generate tuples of value-key pairs. To do that zip() implicitly iterates over the values and keys of your numbers dictionary. Then you use the resulting tuples as arguments to dict() and build the desired dictionary.

Filtering Items by Their Value: Revisited

To filter items in a dictionary with a comprehension, you just need to add an if clause that defines your filtering condition. Earlier, you worked with the condition value <= 2. You can get the same result with a dictionary comprehension:

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}

>>> {key: value for key, value in numbers.items() if value <= 2}
{'one': 1, 'two': 2}

Now your resulting dictionary contains only the items that satisfy your condition. Compared to the previous section’s solution, this one is more concise and efficient.

Swapping Keys and Values Through Iteration: Revisited

You can also approach the problem of swapping keys and values using a dictionary comprehension. With this tool, you can write a more concise, Pythonic solution that’s also more efficient. Here’s how:

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}

>>> {value: key for key, value in numbers.items()}
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

With this comprehension, you create a new dictionary where the keys have taken the place of the values and vice versa. This new approach gives you the ability to write more readable, succinct, and efficient code.

Again, the condition for this code to work is the same one you saw before: the values must be hashable objects. Otherwise, you won’t be able to use them as keys for your new dictionary.

Iterating Over Sorted Keys

If you need to iterate through the keys of a dictionary in sorted order, then you can pass your dictionary as an argument to sorted(). You’ll get a list containing the keys in sorted order. This list will allow you to traverse your dictionary sorted by keys:

>>> incomes = {"apple": 5600.00, "orange": 3500.00, "banana": 5000.00}

>>> for fruit in sorted(incomes):
...     print(fruit, "->", incomes[fruit])
...
apple -> 5600.0
banana -> 5000.0
orange -> 3500.0

In this example, you sort the keys by calling sorted() with your dictionary as an argument. Note that you could’ve also used sorted(incomes.keys()) to get the same result. In both cases, you’ll get a list containing the keys of your dictionary in sorted order.

Note that the sorting order will depend on the data type of your keys and the internal rules that Python uses to sort that specific data type. In this example, Python sorts the keys using its internal rules for sorting strings. These rules are based on the characters’ Unicode code points. A further explanation of these internal rules is out of this tutorial’s scope.

Looping Through Sorted Values

You may also need to iterate through a Python dictionary with its items sorted by values. To do this, you can use sorted() too. This time, you’ll need to use a second argument called key when you call sorted(). This keyword-only argument specifies a one-argument function to extract a comparison key from the items that you’re processing.

To iterate through dictionary items sorted by value, you can write a function that returns the value of each item and then use this function as the key argument to sorted(). In the example below, you do this with a short lambda function:

>>> incomes = {"apple": 5600.00, "orange": 3500.00, "banana": 5000.00}

>>> for fruit, income in sorted(incomes.items(), key=lambda item: item[1]):
...     print(fruit, "->", income)
...
orange -> 3500.0
banana -> 5000.0
apple -> 5600.0

In this example, you define a lambda function and use it to sort the items of incomes by value with sorted(). The lambda function tells sorted() to sort incomes.items() by the second element of each item, item[1], which is the income value.

You may also want to iterate through the values of a dictionary in sorted order without considering the keys. In that case, you can use .values() to provide the augment for sorted(). Here’s a quick example:

>>> for income in sorted(incomes.values()):
...     print(income)
...
3500.0
5000.0
5600.0

Calling sorted() with incomes.values() as an argument returns the values of your dictionary in sorted order. Remember that the keys won’t be accessible if you use .values(). That’s okay. Sometimes, you don’t need the keys, just the values, and this is a quick way to access them.

Sorting a Dictionary With a Comprehension

What if you need to sort an existing dictionary and build a sorted one? As you already know, since Python 3.6, dictionaries remember the insertion order of their items. This feature allows you to sort the items of a dictionary using sorted() while you build a new dictionary with a comprehension:

>>> incomes = {"apple": 5600.00, "orange": 3500.00, "banana": 5000.00}

>>> {fruit: incomes[fruit] for fruit in sorted(incomes)}
{'apple': 5600.0, 'banana': 5000.0, 'orange': 3500.0}

>>> {
...      fruit: income
...      for fruit, income in
...      sorted(incomes.items(), key=lambda item: item[1])
... }
{'orange': 3500.0, 'banana': 5000.0, 'apple': 5600.0}

These comprehensions allow you to create new dictionaries with their items sorted by key and value, respectively. In both cases, the comprehension iterates over the original dictionary in sorted order and builds a new dictionary.

Iterating Through a Dictionary in Reverse-Sorted Order

If you need to traverse your dictionaries in reverse-sorted order, then you can use the reverse argument to sorted(). This argument takes a Boolean value. If you use True, then the items are sorted in reverse order:

>>> incomes = {"apple": 5600.00, "orange": 3500.00, "banana": 5000.00}

>>> for fruit in sorted(incomes, reverse=True):
...     print(fruit, "->", incomes[fruit])
...
orange -> 3500.0
banana -> 5000.0
apple -> 5600.0

In this example, you iterate over the keys of incomes in reverse-sorted order by using the reverse argument to sorted() in the header of your for loop. This example sorts the keys. Why don’t you try writing an example that sorts the values in reverse order?

Traversing a Dictionary in Reverse Order

Another possibility that Python offers when it comes to iterating through dictionaries is to use the built-in reversed() function. This function takes an iterable as an argument and returns an iterator that yields items in reverse order.

Using reversed(), you can traverse your dictionaries in reverse order:

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}

>>> for key, value in reversed(numbers.items()):
...     print(key, "->", value)
...
four -> 4
three -> 3
two -> 2
one -> 1

In this example, the call to reversed() yields items from numbers in reverse order. This enables you to iterate through your dictionary from right to left, which can be useful in some situations.

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

Python’s map() function takes a function object and an iterable as arguments. It returns an iterator that results from applying the input function to every item in the input iterable. You can use map() to iterate through dictionaries in Python by taking advantage of the function’s implicit loop.

Say you want to apply a price discount to all the products in your fruits dictionary. In this case, you can define a function that manages the discount and then use that function as the first argument to map(). Then you can use .items() to provide the iterable object:

>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}

>>> def apply_discount(product, discount=0.05):
...     return product[0], round(product[1] * (1 - discount), 2)
...

>>> dict(map(apply_discount, fruits.items()))
{'apple': 0.38, 'orange': 0.33, 'banana': 0.24}

>>> dict(map(lambda item: apply_discount(item, 0.1), fruits.items()))
{'apple': 0.34, 'orange': 0.3, 'banana': 0.22}

>>> dict(map(lambda item: apply_discount(item, 0.15), fruits.items()))
{'apple': 0.32, 'orange': 0.28, 'banana': 0.2}

In this code snippet, you define a function named apply_discount(), which applies a discount to the price of a given product. Then it returns a tuple containing the product and its new price.

The first call to map() iterates through the items of the dictionary, fruits.items(), and applies the default 5 percent discount to each fruit. In this case, you use the dict() constructor to generate a new dictionary from the data that map() returns.

In the second and third calls to map(), you wrap apply_discount() in a lambda function so that you can provide a different discount value to apply_discount(). This is a common technique that you can use when a tool like map() requires a function with a given number of arguments and your target function doesn’t match that number.

Filtering Items in a Dictionary: filter()

The built-in filter() function is another tool that you can use to implicitly iterate through a dictionary and filter its items according to a given condition. This tool also takes a function object and an iterable as arguments. It returns an iterator from those elements of the input iterable for which the function returns True.

Say that you want to extract the products with a price lower than 0.40 from your fruits dictionary. To do this, you can define a function to determine if the price satisfies that condition and pass the function as the first argument to filter(). Again, the second argument can be fruits.items(). Here’s the code to achieve this:

>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}

>>> def has_low_price(item, price=0.4):
...     return item[1] < price
...

>>> dict(filter(has_low_price, fruits.items()))
{'orange': 0.35, 'banana': 0.25}

You iterate through the items of fruits with filter(). The has_low_price() function compares the item’s price with a target price and returns True if the item’s price is less than the target. Otherwise, it returns False. As a result, you get only the items whose price is lower than the target.

To provide a different target price, you can use a lambda function as you did in the previous section. Go ahead and give it a try.

Iterating Through Multiple Dictionaries With ChainMap

The collections module from the standard library provides a specialized container type called ChainMap. It’s a dictionary-like class that you can use to create a single, updateable view out of multiple existing dictionaries. The resulting object will logically appear and behave as a single dictionary.

ChainMap doesn’t merge the input dictionaries together. Instead, it keeps them in an internal list. The input dictionaries can have duplicate keys. However, only the first instance of a duplicated key will be accessible in lookup and update operations.

Now, suppose you have two dictionaries containing different categories of products and their prices. You need to iterate through them together as one dictionary. To achieve this, you can create a ChainMap object and initialize it with your dictionaries:

>>> from collections import ChainMap

>>> fruits = {"apple": 0.40, "orange": 0.35}
>>> vegetables = {"pepper": 0.20, "onion": 0.55}

>>> catalog = ChainMap(fruits, vegetables)
>>> catalog
ChainMap({'apple': 0.4, 'orange': 0.35}, {'pepper': 0.2, 'onion': 0.55})

>>> for product, price in catalog.items():
...     print(product, "->", price)
...
pepper -> 0.2
onion -> 0.55
apple -> 0.4
orange -> 0.35

After importing ChainMap from collections, you need to create a ChainMap object with the dictionaries that you want to chain. Then you can freely iterate through the resulting object as you would do with a regular dictionary.

ChainMap objects have the same interface as regular dictionaries, so you can use .keys(), values(), and .items() to iterate through their different components.

When using ChainMap to iterate over multiple dictionaries in one go, you must keep in mind that if you have duplicate keys, then you’ll only be able to access the first instance of them. Consider the following example:

>>> from collections import ChainMap

>>> for_adoption = {"dogs": 10, "cats": 7, "pythons": 3}
>>> vet_treatment = {"dogs": 4, "cats": 3, "turtles": 1}
>>> pets = ChainMap(for_adoption, vet_treatment)

>>> for pet, count in pets.items():
...     print(pet, "->", count)
...
...
dogs -> 10
cats -> 7
turtles -> 1
pythons -> 3

In this example, the loop only went through the first instances of "dogs" and "cats". Therefore, you don’t get data from the duplicate instances of these keys.

Iterating Through a Chain of Dictionaries With chain()

The itertools module provides the chain() function, which can take multiple iterable objects as arguments and make an iterator that yields elements from all of them. To do its job, chain() starts yielding items from the first iterable until exhaustion, then the function yields items from the next iterable, and so on until all the input iterable objects are exhausted.

This behavior allows you to iterate through multiple dictionaries in a chain that goes through all the keys, even if there are repeated ones:

>>> from itertools import chain

>>> for_adoption = {"dogs": 10, "cats": 7, "pythons": 3}
>>> vet_treatment = {"dogs": 4, "cats": 3, "turtles": 1}
>>> pets = chain(for_adoption.items(), vet_treatment.items())

>>> for pet, count in pets:
...     print(pet, "->", count)
...
...
dogs -> 10
cats -> 7
pythons -> 3
dogs -> 4
cats -> 3
turtles -> 1

In the above code, chain() returns an iterator that yields items from for_adoption and vet_treatment. Note that unlike ChainMap, the chain() function gives you access to all the keys from your input dictionaries, even the duplicated ones.