Ошибка 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'}

In this article, we will discuss what causes the “RuntimeError: dictionary changed size during iteration” error. In addition, you will know how to use copy(), keys() and some other methods to deal with this error, follow the details below.

In Python, RuntimeError is classed as exception error types. Errors usually occur when there is a problem with the logic of the program. Usually it’s pretty hard to spot while you’re coding. Suppose in this situation, when you enter the following program, the error “RuntimeError: dictionary changed size during iteration” occurred:

Error code

student = {
	"firstName": "Liza",
	"lastName": "Nguyen",
 	"yearofBirth": 2000
}

for s in student.keys():
    student["department"] = "IT"

print("student:", student)

Output:

---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-61-6bbcf4bfc185> in <module>
      5  }
      6 
----> 7 for s in student.keys():
      8     student["department"] ="IT"
      9 

RuntimeError: dictionary changed size during iteration

What causes error?

The error “RuntimeError: dictionary changed size during iteration” informs the coder that: During the execution of the loop instruction, the size of the visible word has been changed. That is, you cannot make modifications while iterating, which will cause a runtime error.

How to fix it?

To help you quickly and effectively solve the above error, we have summarized some methods below. Let’s take a look and choose the method that is suitable for you.

Solution 1: Using copy() function

The purpose of this method is that you can use the copy() function that Python provides to create a new copy that is not affected by the original. From there you can easily edit the copy while keeping the original.

For example:

import copy

student = {
 	"firstName": "Liza",
 	"lastName": "Nguyen",
 	"yearofBirth": 2000
}
copyStudent = copy.copy(student)
for s in copyStudent.keys():
    student["department"] = "IT"

print("student:", student)
print("copyStudent:", copyStudent)

Output:

student: {'firstName': 'Liza', 'lastName': 'Nguyen', 'yearofBirth': 2000, 'department': 'IT'}
copyStudent: {'firstName': 'Liza', 'lastName': 'Nguyen', 'yearofBirth': 2000}

Solution 2: Using keys() function

With this method, we will create a list of keywords in the dictionary and after returning the result will be a new unaffected list.

For instance:

student = {
 	"firstName": "Liza",
 	"lastName": "Nguyen",
 	"yearofBirth": 2000
}

keyStudent = list(student.keys())
print("keyStudent", keyStudent)

for key in keyStudent:
	if key == "yearofBirth":
    	student[key] = 2001
        
print("student", student)

Output:

keyStudent ['firstName', 'lastName', 'yearofBirth']
student {'firstName': 'Liza', 'lastName': 'Nguyen', 'yearofBirth': 2001}

Solution 3: Use the ** operator

This method will take the key-value pairs from one dictionary and pass it to another dictionary. This is also another way to get a copy of a dictionary or list.

Code sample:

student = {
   "firstName": "Liza",
   "lastName": "Nguyen",
   "yearofBirth": 2000
}

copyStudent = {**student}
for s in copyStudent.keys():
    student["department"] = "IT"

print("student:", student)
print("copyStudent:", copyStudent)

Output

student: {'firstName': 'Liza', 'lastName': 'Nguyen', 'yearofBirth': 2000, 'department': 'IT'}
copyStudent: {'firstName': 'Liza', 'lastName': 'Nguyen', 'yearofBirth': 2000}

Solution 4: Pass the new dictionary object to the list

With this method, by creating a cast list and manipulating changes through it, the iteration won’t cause the above error.

For example:

student = {
   "firstName": "Liza",
   "lastName": "Nguyen",
   "yearofBirth": 2000
}

for lst in list(student):
    student["department"] = "IT"

print("student:", student)

Output

student: {'firstName': 'Liza', 'lastName': 'Nguyen', 'yearofBirth': 2000, 'department': 'IT'}

Conclusion

This is how you are able to solve this type of task “RuntimeError: dictionary changed size during iteration”. However, we have provided relevant expertise to develop a more research-oriented mindset, and make it easier for you to answer these type questions. Please leave a message below if you have any questions or comments. Thanks for reading!

Maybe you are interested:

• Series Objects Are Mutable and Cannot be Hashed

In Python, you will get runtimeerror: dictionary changed size during iteration error when you modify, add new, or remove entries in a dictionary object when performing iterations on it. This post will walk you through the causes of this runtimeerror and ultimately the solutions to this Python error. Keep reading to find out why this is happening, in addition to how to fix it.

What Causes This Runtimeerror in Python?

Usually, Python will slap you with this error when you try to modify entries in a dictionary object during iteration. It occurs whenever iterating through a dictionary and virtually all iterable objects. To understand this error, below are some code snippets that illustrate that show the cause of this error by iterating through a dictionary and performing changes simultaneously.

– Example 1: Adding a New Dictionary Item While Iterating

Suppose you have a dictionary that holds the brand, model, and year of a vehicle. If you try to add a new item, say the color of the car during iteration, Python will throw this runtime error. Here is an example that generates this error:

vehicle = {
“Brand”: “Honda”,
“Model”: “Civic Type R”,
“Year”: 2022
}
print(vehicle)
for c in vehicle.keys():
vehicle[“color”] = “Blue”
print(c)

The above code tries to add color to the original dictionary during iteration, which returns the runtimeerror.

In this error, Python is letting you know that the size of the python dictionary was updated during iteration. It indicates that you cannot change the dictionary while simultaneously iterating. Keep in mind that during an iteration trying to delete, modify, or add an item to a python dictionary will not happen. Instead, Python will throw you this error.

– Example 2: Removing an Item From a Dictionary During Iteration

Suppose you now wish to delete an item like the year in the previous vehicle dictionary example. Attempting to delete the year while iterating will yield the same runtime error.

Here is the Python code that will generate the same error:

vehicle = {
“Brand”: “Honda”,
“Model”: “Civic Type R”,
“Year”: 2022
}
print(vehicle)
for c in vehicle.keys():
del vehicle[“Model”]
print(c)

When writing a program in Python, remember iterating a changing object is an unsafe and wrong style of coding. It is not just in Python, generally in programming, mutating an object while performing iterations on it is something you cannot do. The rule applies to other iterables like arrays and lists.

How To Solve This Runtime Error

With Python, you can solve this error in various ways. But first, you need to remember that if a function modifies an object, you must ensure the function only modifies a copy of the original. This way, you leave the original dictionary object untouched. This is one of the most common ways of altering objects when performing iterations simultaneously.

Creating a copy is a great way of getting rid of instances that create an infinite loop that can eventually result in memory exhaustion.

– Solution 1: Adding an Item to a Dictionary

Python provides the copy() module that you can use to generate a copy of an object without interfering with the original object. As such, you have the freedom to modify the copy as you wish. One thing you should note is that you will realize this using the assignment operator.

If you use the assignment operator, you will be creating a variable that uses the original object as the reference point instead of creating a copy of the original object. Therefore, any changes that take place in the new object will reflect in the original object. However, note that often, new developers tend to misuse this operator.

– Example 1: Using a Copy of the Original Dictionary

Suppose you wish to include color in the vehicle dictionary you created earlier. You can accomplish this like so:

import copy
vehicle = {
“Brand”: “Honda”,
“Model”: “Civic Type R”,
“Year”: 2022
}
#creating a shallow copy of the original object
vehicle_copy = copy.copy(vehicle)
for c in vehicle_copy.keys():
vehicle[“Color”] = “Blue”
print(“The output for the vehicle will be: “, vehicle)
print(“The output for the vehicle copy will be: “, vehicle_copy)

Running the above code will generate the following output:

Notice how you use the copy module to generate a copy of the original dictionary. Now using the copy, you had the freedom to iterate without interfering with the original dictionary. Modifying the copy allows you to iterate the original dictionary without generating the runtime error.

– Example 2: Using ** Operator

Alternatively, you can use the two asterisk operator to create a copy of the original dictionary like so:

import copy
vehicle = {
“Brand”: “Honda”,
“Model”: “Civic Type R”,
“Year”: 2022
}
#creating a copy of the original object
vehicle_copy = {**vehicle}
for c in vehicle_copy.keys():
vehicle[“Color”] = “Blue”
print(“The output for the vehicle will be: “, vehicle)
print(“The output for the vehicle copy will be: “, vehicle_copy)

Using the ** operator, Python lets you copy key-value pairs in one dictionary and then dump them into a different dictionary. Often, this Python operator is useful for passing keyword arguments. But, in this case, you use it to let Python copy the dictionary by unpacking the original dictionary and obtaining the key-value pairs within it. The operator then dumbs the unpacked values in the new dictionary.

If you run the code above, you will get the following output:

– Solution 2: Deleting an Item in the Dictionary

When removing a key-value pair in a dictionary, you still have to follow the same rules when performing iterations.

– Example 1: Using a Copy of the Original Dictionary

Suppose you want to let Python modify the dictionary while iterating, using the vehicle example, you may decide to delete the key named year together with its value (2022). You can accomplish this like so:

import copy
vehicle = {
“Brand”: “Honda”,
“Model”: “Civic Type R”,
“Year”: 2022
}
#creating a copy of the original object
vehicle_copy = copy.copy(vehicle)
for c in vehicle_copy.keys():
if c == “Year”:
del vehicle[“Year”]
print(“The output for the vehicle will be: “, vehicle)
print(“The output for the vehicle copy will be: “, vehicle_copy)

The output will be:

– Example 2: Using a Copy of the Keys

Another way you can delete the content of a dictionary is by creating a copy of the keys. you can then use the copy to iterate and modify the dictionary. This is another practical way of solving this error in Python.

vehicle = {
“Brand”: “Honda”,
“Model”: “Civic Type R”,
“Year”: 2022
}
#creating a copy of the original object
vehicle_copy = list(vehicle.keys())
print(“The output for the vehicle copy will be: “, vehicle_copy)
for c in list(vehicle_copy):
if vehicle[c] == “Year”:
vehicle.pop[“Year”]
print(“The output for the vehicle will be: “, vehicle)

The output is as follows:

– Solution 3: Casting Dictionary Objects to a List

Because you cannot iterate a dictionary and make changes simultaneously, you need to come up with a casting list that lets you iterate to modify a dictionary. This approach does not generate the runtime error.

– Example: Add an Item to a Dictionary

Suppose you decide to add color to the original vehicle dictionary, you can accomplish this by casting the dictionary to a list like so:

vehicle = {
“Brand”: “Honda”,
“Model”: “Civic Type R”,
“Year”: 2022
}
for c in list(vehicle):
vehicle[“Color”] = “Blue”
print(“The output for the vehicle will be: “, vehicle)

This will result in:

The output for the vehicle will be: {‘Brand’: ‘Honda’, ‘Model’: ‘Civic Type R’, ‘Year’: 2022, ‘Color’: ‘Blue’}

– Solution 4: Using an Empty List With Dictionary Keys

Another way of ensuring you do not modify the dictionary during iteration entails creating an empty list with dictionary keys to perform iterations on. You can then use the empty list to append all the keys you wish to modify. If you wish to delete an item, use the pop() function. Alternatively, you can use the append() function to add new items to a dictionary.

– Example 1: Removing an Item From a Dictionary

Say you want to let python delete the dictionary key while iterating. Here is an example of how you can use an empty list to delete items in a dictionary. Using the vehicle dictionary example, suppose you decide to delete the year. You can accomplish this like so:

vehicle = {
“Brand”: “Honda”,
“Model”: “Civic Type R”,
“Year”: 2022
}
list = []
for c in vehicle:
list.append(c)
for d in list:
if d == “Year”:
vehicle.pop(d)
print(“The output for the vehicle will be: “, vehicle)

The code above will generate the following output:

The output for the vehicle will be: {‘Brand’: ‘Honda’, ‘Model’: ‘Civic Type R’}

– Example 2: Adding New Items Using an Empty List

Suppose you want to add color to the vehicle dictionary you created earlier. Here is how you can accomplish this using an empty list without concerns of triggering the python list changed size during iteration warning:

vehicle = {
“Brand”: “Honda”,
“Model”: “Civic Type R”,
“Year”: 2022
}
list = []
for c in vehicle:
list.append(c)
for d in list:
vehicle[“Color”] = “Blue”
print(“The output for the vehicle will be: “, vehicle)

Running the above code will generate the following output:

The output for the vehicle will be: {‘Brand’: ‘Honda’, ‘Model’: ‘Civic Type R’, ‘Year’: 2022, ‘Color’: ‘Blue’}

Conclusion

If you get this error when programming in Python, there are a few things you should keep in mind:

• Check if you are trying to simultaneously modify a dictionary during iteration.
• In addition, you will get this error when trying to perform the same operations on arrays and lists
• To solve this error, you need to create a copy of the original dictionary
• Python lets you solve it using the ** operator, empty list, and casting list
• You can then modify the copy and the original dictionary without issues

With this understanding, you can now avoid the error and resolve it whenever it arises. Therefore, you can now modify a python dictionary without worrying about this runtime error.