¿Cómo evitar el error "RuntimeError: el diccionario cambió de tamaño durante la iteración"?

He revisado todas las otras preguntas con el mismo error y aún no he encontrado una solución útil = /

Tengo un diccionario de listas:

d = {'a': [1], 'b': [1, 2], 'c': [], 'd':[]}

en el que algunos de los valores están vacíos. Al final de crear estas listas, quiero eliminar estas listas vacías antes de devolver mi diccionario. Actual Estoy intentando hacer esto de la siguiente manera:

for i in d:
    if not d[i]:
        d.pop(i)

Sin embargo, esto me está dando el error de tiempo de ejecución. Soy consciente de que no se pueden agregar / eliminar elementos en un diccionario mientras se itera a través de él ... ¿cuál sería una forma de evitar esto entonces?

En Python 2.x, la llamada keyshace una copia de la clave sobre la que puede iterar mientras modifica dict:

for i in d.keys():

Tenga en cuenta que esto no funciona en Python 3.x porque keysdevuelve un iterador en lugar de una lista.

Otra forma es usar listpara forzar una copia de las claves a realizar. Este también funciona en Python 3.x:

for i in list(d):

Simplemente use la comprensión del diccionario para copiar los elementos relevantes en un nuevo dict

>>> d
{'a': [1], 'c': [], 'b': [1, 2], 'd': []}
>>> d = { k : v for k,v in d.iteritems() if v}
>>> d
{'a': [1], 'b': [1, 2]}

Para esto en Python 3

>>> d
{'a': [1], 'c': [], 'b': [1, 2], 'd': []}
>>> d = { k : v for k,v in d.items() if v}
>>> d
{'a': [1], 'b': [1, 2]}

Solo necesita usar "copiar":

De esa manera, usted itera sobre los campos del diccionario original y sobre la marcha puede cambiar el dict deseado (d dict). Funciona en cada versión de Python, por lo que es más claro.

In [1]: d = {'a': [1], 'b': [1, 2], 'c': [], 'd':[]}

In [2]: for i in d.copy():
   ...:     if not d[i]:
   ...:         d.pop(i)
   ...:         

In [3]: d
Out[3]: {'a': [1], 'b': [1, 2]}

Intentaría evitar insertar listas vacías en primer lugar, pero, en general, usaría:

d = {k: v for k,v in d.iteritems() if v} # re-bind to non-empty

Si es anterior a 2.7:

d = dict( (k, v) for k,v in d.iteritems() if v )

o solo:

empty_key_vals = list(k for k in k,v in d.iteritems() if v)
for k in empty_key_vals:
    del[k]

Para Python 3:

{k:v for k,v in d.items() if v}

No puede iterar a través de un diccionario mientras está cambiando durante el ciclo for. Hacer un casting para enumerar e iterar sobre esa lista, funciona para mí.

    for key in list(d):
        if not d[key]: 
            d.pop(key)

Para situaciones como esta, me gusta hacer una copia profunda y recorrer esa copia mientras modifico el dict original.

Si el campo de búsqueda está dentro de una lista, puede enumerar en el bucle for de la lista y luego especificar la posición como índice para acceder al campo en el dict original.

Esto funcionó para mí:

dict = {1: 'a', 2: '', 3: 'b', 4: '', 5: '', 6: 'c'}
for key, value in list(dict.items()):
    if (value == ''):
        del dict[key]
print(dict)
# dict = {1: 'a', 3: 'b', 6: 'c'}  

La conversión de los elementos del diccionario a la lista crea una lista de sus elementos, para que pueda iterar sobre ella y evitar el RuntimeError.

dictc = {"stName": "asas"} keys = dictc.keys () para la clave en la lista (keys): dictc [key.upper ()] = 'Nuevo valor' print (str (dictc))

La razón del error de tiempo de ejecución es que no puede iterar a través de una estructura de datos mientras su estructura cambia durante la iteración.

Una forma de lograr lo que está buscando es usar la lista para agregar las claves que desea eliminar y luego usar la función pop en el diccionario para eliminar la clave identificada mientras recorre la lista.

d = {'a': [1], 'b': [1, 2], 'c': [], 'd':[]}
pop_list = []

for i in d:
        if not d[i]:
                pop_list.append(i)

for x in pop_list:
        d.pop(x)
print (d)

Python 3 no permite la eliminación al iterar (usando para el bucle anterior) diccionario. Hay varias alternativas para hacer; una forma simple es cambiar la siguiente línea

for i in x.keys():

Con

for i in list(x)