Accedi a un elemento arbitrario in un dizionario in Python

Se a mydictnon è vuoto, accedo a un elemento arbitrario come:

mydict[mydict.keys()[0]]

C'è un modo migliore per farlo?

Su Python 3, in modo non distruttivo e iterativo:

next(iter(mydict.values()))

Su Python 2, in modo non distruttivo e iterativo:

mydict.itervalues().next()

Se vuoi che funzioni sia in Python 2 che in 3, puoi usare il sixpacchetto:

six.next(six.itervalues(mydict))

anche se a questo punto è abbastanza criptico e preferirei preferire il tuo codice.

Se si desidera rimuovere qualsiasi elemento, fare:

key, value = mydict.popitem()

Nota che "primo" potrebbe non essere un termine appropriato qui perché dictnon è un tipo ordinato in Python <3.6. Python 3.6+ dictssono ordinati.

Se hai solo bisogno di accedere a un elemento (essendo il primo per caso, poiché i dadi non garantiscono l'ordinamento) puoi semplicemente farlo in 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

Si prega di notare che (per quanto ne sappia) Python non garantisce che 2 chiamate successive a nessuno di questi metodi restituiranno l'elenco con lo stesso ordine. Questo non è supportato con Python3.

in 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

In python3, Il modo:

dict.keys() 

restituisce un valore nel tipo: dict_keys (), avremo un errore quando avremo il primo membro delle chiavi di dict in questo modo:

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

Infine, converto dict.keys () in list @ 1st e ottengo il 1 ° membro con il metodo splice list:

list(dict.keys())[0]

per ottenere una chiave

next(iter(mydict))

per ottenere un valore

next(iter(mydict.values()))

per ottenere entrambi

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

I primi due sono Python 2 e 3. Gli ultimi due sono pigri in Python 3, ma non in Python 2.

Come altri hanno già detto, non esiste un "primo elemento", poiché i dizionari non hanno un ordine garantito (sono implementati come tabelle hash). Se vuoi, ad esempio, il valore corrispondente alla chiave più piccola, thedict[min(thedict)]lo farà. Se ti interessa l'ordine in cui sono state inserite le chiavi, vale a dire "primo" intendi "inserito per primo", allora in Python 3.1 puoi usare collection.OrderedDict , che è anche nell'imminente Python 2.7; per le versioni precedenti di Python, scaricare, installare e utilizzare il backport dict ordinato (2.4 e versioni successive) che è possibile trovare qui .

Python 3.7 Ora i dicts sono ordinati per inserzione.

Cosa ne pensi di questo. Non ancora menzionato qui.

py 2 e 3

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

Ignorando i problemi relativi all'ordinamento dei dict, questo potrebbe essere migliore:

next(dict.itervalues())

In questo modo evitiamo la ricerca degli articoli e generiamo un elenco di chiavi che non utilizziamo.

python3

next(iter(dict.values()))

In python3

list(dict.values())[0]

Puoi sempre fare:

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

Questo ti darà una serie di chiavi sistemate in modo coerente (rispetto a builtin .hash () immagino) su cui puoi elaborare se l'ordinamento ha qualche significato per te. Ciò significa che, ad esempio, i tipi numerici vengono ordinati in modo coerente anche se si espande il dizionario.

ESEMPIO

# 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())

Si noti che il dizionario viene ordinato quando viene stampato. Ma il set di chiavi è essenzialmente una hashmap!

Per entrambi Python 2 e 3:

import six

six.next(six.itervalues(d))

first_key, *rest_keys = mydict

Nessuna libreria esterna, funziona su Python 2.7 e 3.x:

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

Per chiave aribtrary basta tralasciare .values ​​()

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

La sottoclasse dictè un metodo, sebbene non efficiente. Qui se si fornisce un numero intero, verrà restituito d[list(d)[n]], altrimenti accedere al dizionario come previsto:

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'