Como evitar o erro "RuntimeError: dicionário alterado de tamanho durante a iteração"?

Verifiquei todas as outras perguntas com o mesmo erro e ainda não encontrei uma solução útil = /

Eu tenho um dicionário de listas:

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

em que alguns dos valores estão vazios. No final da criação dessas listas, desejo remover essas listas vazias antes de retornar meu dicionário. Atualmente, estou tentando fazer o seguinte:

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

no entanto, isso está me dando o erro de tempo de execução. Estou ciente de que você não pode adicionar / remover elementos em um dicionário enquanto itera através dele ... o que seria uma maneira de contornar isso então?

No Python 2.x, a chamada keysfaz uma cópia da chave que você pode iterar enquanto modifica dict:

for i in d.keys():

Observe que isso não funciona no Python 3.x porque keysretorna um iterador em vez de uma lista.

Outra maneira é usar listpara forçar uma cópia das chaves a serem feitas. Este também funciona no Python 3.x:

for i in list(d):

Basta usar a compreensão do dicionário para copiar os itens relevantes para um novo ditado

>>> 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 isso em 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]}

Você só precisa usar "copiar":

Dessa maneira, você itera sobre os campos originais do dicionário e, em tempo real, pode alterar o ditado desejado (dict). É um trabalho em cada versão python, por isso é mais 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]}

Eu tentaria evitar a inserção de listas vazias em primeiro lugar, mas geralmente usaria:

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

Se anterior a 2.7:

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

ou apenas:

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}

Você não pode percorrer um dicionário enquanto ele estiver sendo alterado durante o loop for. Faça um casting para listar e itere sobre essa lista, funciona para mim.

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

Para situações como essa, eu gosto de fazer uma cópia profunda e fazer um loop através dessa cópia enquanto modifica o ditado original.

Se o campo de pesquisa estiver em uma lista, você poderá enumerar no loop for da lista e especificar a posição como índice para acessar o campo no ditado original.

Isso funcionou para mim:

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'}  

A conversão dos itens do dicionário para a lista cria uma lista de seus itens, para que você possa iterar sobre ele e evitar o RuntimeError.

dictc = {"stName": "asas"} chaves = dictc.keys () para a chave na lista (chaves): dictc [key.upper ()] = 'Novo valor' print (str (dictc))

O motivo do erro de tempo de execução é que você não pode iterar através de uma estrutura de dados enquanto sua estrutura está sendo alterada durante a iteração.

Uma maneira de conseguir o que você está procurando é usar a lista para anexar as chaves que você deseja remover e, em seguida, usar a função pop no dicionário para remover a chave identificada enquanto percorre a 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)

O Python 3 não permite a exclusão ao iterar (usando o loop for acima). Existem várias alternativas para fazer; Uma maneira simples é mudar a seguinte linha

for i in x.keys():

Com

for i in list(x)