Python Dictionary Items Function

Python is an object-oriented, interpreted scripting language used in a wide variety of programming fields. In this article, we’ll learn about the items() function in Python dictionaries, which returns an iterable view of all items in a dictionary.

What is a Python Dictionary?

In Python, a dictionary is a collection data type used to store key-value pairs. Unlike other data types, a dictionary is unordered, meaning its elements cannot be accessed using subscripts. To access an element in a dictionary, you must use the dictionary’s key.

For example, I have a dictionary called “caps” that contains the names of football teams and the cities they play in.

# Example Code
caps = {
"GSW": "Golden State Warriors",
"LAL": "Los Angeles Lakers",
"HOU": "Houston Rockets",
"MIA": "Miami Heat"
}

In the above example, we store team names and their cities in a dictionary, with each team name as a key and each corresponding city as a value.

Syntax of the Python Dictionary Items Function

The items function is a Python dictionary function that returns an iterable object of all the items in the dictionary. The syntax of items() is as follows:

dict.items()

In this syntax, dict is the dictionary object whose items are to be returned.

Python Dictionary items Function Example

Let’s take a look at the following example to see how to use the dictionary’s items function.

# Example Code
caps = {
"GSW": "Golden State Warriors",
"LAL": "Los Angeles Lakers",
"HOU": "Houston Rockets",
"MIA": "Miami Heat"
}

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

In the above example, we use a for loop to iterate over the items and their corresponding values in a dictionary. The items() function converts all items into (key, value) tuples and returns an iterable object. In this example, we unpack them into key and value variables and then print them to the console.

When you run the above code, you’ll see the following output:

GSW Golden State Warriors
LAL Los Angeles Lakers
HOU Houston Rockets
MIA Miami Heat

As you can see, the items() function returns a tuple of all the items in the dictionary. In this example, we use a simple for loop to iterate over each tuple and split it into its key and value. We then print these values to the console as output.

Another more common use case is serializing items() to JSON format:

# Example code
import json

caps = {
"GSW": "Golden State Warriors",
"LAL": "Los Angeles Lakers",
"HOU": "Houston Rockets",
"MIA": "Miami Heat"
}

print(json.dumps(list(caps.items())))

In the above example, we serialize the dictionary caps object to JSON format.

Python Dictionary items Function and Iteration

The Python dictionary’s items() function returns an iterable object containing all items. Since this object is iterable, it can be iterated over using a for loop.

In the following example, we use items() and a for loop to create a new dictionary that swaps the keys and values of all items. We use the team name as the value and the city as the key.

# Example Code
caps = {
"GSW": "Golden State Warriors",
"LAL": "Los Angeles Lakers",
"HOU": "Houston Rockets",
"MIA": "Miami Heat"
}

flipped = {}

for key, value in caps.items():
flipped[value] = key

print(flipped)

In the example above, we first create an empty dictionary called flipped. We then use a for loop and the items() function to iterate through all items in the caps dictionary and reverse their key-value pairs, using the team name as the key and the city as the value. Finally, we print the dictionary to verify the result. The output is as follows:

{'Golden State Warriors': 'GSW', 'Los Angeles Lakers': 'LAL', 'Houston Rockets': 'HOU', 'Miami Heat': 'MIA'}

Performance of Python Dictionary items Function

Python dictionaries are implemented as hash tables, with lookups and insertions performed in O(1) time. The items() function doesn’t perform any operations on the dictionary; it simply returns an iterable view, which gives it very high performance.

However, in some cases, you may need to convert the iterable view into a list. This can consume a significant amount of memory, depending on the number of items in the dictionary. If you’re dealing with small dictionaries, this won’t cause any problems. However, if the dictionary is very large, this can incur significant memory overhead, causing your program to pause and consuming significant CPU time.

Fortunately, with Python 2.7 and Python 3.x, you can use the iteritems() function instead of the items() function, which avoids creating at least one large array object in memory. However, in Python 3, iteritems() is deprecated, so you’ll need to use the items() function and manually convert it to a list.

Conclusion

In this article, we learned about the items() function in Python dictionaries, which returns an iterable view of all key-value pairs in a dictionary. We learned how to iterate over this view to retrieve each item and its corresponding value, and also learned how to convert an iterable view into a list object. Because the object returned by the items() function is iterable, it’s very useful when working with dictionaries, helping us quickly iterate over them while avoiding memory overhead. In real-world programming, this can greatly simplify code and improve program performance.