Comment effectuer une itération sur un Python dictionnaire dans l'ordre défini?

Je suis en train de parcourir un dictionnaire que j'ai défini dans un ordre spécifique, mais il a toujours itère dans un ordre différent que ce que j'ai définie dans mon code. C'est juste un exemple de base de ce que je suis en train de faire. Le dictionnaire, je suis à parcourir est beaucoup plus grande, beaucoup plus complexe, nommé clés, et n'est pas dans l'ordre alphabétique/numérique.

level_lookup = \
{
'PRIORITY_1' :   { 'level' : 'BAD',   'value' :   ''  },
'PRIORITY_2' :   { 'level' : 'BAD',   'value' :   ''  },
'PRIORITY_3' :   { 'level' : 'BAD',   'value' :   ''  },
'PRIORITY_4' :   { 'level' : 'BAD',   'value' :   ''  },
'PRIORITY_5' :   { 'level' : 'CHECK', 'value' :   ''  },
'PRIORITY_6' :   { 'level' : 'CHECK', 'value' :   ''  },
'PRIORITY_7' :   { 'level' : 'GOOD',  'value' :   ''  },
'PRIORITY_8' :   { 'level' : 'GOOD',  'value' :   ''  },
}

for priority in level_lookup:
    if( level_lookup[ priority ][ 'value' ] == 'TRUE' ):
        set_levels += str( priority ) + '\n'

J'ai besoin l'ordre que je définir le dictionnaire pour être conservé au cours d'une itération. Ma commande n'est pas alphabétique, tri par ordre alphabétique n'est pas vraiment utile. Est-il possible de faire cela? J'ai essayé " level_lookup.les éléments(), mais cela ne veut pas maintenir ma commande.

Si vous souhaitez utiliser un dictionnaire dans l'ordre... ne pas. Utiliser un OrderedDict à la place.
Les dictionnaires n'ont pas un ordre. Qui est, les éléments sont à venir dans quelques commande lorsque vous réitérer, mais c'est tout ce qui est plus facile pour Python, et peut ou peut ne pas ressembler à l'ordre dans lequel les éléments ont été mis en, et peut changer lorsque vous ajoutez ou supprimer des éléments. Si vous voulez que vos articles dans une commande, utilisez un récipient qui conserve l'ordre des éléments, tels que collections.OrderedDict.

OriginalL'auteur PseudoPsyche | 2013-07-16

9

Vous devez utiliser un OrderedDict. Il fonctionne exactement de la façon dont vous le souhaitez, cependant, vous devez définir de cette façon. Alternativement, vous pouvez avoir une liste de touches dans l'ordre, et de parcourir la liste et l'accès au dictionnaire. Quelque chose le long des lignes de:
```
level_lookup_order = ['PRIORITY_1', 'PRIORITY_2', ...]
for key in level_lookup_order:
    if key in level_lookup:
        do_stuff(level_lookup[key])
```
Ce sera une douleur à maintenir, alors je vous recommande d'utiliser seulement la OrderedDict.

Comme une dernière option, vous pouvez utiliser les constantes. Comme,
```
PRIORITY_1 = 1
PRIORITY_2 = 2
...
lookup_order = {PRIORITY_1: 42, PRIORITY_2: 24, ...}
```
OrderedDict a fait le tour parfaitement. Merci!

OriginalL'auteur gcbirzan
6

Si vous êtes bien avec l'aide de la clé de tri par ordre:
```
for key in sorted(level_lookup.keys()):
    ...
```
C'est ce que je fais généralement si le dict est fournie à moi, et pas quelque chose que je instancier (plutôt que OrderedDict.

OriginalL'auteur Dan Lecocq
4

Vous pourrait utiliser un collections.OrderedDict. Si cela ne fonctionne pas pour vous, vous pouvez trier les clés avant de faire une itération sur eux:
```
for k in sorted(myDict, lambda k: int(k.rsplit("_",1)[1]):
    # do stuff
```
Noter, cependant, que ce tri des coûts de l'espace linéaire et O(nlogn). Aussi, il utilise la coïncidence du système de numérotation "PRIORITY_N" pour le tri, ce qui peut ne pas toujours être valide

OriginalL'auteur inspectorG4dget
2

Essayer;
```
for priority in sorted(level_lookup.iterkeys()):
```
Comme Jon l'a souligné, keys() et iterkeys() sont ici redondant;
```
for priority in sorted(level_lookup):
```
iterkeys() etc... est redondant ici... il suffit d'utiliser sorted(level_lookup) - il va travailler pour Python 2 et 3
Il le fait! Merci!
Belle réponse. Je ne sais pas pourquoi ce n'était pas le préféré de "bonne" réponse.

OriginalL'auteur Sam Nicholls

Je pense que vous feriez mieux de pas à l'aide d'un dictionnaire contenant et ne vois pas de raison impérieuse d'utiliser dans ce cas. Unlistserait de stocker les éléments dans l'ordre souhaité:

level_lookup = [
    {'level': 'BAD',   'value': ''    },
    {'level': 'BAD',   'value': ''    },
    {'level': 'BAD',   'value': ''    },
    {'level': 'BAD',   'value': ''    },
    {'level': 'CHECK', 'value': 'TRUE'},
    {'level': 'CHECK', 'value': 'TRUE'},
    {'level': 'GOOD',  'value': ''    },
    {'level': 'GOOD',  'value': ''    },
]

set_levels = ''
for level, priority in enumerate(level_lookup, start=1):
    if priority['value'] == 'TRUE':
        set_levels += 'PRIORITY_{!s}\n'.format(level)
print set_levels

En fait, vous pourriez écrire la chose qu'compréhension de liste:

set_levels = ('\n'.join('PRIORITY_{!s}'.format(level)
                for level, priority in enumerate(level_lookup, start=1)
                    if priority['value'] == 'TRUE'))
print set_levels

Ce serait le travail, mais il y a d'autres sections de code qui dépendent de faire le dictionnaire look-ups basées sur les touches. Je pourrais faire une boucle par une liste, mais c'est plus propre à maintenir de cette façon plutôt que d'une boucle sur une liste très importante chaque fois que vous êtes à la recherche de quelque chose, lorsque la clé est connue.

OriginalL'auteur martineau

Vous devez vous connecter pour publier un commentaire.