When to use iteritems() vs items() in Python 3?

General Discussions
, ,
1

When should iteritems() be used instead of items() in Python 3?

Is it appropriate to use items() instead of iteritems() everywhere in Python 3? Why was iteritems() removed in Python 3, as it seems like a very useful method? What’s the reasoning behind its removal?

Edit: To clarify, I want to understand the correct way to iterate over a dictionary in a generator-like manner (one item at a time, not loading everything into memory) that is compatible with both Python 2 and Python 3, specifically using the iteritems Python 3 approach.

2

So, I’ve worked a fair bit with Python 2.x and 3.x, and I can tell you, the behavior of .items() changed significantly between the two versions. In Python 2.x, .items() returned a list of (key, value) pairs. But in Python 3.x, .items() now returns an itemview object, which is a bit different. It doesn’t behave like a list by default, so if you want to work with it like in Python 2.x, you’d need to convert it to a list using list(dict.items()).

For backward compatibility, Python 2.7 has these methods like viewkeys, viewitems, and viewvalues. If I had to pick, viewkeys is super handy when you want to do set operations, like finding common keys between two dictionaries:

common_keys = list(dict_a.viewkeys() & dict_b.viewkeys())

In Python 3.x, we don’t need these back-ported methods. You can just use .keys() for key views and .items() for iterating over the dictionary lazily. That’s the big thing with Python 3—it’s all about a “lazy” approach. You don’t have to worry about iteritems() Python 3 anymore, which makes it cleaner to work with.

3

Totally agree with @prynka.chatterjee, and just to add on to that, if you’re looking to iterate lazily over key-value pairs in Python 3, you should simply use .items(). The nice thing about it in Python 3 is that it’s now more efficient because it returns an iterator, so you don’t have to explicitly use iteritems() like we did in Python 2. Here’s how I usually do it:

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

This way, Python 3 does all the heavy lifting under the hood and you get that lazy iteration, which can be a big performance win when working with larger datasets. So, the takeaway here: just use .items() in Python 3—no need for iteritems() Python 3 isn’t missing anything!

4

Ah, yes, if you’ve ever had to work across both Python versions, this can get a bit tricky. When you’re dealing with older codebases or need compatibility between Python 2 and 3, wrapping the .items() and .iteritems() in a try-except block is a smart move. I usually do it like this:

try:
    # Python 3
    items = dict.items()
except AttributeError:
    # Python 2
    items = dict.iteritems()

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

With this, you’re set regardless of whether the code runs in Python 2 or Python 3. It ensures that you’re always using the right method based on the Python version. But remember, in Python 3, you’re already getting lazy iteration with .items(), so there’s no need to worry about iteritems() Python 3-specific details anymore. This is how I keep things neat and maintain compatibility when working with mixed environments.