python 2-6 如何让字典保持有序collections.OrderedDict

2-6 如何让字典保持有序collections.OrderedDict

传统字典

默认字典在存储完以后不保证存储的顺序
dict1 = {'a':1,'b':2,'c':3}
print dict1  {'a': 1, 'c': 3, 'b': 2} 表明存储和建立的顺序不一样
for k in dict1: print k 
输出
a
c
b

使用OrderderDict 保证了先存进的key 会排在字典的前面位置

from collections import OrderedDict
from time import time
from time import sleep
from random import randint

dict2 = OrderedDict() 

person = list('abcdefg')
length = len(person)
start = time()
for i in xrange(length):
    sleep(0.05)
    p = person.pop(randint(0,length-1-i))
    end = time()
    dict2[p]=(i+1,(end -start))

print '-'*50

for k in dict2:
    print k,dict2[k]

--------------------------------------------------
g (1, 0.04999995231628418)
c (2, 0.10000014305114746)
f (3, 0.15000009536743164)
a (4, 0.20000004768371582)
d (5, 0.25)
e (6, 0.2999999523162842)

OrderedDict帮助

>>> help(collections.OrderedDict)
Help on class OrderedDict in module collections:

class OrderedDict(__builtin__.dict)
 |  Dictionary that remembers insertion order
 |  
 |  Method resolution order:
 |      OrderedDict
 |      __builtin__.dict
 |      __builtin__.object
 |  
 |  Methods defined here:
 |  
 |  __delitem__(self, key, PREV=0, NEXT=1, dict_delitem=<slot wrapper '__delitem__' of 'dict' objects>)
 |      od.__delitem__(y) <==> del od[y]
 |  
 |  __eq__(self, other)
 |      od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
 |      while comparison to a regular mapping is order-insensitive.
 |  
 |  __init__(self, *args, **kwds)
 |      Initialize an ordered dictionary.  The signature is the same as
 |      regular dictionaries, but keyword arguments are not recommended because
 |      their insertion order is arbitrary.
 |  
 |  __iter__(self)
 |      od.__iter__() <==> iter(od)
 |  
 |  __ne__(self, other)
 |      od.__ne__(y) <==> od!=y
 |  
 |  __reduce__(self)
 |      Return state information for pickling
 |  
 |  __repr__(self, _repr_running={})
 |      od.__repr__() <==> repr(od)
 |  
 |  __reversed__(self)
 |      od.__reversed__() <==> reversed(od)
 |  
 |  __setitem__(self, key, value, PREV=0, NEXT=1, dict_setitem=<slot wrapper '__setitem__' of 'dict' objects>)
 |      od.__setitem__(i, y) <==> od[i]=y
 |  
 |  clear(self)
 |      od.clear() -> None.  Remove all items from od.
 |  
 |  copy(self)
 |      od.copy() -> a shallow copy of od
 |  
 |  items(self)
 |      od.items() -> list of (key, value) pairs in od
 |  
 |  iteritems(self)
 |      od.iteritems -> an iterator over the (key, value) pairs in od
 |  
 |  iterkeys(self)
 |      od.iterkeys() -> an iterator over the keys in od
 |  
 |  itervalues(self)
 |      od.itervalues -> an iterator over the values in od
 |  
 |  keys(self)
 |      od.keys() -> list of keys in od
 |  
 |  pop(self, key, default=<object object>)
 |      od.pop(k[,d]) -> v, remove specified key and return the corresponding
 |      value.  If key is not found, d is returned if given, otherwise KeyError
 |      is raised.
 |  
 |  popitem(self, last=True)
 |      od.popitem() -> (k, v), return and remove a (key, value) pair.
 |      Pairs are returned in LIFO order if last is true or FIFO order if false.
 |  
 |  setdefault(self, key, default=None)
 |      od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od
 |  
 |  update(*args, **kwds)
 |  
 |  values(self)
 |      od.values() -> list of values in od
 |  
 |  viewitems(self)
 |      od.viewitems() -> a set-like object providing a view on od's items
 |  
 |  viewkeys(self)
 |      od.viewkeys() -> a set-like object providing a view on od's keys
 |  
 |  viewvalues(self)
 |      od.viewvalues() -> an object providing a view on od's values
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  fromkeys(cls, iterable, value=None) from __builtin__.type
 |      OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
 |      If not specified, the value defaults to None.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from __builtin__.dict:
 |  
 |  __cmp__(...)
 |      x.__cmp__(y) <==> cmp(x,y)
 |  
 |  __contains__(...)
 |      D.__contains__(k) -> True if D has a key k, else False
 |  
 |  __ge__(...)
 |      x.__ge__(y) <==> x>=y
 |  
 |  __getattribute__(...)
 |      x.__getattribute__('name') <==> x.name
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(...)
 |      x.__gt__(y) <==> x>y
 |  
 |  __le__(...)
 |      x.__le__(y) <==> x<=y
 |  
 |  __len__(...)
 |      x.__len__() <==> len(x)
 |  
 |  __lt__(...)
 |      x.__lt__(y) <==> x<y
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  has_key(...)
 |      D.has_key(k) -> True if D has a key k, else False
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from __builtin__.dict:
 |  
 |  __hash__ = None
 |  
 |  __new__ = <built-in method __new__ of type object>
 |      T.__new__(S, ...) -> a new object with type S, a subtype of T