5 Best Ways to Loop Through a Dictionary in Python

by

💡 Problem Formulation: In Python, dictionaries are a versatile data structure that allows you to store pairs of keys and values. Looping through a dictionary commonly means accessing each key, value, or both, to perform operations. For example, given a dictionary {"apple": 1, "banana": 2, "cherry": 3}, one might want to print each fruit (key) and its respective count (value).

Method 1: Using dict.items()

The dict.items() method returns a view object that displays a list of dictionary’s (key, value) tuple pairs. It is a clean and Pythonic way to iterate over both keys and values at once, which is convenient when you need access to items without modifying the original dictionary.

♥️ Info: Are you AI curious but you still have to create real impactful projects? Join our official AI builder club on Skool (only $5): SHIP! - One Project Per Month

Here’s an example:

fruits = {"apple": 1, "banana": 2, "cherry": 3}
for fruit, count in fruits.items():
    print(f"The count of {fruit} is {count}")

Output:

The count of apple is 1
The count of banana is 2
The count of cherry is 3

This code uses the .items() method to loop through the dictionary, unpacking each item into fruit and count variables, which are then printed in a formatted string.

Method 2: Iterating Over Keys Using dict.keys()

The dict.keys() method is used to iterate over the keys of a dictionary. It’s particularly useful when you are only interested in keys and do not need the values. The keys are provided in an arbitrary order.

Here’s an example:

fruits = {"apple": 1, "banana": 2, "cherry": 3}
for fruit in fruits.keys():
    print(f"{fruit}")

Output:

apple
banana
cherry

This snippet loops through the keys of the dictionary using .keys() and prints each key. Although .keys() is optional (as simply using for fruit in fruits: would suffice), it enhances readability.

Method 3: Iterating Over Values Using dict.values()

Similarly, the dict.values() method allows you to iterate over the values of a dictionary. This method comes in handy when the keys are not necessary for the operation you need to perform on the values.

Here’s an example:

fruits = {"apple": 1, "banana": 2, "cherry": 3}
for count in fruits.values():
    print(count)

Output:

1
2
3

Each value in the dictionary is accessed using the .values() method and printed, demonstrating how one focuses solely on values within the iteration.

Method 4: Using a Comprehension to Create a Derived Collection

Python’s powerful comprehension feature can be used to construct a new collection from a dictionary while iterating over it. This is concise and allows for quick data manipulation or filtering based on conditions within a single line of code.

Here’s an example:

fruits = {"apple": 1, "banana": 2, "cherry": 3}
fruit_counts = [f"{fruit} has {count}" for fruit, count in fruits.items()]
print(fruit_counts)

Output:

['apple has 1', 'banana has 2', 'cherry has 3']

A new list named fruit_counts is created, containing formatted strings that describe the count of each fruit. The comprehension iterates over items in the dictionary, and for each item, it adds a new string to the list.

Bonus One-Liner Method 5: Iterating Using map() and lambda

For those who prefer functional programming style, the map() function combined with a lambda expression can be used to iterate over a dictionary. This one-liner approach transforms each dictionary item into a new form without using an explicit loop.

Here’s an example:

fruits = {"apple": 1, "banana": 2, "cherry": 3}
print(list(map(lambda item: f"{item[0]} has {item[1]}", fruits.items())))

Output:

['apple has 1', 'banana has 2', 'cherry has 3']

This snippet uses map() to apply a lambda function to each item in fruits.items(), with the lambda function formatting the key-value pair before transforming them into a list of strings.

Summary/Discussion

  • Method 1: Using dict.items(): Ideal for accessing both keys and values. Preserves the relationship between key-value pairs. Cannot directly modify the dictionary while iterating.
  • Method 2: Iterating Over Keys Using dict.keys(): Best when only keys are of interest. Ensures clarity that only keys are being used. Slightly more verbose when keys alone are sufficient.
  • Method 3: Iterating Over Values Using dict.values(): Perfect for operations requiring values only. Eliminates the distraction of keys. Not suitable when keys are also needed.
  • Method 4: Using a Comprehension: Concise for creating new collections. Enables inline conditional logic. Less readable for complex operations.
  • Bonus One-Liner Method 5: Using map() and lambda: Compact functional programming style, very concise. May obscure readability for those not familiar with functional constructs.