Dictionary changed size during iteration как исправить

1. Creating a Shallow Copy of the Dictionary
2. Casting Dictionary Items to a List
3. Appending Keys to an Empty List

This Runtime error occurs when we remove, modify, or add new entries in a dictionary object during iteration. This error occurs when iterating through a dictionary but virtually all iterable objects regardless of the programming language used.

The code snippet below illustrates how this error comes about when iterating through a dictionary and making changes simultaneously.

cars = {
 "brand": "Tesla",
 "model": "Model S Plaid",
 "year":  2021
 }

for x in cars.keys():
  cars["color"] = "white"
print(x)

In the code block above, we add a new item to the original dictionary while iterating. This will return a Runtime Error, letting us know that the dictionary size changed during iteration, implying that we cannot modify the dictionary while iterating simultaneously.

Sample Code:

Traceback (most recent call last):
File "<string>", line 8, in <module>
RuntimeError: dictionary changed size during iteration

While performing any iteration to an object, both deletion, addition, or modification are considered an alteration and cannot be performed while iterating. The code example below demonstrates that this error will also persist if we modify the dictionary while iterating. Therefore, we will still get the same error if we remove an existing item from a dictionary while iterating.

Sample Code:

cars = {
 "brand": "Tesla",
 "model": "Model S Plaid",
 "year":  2021
 }

for x in cars.keys():
    del cars["model"]
print(cars)

Output:

Traceback (most recent call last):
File "<string>", line 8, in <module>
RuntimeError: dictionary changed size during iteration

In Python 3, iterating over a changing object is considered a bad style of writing code and unsafe. Generally, in Programming, we cannot mutate an object while iterating over it simultaneously; this rule extends to iterables such as lists and even arrays.

However, if a function mutates an object, we must make sure that the function only mutates a copy of the original object, leaving the original object intact. This is one of the widely used approaches of making alterations to objects while iterating through them simultaneously.

This is a good practice and the best way of avoiding instances of creating an infinite loop that may eventually lead to memory exhaustion. Several solutions can be used to handle this error, and we will discuss each one here.

Creating a Shallow Copy of the Dictionary

Python provides us with the copy() module that allows us to create a copy of an object with no binding to the original object. This lets us freely modify the copy of the object, leaving the original object intact.

Note that the same cannot be realized by using the assignment operator in Python. Using the assignment operator does not create a copy of the original object but rather a variable that refers to the original object.

Therefore any modifications made to the new object will also affect the original object. New developers often misuse this operator.

Sample Code:

import copy
cars = {
 "brand": "Tesla",
 "model": "Model S Plaid",
 "year":  2021,
 }

#creating a shallow copy
cars_copy = copy.copy(cars)

for x in cars_copy.keys():
    cars["color"] = "black"
    
print(cars)
print(cars_copy)

Output:

{'brand': 'Tesla', 'model': 'Model S Plaid', 'year': 2021, 'color': 'black'}
{'brand': 'Tesla', 'model': 'Model S Plaid', 'year': 2021}

In the sample code provided, we have used the copy module’s copy function to create a dictionary copy that we can freely iterate without affecting the original dictionary. Making changes to a dictionary copy allows us to iterate over the dictionary without encountering an error.

Alternatively, we can use the ** operator that is often referred to as the two asterisk operators to rewrite the code above, as shown below.

Sample Code:

cars = {
 "brand": "Tesla",
 "model": "Model S Plaid",
 "year":  2021
 }

#creating a shallow copy
cars_copy = {**cars}


for x in cars_copy.keys():
  cars["color"] = "black"
  
print(cars)

The ** operator can take key-value pairs from one dictionary and dump them into another dictionary.

Although the operator is widely used to pass in keyword arguments in Python, we have used the operator to unpack the dictionary and obtain the key-value pairs in the code above. We then create a copy of the dictionary and dump the unpacked values in this new dictionary.

Output:

'brand': 'Tesla', 'model': 'Model S Plaid', 'year': 2021, 'color': 'black'}

Deleting a key-value pair from a dictionary is no exception either when performing an iteration and thus should follow a similar approach. Therefore using the same procedure, we will delete the key named model and its value Model S Plaid as shown below.

Sample Code:

import copy
cars = {
 "brand": "Tesla",
 "model": "Model S Plaid",
 "year":  2021,
 "color": "black"
 }
 
cars_copy = copy.copy(cars)
 
for x in cars_copy.keys():
    if x == "model":
        del cars["model"]
   
print(cars)

Output:

{'brand': 'Tesla', 'year': 2021, 'color': 'black'}

Another solution would be to create a copy of the keys that we can then iterate over while modifying the dictionary. However, this can only work in Python 2 and not Python 3 because when done in Python 3, the keys do not return the iterable.

Sample Code:

cars = {
 "brand": "Tesla",
 "model": "Model S Plaid",
 "year":  2021,
 "color": "black"
 }

key_copys = list(cars.keys())
print(key_copys)

for key in list(key_copys):
    if cars[key] == "model":
        cars.pop("model")
        
print(cars)

Sample Output:

['brand', 'model', 'year', 'color']
{'brand': 'Tesla', 'model': 'Model S Plaid', 'year': 2021, 'color': 'black'}

Casting Dictionary Items to a List

Since we cannot iterate over the dictionary while making changes, we can instead create a casting list and iterate over the list while making changes to the dictionary. Iterating over the casting list instead of the original dictionary does not return a Runtime error.

Sample Code:

cars = {
 "brand": "Tesla",
 "model": "Model S Plaid",
 "year":  2021
 }

for i in list(cars):
    cars["color"] = "black"
    
print(cars)

Output:

{'brand': 'Tesla', 'model': 'Model S Plaid', 'year': 2021, 'color': 'black'}

Appending Keys to an Empty List

To avoid changing the dictionary while iterating, we can create an empty list containing the dictionary keys while we perform the iteration. Using this empty list, we can append all the keys that we want to remove or change and then use the pop() function to remove the keys or the append function to add new key-value pairs.

This can be executed as shown in the code below.

Sample Code:

cars = {
 "brand": "Tesla",
 "model": "Model S Plaid",
 "year":  2021
 }

list = []

for i in cars:
    list.append(i)
    
for x in list:
    if x == "model":
        cars.pop(x)
    
print(cars)

Output:

{'brand': 'Tesla', 'year': 2021}

As shown below, we can add a new key-value pair to the dictionary using the same procedure while iterating using the for loop.

Sample Code:

cars = {
 "brand": "Tesla",
 "model": "Model S Plaid",
 "year":  2021
 }
 
list = []

for i in cars:
    list.append(i)
    
for x in list:
    cars["color"] = "black"
  
print(cars)

Output:

{'brand': 'Tesla', 'model': 'Model S Plaid', 'year': 2021, 'color': 'black'}

The Runtimeerror: dictionary changed size during iteration occurs if we tend to change the size of the dictionary while iterating over it. This type of error is an exception error that pops up when the generated error does not fall into any other categories. This error can be resolved by the handlers who are handling exception clauses.

What is RuntimeError?

The RuntimeError is detected when the raised error does not belong to any other error categories. In this type of error, the values are associated with the strings, which shows the exact cause of the error. This error belongs to the exception error category.

In such errors, even though there are some mistakes in the syntax, it gets a pass until its execution. In this case, the interpreter will find the error and stop it with a message describing the exception.

Causes Of RuntimeError

• This type of error arises if there are some variables and function names that are misspelled or capitalized incorrectly but placed in the correct sequence then the syntax error will not arise, but as soon as you run the program, an error message will pop up, and the program would not be executed.
• Another instance where this type of error would cause is when you try to perform operations on the wrong data type.
• This type of error can also arise when the values which can not be converted into any integer get used with the “int” function.

The runtimeerror: dictionary changed size during iteration is the error that arises in python when we change the size of the dictionary, frequently used data structure during iteration.

If you are someone new and perhaps not acquainted with the terms, then here is a little help for you. Basically, Iteration is a term that is used when the sequences of instructions and codes are put until it gives an iterator as a result. Sometimes people confuse the term iterator with the term iterable due to its common nature. But these two terms have two completely different meanings. The Iterable is an object which uses the “__iter__” command to return an Iterator.

The runtimeerror: dictionary changed size during iteration is a self-explanatory error message which will arise when you try to add any entries during iteration. While you are looping in the iteration, you are not allowed do any kind of changes in the dictionary; hence when you try to do so, it generates the runtimeerror: dictionary changed size during iteration message.

E.g.

If someone wants to delete a value from the dictionary, the runtimeerror: dictionary changed size during iteration error will be caused.

my_dict = { 'x' : 1, 'y' : 2, 'z' : 3, 'a' : 4}

for i in my_dict:
    del my_dict["a"]
print (my_dict)     

Output:

Solution For Runtimeerror: Dictionary Changed Size During Iteration

If you face any runtimeerror: dictionary changed size during iteration error, you can use one of the methods mentioned below.

Making a shallow copy

By making a shallow copy, you can store the references of the original elements in the dictionary. it basically does not create or recurse the nested objects but stores their references. It is not the most convenient method, but it can surely create a solution for the runtimeerror: dictionary changed size during iteration error.

E.g.:

my_dict = { ' x ' : 1, ' y ' : 2, ' z ' : 3, ' a' : 4}

my_dict_copy = my_dict.copy()
for i in my_dict:
        del my_dict_copy[i]

print (my_dict)     
print(my_dict_copy)

Making a copy of Dictionary Keys

Instead of making a copy of the entire dictionary which can be a bit of a mess, you can create a copy of the dictionary keys and use them as iterators. This can give you a proper solution to the error message without taking up extra space as it will create only a copy of the required keys.

E.g.:

my_dict = { ' x ' : 1, ' y ' : 2, ' z ' : 3, ' a' : 4}

key_copy = tuple(my_dict.keys())
for a in key_copy:
           del my_dict[a] 

Using Deferred Update

If you want to take other ways than just creating copies of the present dictionary, you can opt for the deferred update method. This method prohibits any changes made during the programming from being applied to the database till the iteration is over. It is the most effective way to avoid the runtimeerror: dictionary changed size during iteration error message.

E.g.:

my_dict = { ' x ' : 1, ' y ' : 2, ' z ' : 3, ' a' : 4}

keys_to_be_removed = []
for i in my_dict:
    keys_to_be_removed.append(i)

for a in keys_to_be_removed:
    del my_dict[a]
  

FAQ

How to differentiate RuntimeError from SyntaxError?

A runtimeError is basically the error caused due to misspelling or misplacement in the syntax, which gets a pass for syntaxError but does not run. But on the other hand, the syntaxError is generally related to the placement and use of commands which get caught by the interpreter or compiler.

How do I get the size of a dictionary in Python?

To find the size of the dictionary, you can use the len() function. This function will return the size of the dictionary in terms of the number of key-value pairs present in the dictionary.

E.g.

my_dict = { ' x ' : 1, ' y ' : 2, ' z ' : 3, ' a' : 4}
print("The length of the dictionary is {}".format(len(my_dict)))

How do you check if a key exists in a dictionary in python?

You can check the existence of a key in a python dictionary using the has_key() method. If the key is available, it will return the output as a true or otherwise a false.

E.g.

def checkKey(dic, key):
     
    if dic.has_key(key):
        print("Present, value =", dic[key])
    else:
        print("Not present")
 
# Driver Function
my_dict = {'x': 1, 'b':2, 'z':3}
key = 'b'
checkKey(dic, key)
 
key = 'w'
checkKey(dic, key)

Conclusion

This article will help you find the cause for the RuntimeError: dictionary changed size during the iteration and will help you with its solution.

References

Dictionary

Learn more about error handling at PythonClear