訪問項目在ordereddict

Question

可以說我有下面的代碼：

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

有沒有一種方法，我可以訪問項目的編號方式，比如：

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

Answer 1

如果它的OrderedDict()您可以通過獲取（鍵，值）對的元組索引來輕鬆訪問元素，如下所示：

>>> 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') 

Python的注意事項3.X

dict.items將返回一個iterable dict view object而不是一個列表。我們需要調用換到一個列表，以便使索引可能

>>> items = list(d.items()) 
>>> items 
[('foo', 'python'), ('bar', 'spam')] 
>>> items[0] 
('foo', 'python') 
>>> items[1] 
('bar', 'spam') 

Answer 2

你必須使用OrderedDict或者你特別希望的是在某些方面具有快速定位索引下令地圖樣類型？如果是後者，那麼考慮一下Python的許多排序詞典類型（它根據鍵排序順序對鍵值對進行排序）。一些實現也支持快速索引。例如，sortedcontainers項目爲此目的具有SortedDict類型。

>>> 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' 

Answer 3

這裏是一個特殊的情況下，如果你想第一條目（或接近）在OrderedDict，而無需創建一個列表：

>>> from collections import OrderedDict 
>>> 
>>> d = OrderedDict() 
>>> d["foo"] = "one" 
>>> d["bar"] = "two" 
>>> d["baz"] = "three" 
>>> 
>>> d.iteritems().next() 
('foo', 'one') 

（你第一次說「下一（）「，它的意思是」第一「。）

在Python 2.7中的非正式測試中，帶有小OrderedDict的iteritems().next()只比items()[0]快一點點。對於10,000個條目的OrderedDict，iteritems().next()比items()[0]快約200倍。

但是如果您保存items（）列表一次，然後使用列表很多，那可能會更快。或者，如果你反覆{創建一個iteritems（）迭代器並遍歷它到你想要的位置}，那可能會更慢。

Answer 4

使用IndexedOrderedDict顯着更高效。

繼尼古拉斯的評論，我已經OrderedDict和IndexedOrderedDict與1000個條目做了一個標杆。

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是〜快100倍於在該特定情況下的具體位置標定元件。

Answer 5

這是一個新時代，Python 3.6.1字典現在保留其順序。這些語義並不明確，因爲這需要BDFL的批准。但Raymond Hettinger是下一個最好的東西（也更有趣），並且他製作了一個pretty strong case字典將會被訂購很長時間。

所以現在可以很容易地創建一個字典片：

test_dict = { 
       'first': 1, 
       'second': 2, 
       'third': 3, 
       'fourth': 4 
      } 

list(test_dict.items())[:2] 

Answer 6

這個社區維基試圖收集現有的答案。

的Python 2.7

在Python 2，的OrderedDict返回列出了keys()，values()，和items()功能。使用values爲例，最簡單的方法是

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

對於大集合，你只關心一個單一的指標，您可以使用生成的版本，iterkeys，itervalues和iteritems避免創建完整的列表：

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

indexed.py包提供了IndexedOrderedDict，它是專爲這種用例設計的，並且是最快的選擇。

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

使用itervalues可以大大加快與隨機存取大型辭書：

$ 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中具有相同的兩個基本選項（名單VS發電機），但字典方法默認返回生成器。

列表方法：

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

發電機方法：

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

Python 3的詞典是一個數量級比蟒2更快，具有用於使用生成類似的加速比。

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