Modifier un dict Python tout en l'itérant

Disons que nous avons un dictionnaire Python d, et nous l'itérons comme suit:

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

( fet ne gsont que quelques transformations de boîte noire.)

En d'autres termes, nous essayons d'ajouter / supprimer des éléments dtout en l'itérant en utilisant iteritems.

Est-ce bien défini? Pourriez-vous fournir quelques références pour étayer votre réponse?

(Il est assez évident de résoudre ce problème s'il est cassé, donc ce n'est pas l'angle que je recherche.)

Il est explicitement mentionné sur la page de documentation Python (pour Python 2.7 ) que

L'utilisation iteritems()lors de l'ajout ou de la suppression d'entrées dans le dictionnaire peut déclencher une RuntimeErroritération ou échouer sur toutes les entrées.

De même pour Python 3 .

De même pour iter(d), d.iterkeys()et d.itervalues(), et je vais aller aussi loin que de dire que le fait pour for k, v in d.items():(je ne me souviens pas exactement ce que forfait, mais je ne serais pas surpris si la mise en œuvre appelée iter(d)).

Alex Martelli y réfléchit ici .

Il peut ne pas être prudent de changer le conteneur (par exemple, dict) en boucle sur le conteneur. Alors del d[f(k)]peut-être pas sûr. Comme vous le savez, la solution de contournement consiste à utiliser d.items()(pour boucler sur une copie indépendante du conteneur) au lieu de d.iteritems()(qui utilise le même conteneur sous-jacent).

Il est normal de modifier la valeur à un index existant du dict, mais l'insertion de valeurs à de nouveaux index (par exemple d[g(k)]=v) peut ne pas fonctionner.

Vous ne pouvez pas faire cela, du moins avec d.iteritems(). Je l'ai essayé, et Python échoue avec

RuntimeError: dictionary changed size during iteration

Si vous utilisez à la place d.items(), cela fonctionne.

En Python 3, d.items()est une vue dans le dictionnaire, comme d.iteritems()en Python 2. Pour faire cela en Python 3, utilisez plutôt d.copy().items(). Cela nous permettra également de parcourir une copie du dictionnaire afin d'éviter de modifier la structure de données sur laquelle nous itérons.

J'ai un grand dictionnaire contenant des tableaux Numpy, donc la chose dict.copy (). Keys () suggérée par @ murgatroid99 n'était pas faisable (même si cela fonctionnait). Au lieu de cela, je viens de convertir le keys_view en une liste et cela a bien fonctionné (en Python 3.4):

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

Je me rends compte que cela ne plonge pas dans le domaine philosophique du fonctionnement interne de Python comme les réponses ci-dessus, mais cela fournit une solution pratique au problème déclaré.

Le code suivant montre que cela n'est pas bien défini:

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

Le premier exemple appelle g (k) et lève une exception (le dictionnaire a changé de taille pendant l'itération).

Le deuxième exemple appelle h (k) et ne lève aucune exception, mais renvoie:

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

Ce qui, en regardant le code, semble faux - je me serais attendu à quelque chose comme:

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

J'ai eu le même problème et j'ai utilisé la procédure suivante pour résoudre ce problème.

La liste Python peut être itérée même si vous modifiez lors de l'itération dessus. donc pour le code suivant, il imprimera les 1 à l'infini.

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

Donc, en utilisant list et dict en collaboration, vous pouvez résoudre ce problème.

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, vous devriez simplement:

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

Ou utiliser:

t2 = t1.copy()

Vous ne devez jamais modifier le dictionnaire original, cela entraîne de la confusion ainsi que des bogues potentiels ou des RunTimeErrors. Sauf si vous ajoutez simplement au dictionnaire de nouveaux noms de clé.

Aujourd'hui, j'avais un cas d'utilisation similaire, mais au lieu de simplement matérialiser les clés du dictionnaire au début de la boucle, je voulais que les modifications du dict affectent l'itération du dict, qui était un dict ordonné.

J'ai fini par créer la routine suivante, qui peut également être trouvée dans 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 illustre l'utilisation. Cette fonction pourrait être utilisée à la place de d.iteritems()ci - dessus pour avoir l'effet souhaité.