Zugriff auf Elemente in Sammlungen.OrderedDict von index

Können sagen, ich habe den folgenden code ein:

import collections
d = collections.OrderedDict()
d['foo'] = 'python'
d['bar'] = 'spam'

Gibt es eine Möglichkeit, ich kann auf die Elemente in einer nummerierten Art und Weise, wie:

d(0) #foo's Output
d(1) #bar's Output

InformationsquelleAutor Billjk | 2012-04-07

156

Wenn Ihr ein OrderedDict() können Sie leicht Zugriff auf die Elemente von der Indizierung, indem man die Tupel von (Schlüssel,Wert) - Paare wie folgt
```
>>> import collections
>>> d = collections.OrderedDict()
>>> d['foo'] = 'python'
>>> d['bar'] = 'spam'
>>> d.items()
[('foo', 'python'), ('bar', 'spam')]
>>> d.items()[0]
('foo', 'python')
>>> d.items()[1]
('bar', 'spam')
```
Hinweis für Python 3.X

dict.items zurückkehren würde, ein durchsuchbar dict-Objekt anzeigen eher als eine Liste. Wir müssen wickeln Sie den Anruf auf eine Liste, um die Indizierung möglich
```
>>> items = list(d.items())
>>> items
[('foo', 'python'), ('bar', 'spam')]
>>> items[0]
('foo', 'python')
>>> items[1]
('bar', 'spam')
```
- Gute Antwort. Listen sind die TheRightWay(tm) für tun, indizierte Suchvorgänge.
- Beachten Sie, dass im 3.x die items Methode gibt ein interable Wörterbuch view-Objekt eher als eine Liste, und unterstützen nicht schneiden oder indizieren. So müssten Sie drehen Sie es in eine Liste ersten. docs.python.org/3.3/library/stdtypes.html#dict-views
- Elemente kopieren, Werte oder Schlüssel, die in Listen kann sehr langsam für große dictonaries. Ich erstellte eine Neufassung der OrderedDict() mit einem anderen internen datastructure für Anwendungen, die dies tun sehr oft: github.com/niklasf/indexed.py
- wie schalte ich Sie in eine Liste?
- verwenden Sie den Konstruktor: list(d.items())
- wenn Sie besorgt sind, mit der Geschwindigkeit, die Sie gehen sollten, mit meinem C-Implementierung die Sammlungen.OrderedDict ist eine Teilmenge.
- Vielleicht werden ihn drängen, aber da sich die Gegenstände gibt ein iterierbar Wörterbuch view-Objekt, gibt es eine chance, wir können ändern Sie den Wert in das Tupel-pair-Mädchen in d....Elemente()[1]? Ex: d.Elemente()[1].value = "Bla"
- Tatsächlich, da gibt es eine iterierbar Wörterbuch view-Objekt, ich glaube, dass die änderung des Wert hier ist möglich, aber es ist nicht möglich, zum hinzufügen oder entfernen von Elementen, um das Wörterbuch, wie jeder iterator funktionieren würde. Korrigieren Sie mich, wenn ich falsch bin!
- Wenn Sie nur den Zugriff auf ein Element, können Sie vermeiden, den Speicher-overhead von list(d.items()) mithilfe next(islice(d.items(), 1)) zu bekommen ('bar', 'spam')
- href="https://stackoverflow.com/questions/10058140/accessing-items-in-a-ordereddict#comment80652490_10058239">comment sollte die akzeptierte Antwort. Würden Sie bitte Einreichen, die als eindeutige Antwort? Mein Kommentar-upvote kann nur so viel zu tun hier.
- Vielen Dank für die Ermutigung. Die OP schien zu wollen, ist der Zugriff auf mehrere verschiedene Elemente des dict, in dem Fall wäre es schneller, es zu konvertieren, um eine Liste. Allerdings habe ich nun begonnen, eine community-wiki-einschließlich dieser Technik.
- Warum nicht items = list(d.items()) -> ` items = Tupel(d....Elemente())`?
- Es sollte erwähnt werden, dass dies O(n). Sehen Quantum7 community-wiki Antwort auf Beweise.
InformationsquelleAutor Abhijit
23

Haben Sie verwenden, um eine OrderedDict oder Sie möchten gezielt eine Karte-wie der Typ, der ' s bestellt, die in irgendeiner Weise mit schnellem positions-Indizierung? Wenn letzteres, dann betrachten Sie eine Python ' s viele sortiert dict-Typen (die Bestellungen von Schlüssel-Wert-Paare basierend auf key sort order). Einige Implementierungen unterstützen auch die schnelle Indizierung. Zum Beispiel, die sortedcontainers Projekt hat eine SortedDict geben Sie für genau diesen Zweck.
```
>>> from sortedcontainers import SortedDict
>>> sd = SortedDict()
>>> sd['foo'] = 'python'
>>> sd['bar'] = 'spam'
>>> print sd.iloc[0] # Note that 'bar' comes before 'foo' in sort order.
'bar'
>>> # If you want the value, then simple do a key lookup:
>>> print sd[sd.iloc[1]]
'python'
```
- Sie können auch SortedDict mit einem Schlüssel-Funktion zu vermeiden, Vergleiche. Wie: SortedDict(lambda key: 0, ...). Schlüssel werden dann unsortiert, sondern bleiben auch weiterhin in einer stabilen Ordnung und sind indexiert.
InformationsquelleAutor GrantJ
17

Hier ist ein besonderer Fall, wenn Sie wollen, dass die ersten Eintrag (oder kurz davor) in eine OrderedDict, ohne eine Liste erstellen:
```
>>> from collections import OrderedDict
>>> 
>>> d = OrderedDict()
>>> d["foo"] = "one"
>>> d["bar"] = "two"
>>> d["baz"] = "three"
>>> 
>>> d.iteritems().next()
('foo', 'one')
```
(Das erste mal, wenn Sie sagen "weiter()", es wirklich bedeutet, "erste.")

In meinem informellen test in Python 2.7, iteritems().next() mit einem kleinen OrderedDict ist nur ein kleines bisschen schneller als items()[0]. Mit einem OrderedDict von 10.000 Einträge, iteritems().next() wurde über 200-mal schneller als items()[0].

ABER wenn Sie speichern die Elemente() Liste einmal und dann verwenden Sie die Liste, eine Menge, das könnte schneller sein. Oder wenn Sie wiederholt { erstellen Sie eine iteritems() iterator und Schritt durch Sie an die gewünschte position }, das könnte langsamer sein.
- Python 3 OrderedDicts nicht iteritems() - Methode, so müssen Sie das folgende tun, um das erste Element: next(iter(d.items())).
- In Python 3 d.items() scheint sich nicht um einen iterator, so iter vor wird nicht helfen? Es wird noch zurück, die komplette Liste 🙁
- Update: ich war falsch, iter(d....Elemente()) gibt odict_iterator bestätigt wurde mir im IRC #python, dass dies nicht eine Kopie der Liste.
InformationsquelleAutor SteveWithamDuplicate
13

Es ist dramatisch effizienter zu nutzen IndexedOrderedDict aus der indiziert Paket.

Folgende Niklas Kommentar, ich habe eine benchmark auf OrderedDict und IndexedOrderedDict mit 1000 Einträgen.
```
In [1]: from numpy import *
In [2]: from indexed import IndexedOrderedDict
In [3]: id=IndexedOrderedDict(zip(arange(1000),random.random(1000)))
In [4]: timeit id.keys()[56]
1000000 loops, best of 3: 969 ns per loop

In [8]: from collections import OrderedDict
In [9]: od=OrderedDict(zip(arange(1000),random.random(1000)))
In [10]: timeit od.keys()[56]
10000 loops, best of 3: 104 µs per loop
```
IndexedOrderedDict ist ~100 mal schneller im index-Elemente an bestimmten position, in diesem speziellen Fall.
- Schön! Noch nicht in Anaconda leider.
- Das Paket der eigentliche name ist indexed.py. Versuchen Sie indexed.py statt indexed.
InformationsquelleAutor 刘金国

Dieser community wiki versucht zu sammeln, bereits vorhandene Antworten.

Python 2.7

In python 2 die keys(), values(), und items() Funktionen OrderedDict Gegenzug Listen. Mit values als ein Beispiel, ist der einfachste Weg

d.values()[0]  # "python"
d.values()[1]  # "spam"

Für große Sammlungen, wenn Sie nur über einen einzigen index, können Sie vermeiden, erstellen Sie die vollständige Liste über den generator Versionen iterkeys, itervalues und iteritems:

import itertools
next(itertools.islice(d.itervalues(), 0, 1))  # "python"
next(itertools.islice(d.itervalues(), 1, 2))  # "spam"

Den indexed.py Paket bietet IndexedOrderedDict, die speziell für diesen Anwendungsfall und wird die Schnellste option.

from indexed import IndexedOrderedDict
d = IndexedOrderedDict({'foo':'python','bar':'spam'})
d.values()[0]  # "python"
d.values()[1]  # "spam"

Mit itervalues können deutlich schneller für große Wörterbücher mit random access:

$ python2 -m timeit -s 'from collections import OrderedDict; from random import randint; size = 1000;   d = OrderedDict({i:i for i in range(size)})'  'i = randint(0, size-1); d.values()[i:i+1]'
1000 loops, best of 3: 259 usec per loop
$ python2 -m timeit -s 'from collections import OrderedDict; from random import randint; size = 10000;  d = OrderedDict({i:i for i in range(size)})' 'i = randint(0, size-1); d.values()[i:i+1]'
100 loops, best of 3: 2.3 msec per loop
$ python2 -m timeit -s 'from collections import OrderedDict; from random import randint; size = 100000; d = OrderedDict({i:i for i in range(size)})' 'i = randint(0, size-1); d.values()[i:i+1]'
10 loops, best of 3: 24.5 msec per loop

$ python2 -m timeit -s 'from collections import OrderedDict; from random import randint; size = 1000;   d = OrderedDict({i:i for i in range(size)})' 'i = randint(0, size-1); next(itertools.islice(d.itervalues(), i, i+1))'
10000 loops, best of 3: 118 usec per loop
$ python2 -m timeit -s 'from collections import OrderedDict; from random import randint; size = 10000;  d = OrderedDict({i:i for i in range(size)})' 'i = randint(0, size-1); next(itertools.islice(d.itervalues(), i, i+1))'
1000 loops, best of 3: 1.26 msec per loop
$ python2 -m timeit -s 'from collections import OrderedDict; from random import randint; size = 100000; d = OrderedDict({i:i for i in range(size)})' 'i = randint(0, size-1); next(itertools.islice(d.itervalues(), i, i+1))'
100 loops, best of 3: 10.9 msec per loop

$ python2 -m timeit -s 'from indexed import IndexedOrderedDict; from random import randint; size = 1000;   d = IndexedOrderedDict({i:i for i in range(size)})' 'i = randint(0, size-1); d.values()[i]'
100000 loops, best of 3: 2.19 usec per loop
$ python2 -m timeit -s 'from indexed import IndexedOrderedDict; from random import randint; size = 10000;  d = IndexedOrderedDict({i:i for i in range(size)})' 'i = randint(0, size-1); d.values()[i]'
100000 loops, best of 3: 2.24 usec per loop
$ python2 -m timeit -s 'from indexed import IndexedOrderedDict; from random import randint; size = 100000; d = IndexedOrderedDict({i:i for i in range(size)})' 'i = randint(0, size-1); d.values()[i]'
100000 loops, best of 3: 2.61 usec per loop

+--------+-----------+----------------+---------+
|  size  | list (ms) | generator (ms) | indexed |
+--------+-----------+----------------+---------+
|   1000 | .259      | .118           | .00219  |
|  10000 | 2.3       | 1.26           | .00224  |
| 100000 | 24.5      | 10.9           | .00261  |
+--------+-----------+----------------+---------+

Python 3.6

Python 3 hat die gleichen grundlegenden Optionen (Liste vs generator), aber die dict-Methoden zurück, Generatoren standardmäßig.

Liste Methode:

list(d.values())[0]  # "python"
list(d.values())[1]  # "spam"

Generator-Methode:

import itertools
next(itertools.islice(d.values(), 0, 1))  # "python"
next(itertools.islice(d.values(), 1, 2))  # "spam"

Python 3 Wörterbücher sind um eine Größenordnung schneller als die python 2 und haben ähnliche Beschleunigungen für die Verwendung von Generatoren.

+--------+-----------+----------------+---------+
|  size  | list (ms) | generator (ms) | indexed |
+--------+-----------+----------------+---------+
|   1000 | .0316     | .0165          | .00262  |
|  10000 | .288      | .166           | .00294  |
| 100000 | 3.53      | 1.48           | .00332  |
+--------+-----------+----------------+---------+

InformationsquelleAutor

5

Es ist eine neue ära und mit Python 3.6.1 Wörterbücher behalten jetzt Ihre Bestellung. Diese Semantik nicht explizit, weil das verlangen würde, dass BDFL-Zulassung. Aber Raymond Hettinger ist die nächste beste Sache (und Lustiger) und er macht einen ziemlich starke Fall Wörterbücher, die bestellt wird, für eine sehr lange Zeit.

So, jetzt ist es einfach zu erstellen Scheiben ein Wörterbuch:
```
test_dict = {
                'first':  1,
                'second': 2,
                'third':  3,
                'fourth': 4
            }

list(test_dict.items())[:2]
```
Hinweis: Dictonary einführen-um die Erhaltung ist jetzt offizielle Python-3.7.

InformationsquelleAutor highpost

für OrderedDict() können Sie den Zugriff auf die Elemente von der Indizierung, indem man die Tupel von (Schlüssel,Wert) - Paare wie folgt, oder mit '.Werte()'

>>> import collections
>>> d = collections.OrderedDict()
>>> d['foo'] = 'python'
>>> d['bar'] = 'spam'
>>> d.items()
[('foo', 'python'), ('bar', 'spam')]
>>>d.values()
odict_values(['python','spam'])
>>>list(d.values())
['python','spam']

InformationsquelleAutor Mehar Rahim

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.