Accéder à un élément arbitraire dans un dictionnaire en Python

Si a mydictn'est pas vide, j'accède à un élément arbitraire comme:

mydict[mydict.keys()[0]]

Y a-t-il une meilleure façon de procéder?

Sur Python 3, de manière non destructive et itérative:

next(iter(mydict.values()))

Sur Python 2, de manière non destructive et itérative:

mydict.itervalues().next()

Si vous voulez qu'il fonctionne à la fois en Python 2 et 3, vous pouvez utiliser le sixpackage:

six.next(six.itervalues(mydict))

mais à ce stade, il est assez cryptique et je préfère votre code.

Si vous souhaitez supprimer un élément, procédez comme suit:

key, value = mydict.popitem()

Notez que "premier" peut ne pas être un terme approprié ici car il dictne s'agit pas d'un type ordonné en Python <3.6. Python 3.6+ dictsest commandé.

Si vous n'avez besoin d'accéder qu'à un seul élément (étant le premier par hasard, car les dictés ne garantissent pas l'ordre), vous pouvez simplement le faire en Python 2 :

my_dict.keys()[0]     -> key of "first" element
my_dict.values()[0]   -> value of "first" element
my_dict.items()[0]    -> (key, value) tuple of "first" element

Veuillez noter que (au mieux de ma connaissance) Python ne garantit pas que 2 appels successifs à l'une de ces méthodes retourneront list avec le même ordre. Ceci n'est pas pris en charge avec Python3.

en Python 3 :

list(my_dict.keys())[0]     -> key of "first" element
list(my_dict.values())[0]   -> value of "first" element
list(my_dict.items())[0]    -> (key, value) tuple of "first" element

En python3, La façon:

dict.keys() 

retourne une valeur dans type: dict_keys (), nous aurons une erreur lorsque nous aurons obtenu le 1er membre des clés de dict de cette façon:

dict.keys()[0]
TypeError: 'dict_keys' object does not support indexing

Enfin, je convertis dict.keys () en liste @ 1st, et j'ai obtenu le 1er membre par la méthode d'épissage de liste:

list(dict.keys())[0]

obtenir une clé

next(iter(mydict))

pour obtenir une valeur

next(iter(mydict.values()))

obtenir les deux

next(iter(mydict.items())) # or next(iter(mydict.viewitems())) in python 2

Les deux premiers sont Python 2 et 3. Les deux derniers sont paresseux en Python 3, mais pas en Python 2.

Comme d'autres l'ont mentionné, il n'y a pas de "premier élément", car les dictionnaires n'ont pas d'ordre garanti (ils sont implémentés sous forme de tables de hachage). Si vous voulez, par exemple, la valeur correspondant à la plus petite clé le thedict[min(thedict)]fera. Si vous vous souciez de l'ordre dans lequel les clés ont été insérées, c'est-à-dire que par "premier" vous voulez dire "inséré le plus tôt", alors dans Python 3.1 vous pouvez utiliser collections.OrderedDict , qui est également dans le prochain Python 2.7; pour les anciennes versions de Python, téléchargez, installez et utilisez le backport dict dicté (2.4 et versions ultérieures) que vous pouvez trouver ici .

Python 3.7 Les dits sont désormais ordonnés par insertion.

Que dis-tu de ça. Pas encore mentionné ici.

py 2 & 3

a = {"a":2,"b":3}
a[list(a)[0]] # the first element is here
>>> 2

Ignorant les problèmes liés à l'ordre des dicts, cela pourrait être mieux:

next(dict.itervalues())

De cette façon, nous évitons la recherche d'éléments et générons une liste de clés que nous n'utilisons pas.

Python3

next(iter(dict.values()))

En python3

list(dict.values())[0]

Vous pouvez toujours faire:

for k in sorted(d.keys()):
    print d[k]

Cela vous donnera un ensemble de clés triées de manière cohérente (par rapport au .hash () intégré, je suppose) sur lesquelles vous pouvez traiter si le tri a une signification pour vous. Cela signifie par exemple que les types numériques sont triés de manière cohérente même si vous développez le dictionnaire.

EXEMPLE

# lets create a simple dictionary
d = {1:1, 2:2, 3:3, 4:4, 10:10, 100:100}
print d.keys()
print sorted(d.keys())

# add some other stuff
d['peter'] = 'peter'
d['parker'] = 'parker'
print d.keys()
print sorted(d.keys())

# some more stuff, numeric of different type, this will "mess up" the keys set order
d[0.001] = 0.001
d[3.14] = 'pie'
d[2.71] = 'apple pie'
print d.keys()
print sorted(d.keys())

Notez que le dictionnaire est trié lors de l'impression. Mais le jeu de clés est essentiellement une table de hachage!

Pour Python 2 et 3:

import six

six.next(six.itervalues(d))

first_key, *rest_keys = mydict

Pas de bibliothèques externes, fonctionne à la fois sur Python 2.7 et 3.x:

>>> list(set({"a":1, "b": 2}.values()))[0]
1

Pour la clé aribtrary, il suffit de laisser de côté .values ​​()

>>> list(set({"a":1, "b": 2}))[0]
'a'

Le sous dict- classement est une méthode, mais pas efficace. Ici, si vous fournissez un entier, il reviendra d[list(d)[n]], sinon accédez au dictionnaire comme prévu:

class mydict(dict):
    def __getitem__(self, value):
        if isinstance(value, int):
            return self.get(list(self)[value])
        else:
            return self.get(value)

d = mydict({'a': 'hello', 'b': 'this', 'c': 'is', 'd': 'a',
            'e': 'test', 'f': 'dictionary', 'g': 'testing'})

d[0]    # 'hello'
d[1]    # 'this'
d['c']  # 'is'