Modificare un dict di Python durante l'iterazione su di esso

Diciamo di avere un dizionario Python de lo stiamo iterando in questo modo:

for k,v in d.iteritems():
    del d[f(k)] # remove some item
    d[g(k)] = v # add a new item

( fe gsono solo alcune trasformazioni della scatola nera.)

In altre parole, proviamo ad aggiungere / rimuovere elementi a dmentre iteriamo su di esso utilizzando iteritems.

È ben definito? Potresti fornire alcuni riferimenti per supportare la tua risposta?

(È abbastanza ovvio come risolvere questo problema se è rotto, quindi questo non è l'angolo che cerco.)

È esplicitamente menzionato nella pagina della documentazione di Python (per Python 2.7 ) che

L'utilizzo iteritems()durante l'aggiunta o l'eliminazione di voci nel dizionario può generare a RuntimeErroro non riuscire a eseguire l'iterazione su tutte le voci.

Allo stesso modo per Python 3 .

Lo stesso vale per iter(d), d.iterkeys()e d.itervalues(), e mi spingerò a dire che lo fa per for k, v in d.items():(non ricordo esattamente cosa forfa, ma non sarei sorpreso se l'implementazione chiamasse iter(d)).

Alex Martelli pesa su questo qui .

Potrebbe non essere sicuro cambiare il contenitore (es. Dict) durante il ciclo del contenitore. Quindi del d[f(k)]potrebbe non essere sicuro. Come sapete, la soluzione alternativa consiste nell'usare d.items()(per eseguire il ciclo su una copia indipendente del contenitore) anziché d.iteritems()(che utilizza lo stesso contenitore sottostante).

Va bene modificare il valore in un indice esistente del dict, ma l'inserimento di valori in nuovi indici (ad esempio d[g(k)]=v) potrebbe non funzionare.

Non puoi farlo, almeno con d.iteritems(). L'ho provato e Python non riesce con

RuntimeError: dictionary changed size during iteration

Se invece usi d.items(), allora funziona.

In Python 3, d.items()è una vista nel dizionario, come d.iteritems()in Python 2. Per farlo in Python 3, usa invece d.copy().items(). Allo stesso modo questo ci permetterà di iterare su una copia del dizionario per evitare di modificare la struttura dei dati su cui stiamo iterando.

Ho un grande dizionario contenente array Numpy, quindi la cosa dict.copy (). Keys () suggerita da @ murgatroid99 non era fattibile (sebbene funzionasse). Invece, ho appena convertito keys_view in un elenco e ha funzionato bene (in Python 3.4):

for item in list(dict_d.keys()):
    temp = dict_d.pop(item)
    dict_d['some_key'] = 1  # Some value

Mi rendo conto che questo non si immerge nel regno filosofico del funzionamento interno di Python come le risposte sopra, ma fornisce una soluzione pratica al problema dichiarato.

Il codice seguente mostra che questo non è ben definito:

def f(x):
    return x

def g(x):
    return x+1

def h(x):
    return x+10

try:
    d = {1:"a", 2:"b", 3:"c"}
    for k, v in d.iteritems():
        del d[f(k)]
        d[g(k)] = v+"x"
    print d
except Exception as e:
    print "Exception:", e

try:
    d = {1:"a", 2:"b", 3:"c"}
    for k, v in d.iteritems():
        del d[f(k)]
        d[h(k)] = v+"x"
    print d
except Exception as e:
    print "Exception:", e

Il primo esempio chiama g (k) e genera un'eccezione (la dimensione del dizionario cambia durante l'iterazione).

Il secondo esempio chiama h (k) e non genera eccezioni, ma restituisce:

{21: 'axx', 22: 'bxx', 23: 'cxx'}

Il che, guardando il codice, sembra sbagliato - mi sarei aspettato qualcosa del tipo:

{11: 'ax', 12: 'bx', 13: 'cx'}

Ho avuto lo stesso problema e ho usato la seguente procedura per risolvere questo problema.

Python List può essere iterato anche se lo modifichi durante l'iterazione su di esso. quindi per il codice successivo stamperà gli 1 all'infinito.

for i in list:
   list.append(1)
   print 1

Quindi usando list e dict in modo collaborativo puoi risolvere questo problema.

d_list=[]
 d_dict = {} 
 for k in d_list:
    if d_dict[k] is not -1:
       d_dict[f(k)] = -1 # rather than deleting it mark it with -1 or other value to specify that it will be not considered further(deleted)
       d_dict[g(k)] = v # add a new item 
       d_list.append(g(k))

Python 3 dovresti solo:

prefix = 'item_'
t = {'f1': 'ffw', 'f2': 'fca'}
t2 = dict() 
for k,v in t.items():
    t2[k] = prefix + v

oppure usa:

t2 = t1.copy()

Non dovresti mai modificare il dizionario originale, porta a confusione e potenziali bug o RunTimeErrors. A meno che non si aggiunga al dizionario solo nuovi nomi di chiavi.

Oggi ho avuto un caso d'uso simile, ma invece di materializzare semplicemente le chiavi sul dizionario all'inizio del ciclo, volevo che le modifiche al dict influenzassero l'iterazione del dict, che era un dict ordinato.

Ho finito per creare la seguente routine, che può essere trovata anche in jaraco.itertools :

def _mutable_iter(dict):
    """
    Iterate over items in the dict, yielding the first one, but allowing
    it to be mutated during the process.
    >>> d = dict(a=1)
    >>> it = _mutable_iter(d)
    >>> next(it)
    ('a', 1)
    >>> d
    {}
    >>> d.update(b=2)
    >>> list(it)
    [('b', 2)]
    """
    while dict:
        prev_key = next(iter(dict))
        yield prev_key, dict.pop(prev_key)

La docstring illustra l'utilizzo. Questa funzione potrebbe essere utilizzata al posto della d.iteritems()precedente per ottenere l'effetto desiderato.