Comment puis-je convertir un dictionnaire Python pour une liste de tuples?

Si j'ai un dictionnaire comme:

{ 'a': 1, 'b': 2, 'c': 3 }

Comment puis-je convertir il pour cela?

[ ('a', 1), ('b', 2), ('c', 3) ]

Et comment puis-je convertir il pour cela?

[ (1, 'a'), (2, 'b'), (3, 'c') ]

[tuple(reversed(x)) for x in d.items()]
Compte tenu de x est déjà un tuple dans votre code (c'est la nature de items pour produire un objet iterable tuples), il serait plus simple, plus rapide de simplement faire de [x[::-1] for x in d.items()]; l'inversion de la tranche directement constructions de l'inversion de la tuple de la bonne taille, plutôt que d'avoir le tuple constructeur de manière itérative à remplir (avec la surutilisation et le redimensionnement à la fin) un tuple à partir d'un reversed itérateur.
vous êtes de droite. Je voulais juste être explicite qu'il n'est pas toujours un besoin pour k, v modèle dans de tels cas.
Remarque: ajout de compatibility tag en raison de py2.x // py3.différences x

InformationsquelleAutor mike | 2009-03-23

328
```
>>> d = { 'a': 1, 'b': 2, 'c': 3 }
>>> d.items()
[('a', 1), ('c', 3), ('b', 2)]
>>> [(v, k) for k, v in d.iteritems()]
[(1, 'a'), (3, 'c'), (2, 'b')]
```
Il n'est pas dans l'ordre que vous voulez, mais dicts ne disposent pas d'un ordre de toute façon.¹ de les Trier ou de les organiser en tant que de besoin.

Voir: les éléments(), iteritems()

En Python 3.x, vous n'utilisez pas iteritems (qui n'existe plus), mais au lieu d'utiliser items, qui retourne maintenant une "vue" dans le dictionnaire d'objets. Voir la Ce qui est Nouveau document pour Python 3.0, et la nouvelle la documentation sur les points de vue.

^{1: Insertion-la conservation de l'ordre pour les dicts était ajouté en Python 3.7}
- les éléments() renvoie un dict_keys vue en python3. Envelopper le présent appel à un casting pour une liste de la liste des" ()". Voir @SilentGhost réponse
InformationsquelleAutor Devin Jeanpierre

car personne d'autre ne l'a fait, je vais ajouter py3k versions:

>>> d = { 'a': 1, 'b': 2, 'c': 3 }
>>> list(d.items())
[('a', 1), ('c', 3), ('b', 2)]
>>> [(v, k) for k, v in d.items()]
[(1, 'a'), (3, 'c'), (2, 'b')]

InformationsquelleAutor SilentGhost

16

Vous pouvez utiliser interprétations de la liste.
```
[(k,v) for k,v in a.iteritems()] 
```
vous obtiendrez [ ('a', 1), ('b', 2), ('c', 3) ] et
```
[(v,k) for k,v in a.iteritems()] 
```
l'autre exemple.

Lire plus sur les interprétations de la liste si vous voulez, c'est très intéressant ce que vous pouvez faire avec eux.

InformationsquelleAutor mpeterson
9

Créer une liste de namedtuples

Il peut souvent être très pratique à utiliser namedtuple. Par exemple, vous avez un dictionnaire de 'nom' que les clés et le "score" que des valeurs comme:
```
d = {'John':5, 'Alex':10, 'Richard': 7}
```
Vous pouvez lister les éléments de n-uplets, triés si vous le souhaitez, et d'obtenir le nom et le score de, disons que le joueur avec le score le plus élevé (indice=0) très Pythonically comme ceci:
```
>>> player = best[0]

>>> player.name
        'Alex'
>>> player.score
         10
```
Comment faire:

liste dans un ordre aléatoire ou de maintien de l'ordre de les collections.OrderedDict:
```
import collections
Player = collections.namedtuple('Player', 'name score')
players = list(Player(*item) for item in d.items())
```
dans l'ordre, triés par valeur ("score"):
```
import collections
Player = collections.namedtuple('Player', 'score name')
```
triés avec le score le plus bas en premier:
```
worst = sorted(Player(v,k) for (k,v) in d.items())
```
triés avec le score le plus élevé en premier:
```
best = sorted([Player(v,k) for (k,v) in d.items()], reverse=True)
```
InformationsquelleAutor Remi
6

Ce que vous voulez est dict's items() et iteritems() méthodes. items renvoie une liste de (clé,valeur) des n-uplets. Depuis les tuples sont immuables, ils ne peuvent pas être inversés. Ainsi, vous devez parcourir les éléments et de créer de nouveaux tuples pour obtenir l'inversion de l' (valeur,clé) de n-uplets. Pour l'itération, iteritems est préférable, car il utilise un générateur pour produire de l' (clé,valeur) des n-uplets plutôt que d'avoir à garder l'ensemble de la liste en mémoire.
```
Python 2.5.1 (r251:54863, Jan 13 2009, 10:26:13) 
[GCC 4.0.1 (Apple Inc. build 5465)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> a = { 'a': 1, 'b': 2, 'c': 3 }
>>> a.items()
[('a', 1), ('c', 3), ('b', 2)]
>>> [(v,k) for (k,v) in a.iteritems()]
[(1, 'a'), (3, 'c'), (2, 'b')]
>>> 
```
InformationsquelleAutor Barry Wark
5
```
[(k,v) for (k,v) in d.iteritems()]
```
et
```
[(v,k) for (k,v) in d.iteritems()]
```
- "[(k,v) de (k,v) dans d.iteritems()]" est une terrible équivalent à d.les éléments()
InformationsquelleAutor Robert Rossney

>>> a={ 'a': 1, 'b': 2, 'c': 3 } 

>>> [(x,a[x]) pour x dans un.les touches() ] 
[('a', 1), ('c', 3), ('b', 2)] 

>>> [(a[x],x) pour x dans un.les touches() ] 
[(1, 'a'), (3, 'c'), (2, 'b')]

InformationsquelleAutor ismail

4

Par keys() et values() méthodes de dictionnaire et zip.

zip sera de retour une liste de tuples qui agit comme un commandés dictionnaire.

Démo:
```
>>> d = { 'a': 1, 'b': 2, 'c': 3 }
>>> zip(d.keys(), d.values())
[('a', 1), ('c', 3), ('b', 2)]
>>> zip(d.values(), d.keys())
[(1, 'a'), (3, 'c'), (2, 'b')]
```
- Cela a fonctionné pour moi comme une alternative à collections.OrderedDict() qui fonctionne mieux avec plusieurs versions de Python Requêtes HTTP lib. Même si je n'aime pas le zip nom de la fonction comme étant un peu vague/surchargé.
- Remarque le zip-ification n'est pas une "profonde" de la coulée, c'est à dire si il sont imbriqués les enfants, elles ne seront pas touchés. Vous pourriez avoir à rouler vos propres récursivité.
InformationsquelleAutor Vivek Sable
3
```
d = {'John':5, 'Alex':10, 'Richard': 7}
list = []
for i in d:
   k = (i,d[i])
   list.append(k)

print list
```
- Bien que ce code peut aider à résoudre le problème, ça n'explique pas pourquoi et/ou comment il répond à la question. La fourniture de ce contexte supplémentaire permettrait d'améliorer de façon significative à long terme sa valeur éducative. Veuillez modifier votre réponse pour ajouter des explications, y compris quelles sont les limites et les hypothèses s'appliquent.
InformationsquelleAutor Harish

Pour Python3.x utilisation

for key, value in dict.items():
    temp = [key,value]
    dictlist.append(temp)

Pour Python 2.7 utilisation

for key, value in dict.iteritems():
    temp = [key,value]
    dictlist.append(temp)

Grâce

InformationsquelleAutor Dheeraj M Pai

Vous devez vous connecter pour publier un commentaire.