La modification d'un Python dict lors de l'itération sur elle

Disons que nous avons un dictionnaire Python d, et nous sommes une itération sur elle comme:

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

(f et g sont juste quelques-noir-boîte de transformations.)

En d'autres termes, nous essayons d'ajouter/supprimer des éléments à d lors de l'itération sur l'aide de iteritems.

Est-ce bien défini? Pourriez-vous donner quelques références à l'appui de votre réponse?

(Il est assez évident de comment résoudre ce problème si c'est cassé, donc ce n'est pas l'angle que je suis après.)

double possible de python - pourquoi n'est-il pas sûr de modifier la séquence de itérée sur?
Voir stackoverflow.com/questions/5384914/...
J'ai essayé de le faire et il semble que si vous laissez initiale dict taille inchangée - par exemple, de remplacer tout de clé/valeur au lieu de les enlever ensuite ce code ne sera pas jeter l'exception
Je suis en désaccord que c'est “assez évident comment résoudre ce problème si c'est cassé” pour tout le monde à la recherche de ce thème (dont moi-même), et je souhaite que l'on a accepté la réponse a au moins touché.

InformationsquelleAutor NPE | 2011-07-21

dictionary python

48

Il est explicitement mentionné sur le Python page de doc (pour Python 2.7) que

À l'aide de iteritems() lors de l'ajout ou de la suppression d'entrées dans le dictionnaire peut soulever une RuntimeError ou ne parviennent pas à effectuer une itération sur toutes les entrées.

De même pour Python 3.

La même chose vaut pour iter(d), d.iterkeys() et d.itervalues(), et je vais aller aussi loin que de dire qu'il ne l'est pour le for k, v in d.items(): (je ne me souviens pas exactement ce que for fait, mais je ne serais pas surpris si la mise en œuvre appelée iter(d)).
- Je vais me mettre dans l'embarras pour le bien de la communauté en affirmant que j'ai utilisé le très extrait de code. Pensant que puisque je n'ai pas un RuntimeError, je croyais que tout était bon. Et il a été, pendant un certain temps. Anale de rétention des tests unitaires ont été de me donner les pouces vers le haut et c'était encore en cours d'exécution bien quand il a été libéré. Ensuite, j'ai commencé à avoir un comportement bizarre. Ce qui se produit est que les éléments du dictionnaire ont été prise en sautées et donc pas tous les articles dans le dictionnaire ont été en cours de numérisation. Les enfants, apprendre des erreurs que j'ai faites dans ma vie et dire non! 😉
- Puis-je exécuter dans des problèmes si je suis la modification de la valeur à la clé actuelle (mais pas en ajoutant ou en supprimant toutes les clés?) Je imaaaagine que cela ne devrait pas poser de problèmes, mais j'aimerais bien le savoir!
- Je ne sais pas du tout, mais vous pourriez encore être en cours d'exécution dans un champ de mines, si votre corps de boucle faire usage de la valeur et en n'attendant pas qu'il change.
- d.items() devriez être en sécurité dans Python 2.7 (le jeu change avec Python 3), car il rend ce qui est essentiellement une copie de d, de sorte que vous n'êtes pas modifier ce que vous avez à parcourir.
- Il serait intéressant de savoir si cela est vrai aussi pour viewitems()
- il est ! Reportez-vous à docs.python.org/3/library/stdtypes.html#dictionary-view-objects.
InformationsquelleAutor Raphaël Saint-Pierre
44

Alex Martelli pèse sur cette ici.

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

Il est d'accord pour modifier la valeur à un existant indice de la dict, mais l'insertion de valeurs à de nouveaux indices (par exemple,d[g(k)]=v) peuvent ne pas fonctionner.
- Je pense que c'est une clé de réponse pour moi. Beaucoup de cas d'utilisation ont un processus d'insertion des choses et d'un autre de nettoyage des choses ou en les supprimant de sorte que le conseil d.les éléments() fonctionne. Python 3 mises en garde de ne pas résister
- Plus d'informations sur le Python 3 mises en garde peuvent être trouvés dans PEP 469 où la sémantique de ladite Python 2 dict méthodes sont énumérés.
- "C'est d'accord pour modifier la valeur à un index existant de la dict" -- avez-vous une référence pour le présent?
- Non, je n'ai pas de référence pour le présent, mais je pense que c'est assez standard en Python. Par exemple, Alex Martelli est un Python de base du développeur et de l' montre son utilisation ici.
InformationsquelleAutor unutbu
22

Vous ne pouvez pas le faire, au 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(), puis il travaille.

En Python 3, d.items() est vue dans le dictionnaire, comme d.iteritems() en Python 2. Pour ce faire, dans Python 3, au lieu d'utiliser d.copy().items(). Cela va de même de nous permettre de parcourir une copie du dictionnaire afin d'éviter la modification de la structure de données, nous sommes à parcourir.
- Sauf en Python 3...
- J'ai ajouté Python 3 pour ma réponse.
- Pour info, la traduction littérale (comme, par exemple, utilisé par 2to3) de Py2 de d.items() à Py3 est list(d.items()), bien que d.copy().items() est probablement de même de l'efficacité.
- Si le dict objet est très grand, est d.copier().les éléments() efficiet?
InformationsquelleAutor murgatroid99
6

Le code suivant montre que ce n'est pas bien définie:
```
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 des appels de g(k), et lève une exception (dictionnaire changé de taille au cours de l'itération).

Le deuxième exemple d'appels h(k) et jette pas une exception, mais les sorties:
```
{21: 'axx', 22: 'bxx', 23: 'cxx'}
```
Qui, en regardant le code, semble mal - je me serais attendu à quelque chose comme:
```
{11: 'ax', 12: 'bx', 13: 'cx'}
```
- Je peux comprendre pourquoi vous pourriez vous attendre {11: 'ax', 12: 'bx', 13: 'cx'} mais le 21,22,23 devrait vous donner une idée de ce qui s'est réellement passé: la boucle est allé par le biais d'éléments 1, 2, 3, 11, 12, 13 mais n'ai pas réussi à récupérer le second tour des nouveaux éléments qu'ils sont insérés avant les éléments que vous avait déjà itéré. Changement h() de retour x+5 et vous obtenez un autre x: 'axxx' etc. ou "x+3' et vous obtenez le magnifique 'axxxxx'
- Ouais, mon erreur j'ai peur que mon résultat attendu a été {11: 'ax', 12: 'bx', 13: 'cx'} comme vous l'avez dit, donc je vais mettre à jour mon post à ce sujet. De toute façon, ce n'est clairement pas bien défini comportement.
InformationsquelleAutor combatdave
6

J'ai un gros dictionnaire contenant les tableaux Numpy, de sorte que le dict.copier().les touches() chose suggéré par @murgatroid99 n'était pas possible (si elle a fonctionné). Au lieu de cela, j'ai juste converti le keys_view à une liste et il 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 ce n'est pas plongée dans le domaine philosophique de Python fonctionnement interne que les réponses ci-dessus, mais il offre une solution pratique au problème posé.

InformationsquelleAutor 2cynykyl
1

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

Liste Python peut être itérer même si vous modifiez lors de l'itération sur elle.
donc, pour la suite de code, il va imprimer de 1 à l'infini.
```
for i in list:
   list.append(1)
   print 1
```
Donc à l'aide de la liste 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))
```
- Je ne suis pas sûr si c'est sûr qu'à modifier une liste au cours d'une itération (même si cela peut fonctionner dans certains cas). Voir cette question par exemple...
- Si vous souhaitez supprimer des éléments d'une liste, vous pouvez parcourir dans l'ordre inverse, puisque dans l'ordre normal de l'index de l'élément suivant allait changer lors de la suppression. par exemple.
InformationsquelleAutor Zeel Shah
0

Aujourd'hui, j'ai eu ce genre de cas d'utilisation, mais au lieu de simplement se matérialiser les touches sur le dictionnaire au début de la boucle, je voulais des modifications à la dict affecter l'itération de la dict, qui a été ordonnée, dict.

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

InformationsquelleAutor Jason R. Coombs
0

Python 3, vous devez juste:
```
prefix = 'item_'
t = {'f1': 'ffw', 'f2': 'fca'}
t2 = dict() 
for k,v in t.items():
    t2[k] = prefix + v
```
ou de l'utilisation:
```
t2 = t1.copy()
```
Vous ne devriez jamais modifier dictionnaire original, il conduit à la confusion ainsi que les éventuels bugs ou RunTimeErrors. Sauf si vous venez d'ajouter au dictionnaire avec de nouveaux noms de clé.

InformationsquelleAutor Dexter

Vous devez vous connecter pour publier un commentaire.