Understanding the “AttributeError: ‘dict’ object has no attribute ‘iteritems’” in Python 3

If you are working with Python 3 and encounter an error like this:

AttributeError: 'dict' object has no attribute 'iteritems'

You’re not alone! This issue frequently appears when code that was originally written for Python 2 is run in Python 3. It often happens when dealing with dictionary methods like iteritems().

Why Does This Happen?

In Python 2, dictionaries had several methods like iteritems(), iterkeys(), and itervalues() which were commonly used to iterate over dictionary items, keys, or values, respectively. However, these methods were removed in Python 3 as part of a broader update to the language to make it more memory efficient.

In Python 3, dict.items(), dict.keys(), and dict.values() return views instead of lists, which is similar to the functionality provided by iteritems() in Python 2. This means that if you’re migrating Python 2 code to Python 3, you need to update any use of iteritems() to items().

The Fix

To resolve this issue, replace the old iteritems() method with items(). Let’s take a look at an example of how to do this.

Example: Refactoring Python 2 Code to Python 3

Here’s an example where you might run into this issue:

Python 2 Code:

# Python 2 code with iteritems()
my_dict = {'a': 1, 'b': 2, 'c': 3}

for key, value in my_dict.iteritems():
    print(f"{key}: {value}")

Python 3 Code:

The equivalent Python 3 code looks like this:

# Python 3 code with items()
my_dict = {'a': 1, 'b': 2, 'c': 3}

for key, value in my_dict.items():
    print(f"{key}: {value}")

Why The Change?

In Python 2, iteritems() was used to return an iterator that yielded dictionary items without creating a list in memory. This was more memory-efficient than using items(), which would return a full list of dictionary items.

However, starting with Python 3, items() now returns a dictionary view, which is similar to the iterator that iteritems() used to return in Python 2. Therefore, iteritems() was removed, and items() became the preferred method.

Performance Implications

Let’s compare the performance of the old items() vs iteritems() in Python 2 and why items() in Python 3 is more efficient:

Python 2 Benchmark:

import timeit

my_dict = {i: i * 2 for i in xrange(1000000)}

# Time taken with items()
start = timeit.default_timer()
for key, value in my_dict.items():
    pass
time_with_items = timeit.default_timer() - start

# Time taken with iteritems()
start = timeit.default_timer()
for key, value in my_dict.iteritems():
    pass
time_with_iteritems = timeit.default_timer() - start

print(f"Time with items: {time_with_items}")
print(f"Time with iteritems: {time_with_iteritems}")

Python 3 Equivalent:

In Python 3, we don’t need to worry about this distinction because items() now acts as an iterator:

import timeit

my_dict = {i: i * 2 for i in range(1000000)}

# Time taken with items()
start = timeit.default_timer()
for key, value in my_dict.items():
    pass
time_with_items = timeit.default_timer() - start

print(f"Time with items: {time_with_items}")

Python 3 Code Example: Using items() Efficiently

Let’s look at a practical example of using dictionaries in Python 3 where we efficiently retrieve and process key-value pairs using items().

# Example dictionary of student scores
student_scores = {'Alice': 90, 'Bob': 85, 'Charlie': 92}

# Find the student with the highest score
max_score = max(student_scores.values())
top_student = [name for name, score in student_scores.items() if score == max_score]

print(f"Top student: {top_student[0]} with score {max_score}")

In this example, items() is used to iterate over the dictionary and find the student with the highest score. This code is both Python 2 and 3 compatible if using items() in Python 3.

If you encounter the AttributeError: 'dict' object has no attribute 'iteritems', it’s a sign that you’re using a Python 2-specific method in Python 3. The solution is simple—replace iteritems() with items(). This small change brings your code into the Python 3 world, where items() offers the same functionality as iteritems() did in Python 2, but with the added advantage of memory efficiency.

Whether you’re migrating an old project from Python 2 to Python 3 or maintaining cross-version compatibility, making this adjustment will help ensure your dictionary operations are smooth and efficient in Python 3.