scripting – How to delete items from a dictionary while iterating over it?

The Question :

319 people think this question is useful

Is it legitimate to delete items from a dictionary in Python while iterating over it?

For example:

for k, v in mydict.iteritems():
   if k == val:
     del mydict[k]

The idea is to remove elements that don’t meet a certain condition from the dictionary, instead of creating a new dictionary that’s a subset of the one being iterated over.

Is this a good solution? Are there more elegant/efficient ways?

The Question Comments :
  • A related question with very interesting answers:….
  • One could have tried easily. If it fails, it’s not legitimate.
  • @Trilarion One could have tried easily… and easily learned nothing of value. If it succeeds, it’s not necessarily legitimate. Edge cases and unexpected caveats abound. This question is of non-trivial interest to all would-be Pythonistas. Hand-waving dismissal on the order of “One could have tried easily!” is unhelpful and contrary to the inquisitive spirit of stackoverflow enquiry.
  • After perusing max‘s related question, I must concur. You probably just want to peruse that disturbingly in-depth question and its well-written answers instead. Your Pythonic mind will be blown.
  • @CecilCurry Testing an idea for yourself before presenting it here is kind of in the spirit of stackoverflow if I’m not mistaken. That was all I wanted to convey. Sorry if there has been any disturbance because of that. Also I think it is a good question and did not downvote it. I like the answer of Jochen Ritzel most. I don’t think one needs to do all that stuff to delete on the fly when deleting in a second step is much more simple. That should be the preferred way in my view.

The Answer 1

316 people think this answer is useful


This answer will not work for Python3 and will give a RuntimeError.

RuntimeError: dictionary changed size during iteration.

This happens because mydict.keys() returns an iterator not a list. As pointed out in comments simply convert mydict.keys() to a list by list(mydict.keys()) and it should work.

A simple test in the console shows you cannot modify a dictionary while iterating over it:

>>> mydict = {'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> for k, v in mydict.iteritems():
...    if k == 'two':
...        del mydict[k]
Traceback (most recent call last):
  File "<ipython console>", line 1, in <module>
RuntimeError: dictionary changed size during iteration

As stated in delnan’s answer, deleting entries causes problems when the iterator tries to move onto the next entry. Instead, use the keys() method to get a list of the keys and work with that:

>>> for k in mydict.keys():
...    if k == 'two':
...        del mydict[k]
>>> mydict
{'four': 4, 'three': 3, 'one': 1}

If you need to delete based on the items value, use the items() method instead:

>>> for k, v in mydict.items():
...     if v == 3:
...         del mydict[k]
>>> mydict
{'four': 4, 'one': 1}

The Answer 2

95 people think this answer is useful

You could also do it in two steps:

remove = [k for k in mydict if k == val]
for k in remove: del mydict[k]

My favorite approach is usually to just make a new dict:

# Python 2.7 and 3.x
mydict = { k:v for k,v in mydict.items() if k!=val }
# before Python 2.7
mydict = dict((k,v) for k,v in mydict.iteritems() if k!=val)

The Answer 3

23 people think this answer is useful

Iterate over a copy instead, such as the one returned by items():

for k, v in list(mydict.items()):

The Answer 4

21 people think this answer is useful

You can’t modify a collection while iterating it. That way lies madness – most notably, if you were allowed to delete and deleted the current item, the iterator would have to move on (+1) and the next call to next would take you beyond that (+2), so you’d end up skipping one element (the one right behind the one you deleted). You have two options:

  • Copy all keys (or values, or both, depending on what you need), then iterate over those. You can use .keys() et al for this (in Python 3, pass the resulting iterator to list). Could be highly wasteful space-wise though.
  • Iterate over mydict as usual, saving the keys to delete in a seperate collection to_delete. When you’re done iterating mydict, delete all items in to_delete from mydict. Saves some (depending on how many keys are deleted and how many stay) space over the first approach, but also requires a few more lines.

The Answer 5

11 people think this answer is useful

It’s cleanest to use list(mydict):

>>> mydict = {'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> for k in list(mydict):
...     if k == 'three':
...         del mydict[k]
>>> mydict
{'four': 4, 'two': 2, 'one': 1}

This corresponds to a parallel structure for lists:

>>> mylist = ['one', 'two', 'three', 'four']
>>> for k in list(mylist):                            # or mylist[:]
...     if k == 'three':
...         mylist.remove(k)
>>> mylist
['one', 'two', 'four']

Both work in python2 and python3.

The Answer 6

10 people think this answer is useful

With python3, iterate on dic.keys() will raise the dictionary size error. You can use this alternative way:

Tested with python3, it works fine and the Error “dictionary changed size during iteration” is not raised:

my_dic = { 1:10, 2:20, 3:30 }
# Is important here to cast because ".keys()" method returns a dict_keys object.
key_list = list( my_dic.keys() )

# Iterate on the list:
for k in key_list:
    del( my_dic[k] )

print( my_dic )
# {}

The Answer 7

9 people think this answer is useful

You can use a dictionary comprehension.

d = {k:d[k] for k in d if d[k] != val}

The Answer 8

4 people think this answer is useful

You could first build a list of keys to delete, and then iterate over that list deleting them.

dict = {'one' : 1, 'two' : 2, 'three' : 3, 'four' : 4}
delete = []
for k,v in dict.items():
    if v%2 == 1:
for i in delete:
    del dict[i]

The Answer 9

3 people think this answer is useful

There is a way that may be suitable if the items you want to delete are always at the “beginning” of the dict iteration

while mydict:
    key, value = next(iter(mydict.items()))
    if should_delete(key, value):
       del mydict[key]

The “beginning” is only guaranteed to be consistent for certain Python versions/implementations. For example from What’s New In Python 3.7

the insertion-order preservation nature of dict objects has been declared to be an official part of the Python language spec.

This way avoids a copy of the dict that a lot of the other answers suggest, at least in Python 3.

The Answer 10

1 people think this answer is useful

I tried the above solutions in Python3 but this one seems to be the only one working for me when storing objects in a dict. Basically you make a copy of your dict() and iterate over that while deleting the entries in your original dictionary.

        tmpDict = realDict.copy()
        for key, value in tmpDict.items():
            if value:

Add a Comment