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