python collections模块详解

缺乏、安全感 2023-11-05 06:15 111阅读 0赞

## 1.模块简介 ##

> collections包含了一些特殊的容器，针对Python内置的容器，例如list、dict、set和tuple，提供了另一种选择；
> 
> namedtuple，可以创建包含名称的tuple；
> 
> deque，类似于list的容器，可以快速的在队列头部和尾部添加、删除元素；
> 
> Counter，dict的子类，计算可hash的对象；
> 
> OrderedDict，dict的子类，可以记住元素的添加顺序；
> 
> defaultdict，dict的子类，可以调用提供默认值的函数；

## 2.模块使用 ##

### 2.1 Counter ###

counter可以支持方便、快速的计数，例如，

from collections import *
    
    cnt = Counter()
    wordList = ["a","b","c","c","a","a"]
    for word in wordList:
        cnt[word] += 1
    print cnt

控制台输出，

Counter({'a': 3, 'c': 2, 'b': 1})

对可迭代的对象进行计数或者从另一个映射（counter）进行初始化，

>>> c = Counter()#一个新的，空的counter
    >>> c
    Counter()
    >>> c = Counter("gallahad")#从可迭代的字符串初始化counter
    >>> c
    Counter({'a': 3, 'l': 2, 'h': 1, 'g': 1, 'd': 1})
    >>> c = Counter({'red':4,'blue':2})#从映射初始化counter
    >>> c
    Counter({'red': 4, 'blue': 2})
    >>> c = Counter(cats = 4,dogs = 8)#从args初始化counter
    >>> c
    Counter({'dogs': 8, 'cats': 4}

Counter对象类似于字典，如果某个项缺失，会返回0，而不是报出KeyError；

>>> c = Counter(['eggs','ham'])
    >>> c['bacon']#没有'bacon'
    0
    >>> c['eggs']#有'eggs'
    1

将一个元素的数目设置为0，并不能将它从counter中删除，使用del可以将这个元素删除；

>>> c
    Counter({'eggs': 1, 'ham': 1})
    >>> c['eggs'] = 0
    >>> c
    Counter({'ham': 1, 'eggs': 0})#'eggs'依然存在
    >>> del c['eggs']
    >>> c
    Counter({'ham': 1})#'eggs'不存在
    Counter对象支持以下三个字典不支持的方法，elements()，most_common()，subtract()；
    element()，返回一个迭代器，每个元素重复的次数为它的数目，顺序是任意的顺序，如果一个元素的数目少于1，那么elements()就会忽略它；

>>> c = Counter(a=2,b=4,c=0,d=-2,e = 1)
    >>> c
    Counter({'b': 4, 'a': 2, 'e': 1, 'c': 0, 'd': -2})
    >>> list(c.elements())
    ['a', 'a', 'b', 'b', 'b', 'b', 'e']

**most\_common()**，返回一个列表，包含counter中n个最大数目的元素  
，如果忽略n或者为None，most\_common()将会返回counter中的所有元素，元素有着相同数目的将会以任意顺序排列；

>>> Counter('abracadabra').most_common(3)
    [('a', 5), ('r', 2), ('b', 2)]
    >>> Counter('abracadabra').most_common()
    [('a', 5), ('r', 2), ('b', 2), ('c', 1), ('d', 1)]
    >>> Counter('abracadabra').most_common(None)
    [('a', 5), ('r', 2), ('b', 2), ('c', 1), ('d', 1)]

**subtract()**，从一个可迭代对象中或者另一个映射（或counter）中，元素相减，类似于dict.update()，但是subtracts 数目而不是替换它们，输入和输出都有可能为0或者为负；

>>> c = Counter(a=4,b=2,c=0,d=-2)
    >>> d = Counter(a=1,b=2,c=-3,d=4)
    >>> c.subtract(d)
    >>> c
    Counter({'a': 3, 'c': 3, 'b': 0, 'd': -6})

**update()**，从一个可迭代对象中或者另一个映射（或counter）中所有元素相加，类似于dict.upodate，是数目相加而非替换它们，另外，可迭代对象是一个元素序列，而非(key,value)对构成的序列；

>>> c
    Counter({'a': 4, 'b': 2, 'c': 0, 'd': -2})
    >>> d
    Counter({'d': 4, 'b': 2, 'a': 1, 'c': -3})
    >>> c.update(d)
    >>> c
    Counter({'a': 5, 'b': 4, 'd': 2, 'c': -3})

Counter对象常见的操作，

>>> c
    Counter({'a': 5, 'b': 4, 'd': 2, 'c': -3})
    >>> sum(c.values())# 统计所有的数目
    8
    >>> list(c)# 列出所有唯一的元素
    ['a', 'c', 'b', 'd']
    >>> set(c)# 转换为set
    set(['a', 'c', 'b', 'd'])
    >>> dict(c)# 转换为常规的dict
    {'a': 5, 'c': -3, 'b': 4, 'd': 2}
    >>> c.items()# 转换为(elem,cnt)对构成的列表
    [('a', 5), ('c', -3), ('b', 4), ('d', 2)]
    >>> c.most_common()[:-4:-1]# 输出n个数目最小元素
    [('c', -3), ('d', 2), ('b', 4)]
    >>> c += Counter()# 删除数目为0和为负的元素
    >>> c
    Counter({'a': 5, 'b': 4, 'd': 2})
    >>> Counter(dict(c.items()))# 从(elem,cnt)对构成的列表转换为counter
    Counter({'a': 5, 'b': 4, 'd': 2})
    >>> c.clear()# 清空counter
    >>> c
    Counter(在Counter对象进行数学操作，得多集合（counter中元素数目大于0）加法和减法操作，是相加或者相减对应元素的数目；交集和并集返回对应数目的最小值和最大值；每个操作均接受暑促是有符号的数目，但是输出并不包含数目为0或者为负的元素>>> c = Counter(a=3,b=1,c=-2)
    >>> d = Counter(a=1,b=2,c=4)
    >>> c+d#求和
    Counter({'a': 4, 'b': 3, 'c': 2})
    >>> c-d#求差
    Counter({'a': 2})
    >>> c & d#求交集
    Counter({'a': 1, 'b': 1})
    >>> c | d#求并集
    Counter({'c': 4, 'a': 3, 'b': 2}2.2 deque

deque是栈和队列的一种广义实现，deque是"double-end queue"的简称；deque支持线程安全、有效内存地以近似O(1)的性能在deque的两端插入和删除元素，尽管list也支持相似的操作，但是它主要在固定长度操作上的优化，从而在pop(0)和insert(0,v)（会改变数据的位置和大小）上有O(n)的时间复杂度。

deque支持如下方法，

**append(x)，** 将x添加到deque的右侧；

**appendleft(x)，** 将x添加到deque的左侧；

**clear()，** 将deque中的元素全部删除，最后长度为0；

**count(x)，** 返回deque中元素等于x的个数；

**extend(iterable)，** 将可迭代变量iterable中的元素添加至deque的右侧；

**extendleft(iterable)，** 将变量iterable中的元素添加至deque的左侧，往左侧添加序列的顺序与可迭代变量iterable中的元素相反；

**pop()，** 移除和返回deque中最右侧的元素，如果没有元素，将会报出IndexError；

**popleft()，** 移除和返回deque中最左侧的元素，如果没有元素，将会报出IndexError；

**remove(value)，** 移除第一次出现的value，如果没有找到，报出ValueError；

**reverse()，** 反转deque中的元素，并返回None；

**rotate(n)，** 从右侧反转n步，如果n为负数，则从左侧反转，d.rotate(1)等于d.appendleft(d.pop())；

**maxlen，** 只读的属性，deque的最大长度，如果无解，就返回None；

除了以上的方法之外，deque还支持迭代、序列化、len(d)、reversed(d)、copy.copy(d)、copy.deepcopy(d)，通过in操作符进行成员测试和下标索引，索引的时间复杂度是在两端是O(1)，在中间是O(n)，为了快速获取，可以使用list代替

>>> from collections import deque
    >>> d = deque('ghi')# 新建一个deque，有三个元素
    >>> for ele in d:# 遍历deque
    ...     print ele.upper()
    ...     
    ... 
    G
    H
    I
    >>> d.append('j')# deque右侧添加一个元素
    >>> d.appendleft('f')# deque左侧添加一个元素
    >>> d# 打印deque
    deque(['f', 'g', 'h', 'i', 'j'])
    >>> d.pop()# 返回和移除最右侧元素
    'j'
    >>> d.popleft()# 返回和移除最左侧元素
    'f'
    >>> list(d)# 以列表形式展示出deque的内容
    ['g', 'h', 'i']
    >>> d[0]# 获取最左侧的元素
    'g'
    >>> d[-1]# 获取最右侧的元素
    'i'
    >>> list(reversed(d))# 以列表形式展示出倒序的deque的内容
    ['i', 'h', 'g']
    >>> 'h' in d# 在deque中搜索
    True
    >>> d.extend('jkl')# 一次添加多个元素
    >>> d
    deque(['g', 'h', 'i', 'j', 'k', 'l'])
    >>> d.rotate(1)# 往右侧翻转
    >>> d
    deque(['l', 'g', 'h', 'i', 'j', 'k'])
    >>> d.rotate(-1)# 往左侧翻转
    >>> d
    deque(['g', 'h', 'i', 'j', 'k', 'l'])
    >>> deque(reversed(d))# 以逆序新建一个deque
    deque(['l', 'k', 'j', 'i', 'h', 'g'])
    >>> d.clear()# 清空deque
    >>> d.pop()# 不能在空的deque上pop
    Traceback (most recent call last):
      File "<input>", line 1, in <module>
    IndexError: pop from an empty deque
    >>> d.extendleft('abc')# 以输入的逆序向左扩展
    >>> d
    deque(['c', 'b', 'a'])

**其他的应用：**

1.限定长度的deque提供了Unix中tail命令相似的功能；

from collections import deque
    
    def tail(filename,n = 10):
        "Return the last n lines of a file"
        return deque(open(filename),n)
    
    print tail("temp.txt",10)

2.使用deque维护一个序列（右侧添加元素，左侧删除元素）中窗口的平均值；

from collections import deque
    import itertools
    
    def moving_average(iterable,n = 3):
        it = iter(iterable)
        d = deque(itertools.islice(it,n-1))
        # 第一次只有两个元素，再右移的过程中，需要先删除最左端的元素，因此现在最左端加入0
        d.appendleft(0)
        s = sum(d)
        for ele in it:
            # 删除最左端的元素，再加上新元素
            s += ele - d.popleft()
            # 右端添加新元素
            d.append(ele)
            yield s / float(n)
    
    array = [40,30,50,46,39,44]
    for ele in moving_average(array,n=3):
        print ele

3.rotate()方法提供了一种实现deque切片和删除的方式，例如，del d\[n\]依赖于rotate方法的纯Python实现，如下，

from collections import deque
    
    def delete_nth(d,n):
        # 将前n个元素翻转到右侧
        d.rotate(-n)
        # 删除第n个元素
        d.popleft()
        # 再将后n个元素翻转到左侧
        d.rotate(n)
    
    d = deque("abcdefg")
    delete_nth(d,n = 3)
    print d4.slice依赖于rotate方法的纯Python实现，如下from collections import deque
    
    def slice(d,m,n):
        # 先将前面m个元素翻转到右侧
        d.rotate(-m)
        i = m
        sliceList = []
        # 依次将[m,n]区间内的元素出栈
        while i < n:
            item = d.popleft()
            sliceList.append(item)
            i+=1
        # 再将出栈的元素扩展到deque右侧
        d.extend(sliceList)
        # 再将后面n个元素翻转到左侧
        d.rotate(n)
        return sliceList
    
    d = deque("abcdefg")
    print slice(d,1,5)2.3 defaultdict
    defaultdict是内置数据类型dict的一个子类，基本功能与dict一样，只是重写了一个方法__missing__(key)和增加了一个可写的对象变量default_factory。>>> dir(defaultdict)
    ['__class__', '__cmp__', '__contains__', '__copy__', '__delattr__', '__delitem__
    ', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__
    ', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__',
    '__missing__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '
    __setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear
    ', 'copy', 'default_factory', 'fromkeys', 'get', 'has_key', 'items', 'iteritems'
    , 'iterkeys', 'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'v
    alues', 'viewitems', 'viewkeys', 'viewvalues']
    >>> dir(dict)
    ['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__'
    , '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__',
     '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '_
    _new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__'
    , '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get
    ', 'has_key', 'items', 'iteritems', 'iterkeys', 'itervalues', 'keys', 'pop', 'po
    pitem', 'setdefault', 'update', 'values', 'viewitems', 'viewkeys', 'viewvalues']missing(key)
    如果default_factory属性为None，就报出以key作为遍历的KeyError异常；

1.  如果default\_factory不为None，就会向给定的key提供一个默认值，这个值插入到词典中，并返回；
2.  如果调用default\_factory报出异常，这个异常在传播时不会改变；
3.  这个方法是当要求的key不存在时，dict类中的\_\_getitem()\_\_方法所调用，无论它返回或者报出什么，最终返回或报出给\_\_getitem()\_\_；
4.  只有\_\_getitem\_\_()才能调用\_\_missing\_\_()，这意味着，如果get()起作用，如普通的词典，将会返回None作为默认值，而不是使用default\_factory；

**default\_factory，** 这个属性用于\_\_missing\_\_()方法，使用构造器中的第一个参数初始化；

使用list作为default\_factory，很容易将一个key-value的序列转换为一个关于list的词典；

>>> from collections import *
    >>> s = [('yellow',1),('blue',2),('yellow',3),('blue',4),('red',5)]
    >>> d = defaultdict(list)
    >>> for k,v in s: d[k].append(v)
    ... 
    >>> d.items()
    [('blue', [2, 4]), ('red', [5]), ('yellow', [1, 3])]当每一个key第一次遇到时，还没有准备映射，首先会使用default_factory函数自动创建一个空的list，list.append()操作将value添加至新的list中，当key再次遇到时，通过查表，返回对应这个key的list，list.append()会将新的value添加至list，这个技术要比dict.setdefault()要简单和快速。

>>> e = {}
    >>> for k,v in s: e.setdefault(k,[]).append(v)
    ... 
    >>> e.items()
    [('blue', [2, 4]), ('red', [5]), ('yellow', [1, 3])]

设置default\_factory为int，使得defaultdict可以用于计数，

>>> s = "mississippi"
    >>> d = defaultdict(int)
    >>> for k in s: d[k]+=1
    ... 
    >>> d.items()
    [('i', 4), ('p', 2), ('s', 4), ('m', 1)]

当一个字母第一次遇到，默认从default\_factory中调用int()用于提供一个默认为0的计数，递增操作会增加每个字母的计数。

函数int()经常返回0，是常量函数的一种特例。一种更快和更灵活的创建常量函数的方式是使用itertools.repeat()，可以提供任意常量值（不仅仅是0），

>>> import itertools
    >>> def constant_factory(value):
    ...     return itertools.repeat(value).next
    ... 
    >>> d = defaultdict(constant_factory('<missing>'))
    >>> d.update(name = "John",action = "ran")
    >>> "%(name)s %(action)s to %(object)s"%d
    'John ran to <missing>'

将default\_factory设置为set，使得defaultdict可以建立一个关于set的词典，

>>> s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue',
    4)]
    >>> d = defaultdict(set)
    >>> for k,v in s:d[k].add(v)
    ... 
    >>> d.items()
    [('blue', set([2, 4])), ('red', set([1, 3]))]

### 2.4 namedtuple ###

命名的元组，意味给元组中的每个位置赋予含义，意味着代码可读性更强，namedtuple可以在任何常规元素使用的地方使用，而且它可以通过名称来获取字段信息而不仅仅是通过位置索引。

>>> from collections import *
    >>> Point = namedtuple('Point',['x','y'],verbose = True)
    class Point(tuple):
        'Point(x, y)'
    
        __slots__ = ()
    
        _fields = ('x', 'y')
    
        def __new__(_cls, x, y):
            'Create new instance of Point(x, y)'
            return _tuple.__new__(_cls, (x, y))
    
        @classmethod
        def _make(cls, iterable, new=tuple.__new__, len=len):
            'Make a new Point object from a sequence or iterable'
            result = new(cls, iterable)
            if len(result) != 2:
                raise TypeError('Expected 2 arguments, got %d' % len(result))
            return result
    
        def __repr__(self):
            'Return a nicely formatted representation string'
            return 'Point(x=%r, y=%r)' % self
    
        def _asdict(self):
            'Return a new OrderedDict which maps field names to their values'
            return OrderedDict(zip(self._fields, self))
    
        def _replace(_self, **kwds):
            'Return a new Point object replacing specified fields with new values'
            result = _self._make(map(kwds.pop, ('x', 'y'), _self))
            if kwds:
                raise ValueError('Got unexpected field names: %r' % kwds.keys())
            return result
    
        def __getnewargs__(self):
            'Return self as a plain tuple.  Used by copy and pickle.'
            return tuple(self)
    
        __dict__ = _property(_asdict)
    
        def __getstate__(self):
            'Exclude the OrderedDict from pickling'
            pass
    
        x = _property(_itemgetter(0), doc='Alias for field number 0')
    
        y = _property(_itemgetter(1), doc='Alias for field number 1'

>>> p = Point(11,y = 22)# 实例化一个对象，可以使用位置或者关键字
    >>> p[0] + p[1]# 通过索引访问元组中的元素
    33
    >>> x,y = p# 分开，类似于常规的元组
    >>> x,y
    (11, 22)
    >>> p.x + p.y# 通过名称访问元素
    33
    >>> p# 可读的__repr__，通过name = value风格
    Point(x=11, y=22)

namedtuple在给csv或者sqlite3返回的元组附上名称特别有用，

from collections import *
    import csv
    
    EmployeeRecord = namedtuple('EmployeeRecord','name, age, title, department, paygrade')
    for emp in map(EmployeeRecord._make,csv.reader(open("employee.csv","rb"))):
        print emp.name,emp.title
    
    # import sqlite3
    # conn = sqlite3.connect('/companydata')
    # cursor = conn.cursor()
    # cursor.execute('SELECT name, age, title, department, paygrade FROM employees')
    # for emp in map(EmployeeRecord._make, cursor.fetchall()):
    #     print emp.name, emp.title

控制台输出，

Jim RD
    Tom Manager

除了从tuples继承的方法之外，namedtuple还支持三种方法和一个属性，为了避免和名称冲突，这些方法和属性以下划线开始。

\*\*somenamedtuple.\_make()，\*\* 从已有的序列或者可迭代的对象中创建一个新的对象；

>>> Point = namedtuple('Point', ['x', 'y'])
    >>> t = [33,44]
    >>> Point._make(t)
    Point(x=33, y=44)

\*\*somenamedtuple.\_asdict()，\*\* 返回一个OrderDict，由名称到对应值建立的映射；

>>> p = Point(x = 11,y = 22)
    >>> p
    Point(x=11, y=22)
    >>> pDict = p._asdict()
    >>> pDict
    OrderedDict([('x', 11), ('y', 22)])

\*\*somenamedtuple.\_replace()，\*\* 返回一个新的namedtuple对象，用新值替换指定名称中的值；

>>> p2 = p._replace(x = 33)
    >>> p2
    Point(x=33, y=22)

\*\*somenamedtuple.\_fields，\*\* 以字符串构成的元组的形式返回namedtuple中的名称，在自省或者基于一个已经存在的namedtuple中创建新的namedtuple时，非常有用；

>>> p._fields
    ('x', 'y')
    >>> Color = namedtuple('Color',"red green blu")
    >>> Pixel = namedtuple('Pixel',Point._fields + Color._fields)
    >>> Pixel(11,22,128,255,0)
    Pixel(x=11, y=22, red=128, green=255, blu=0)

当名称存储在字符串中，可以使用getattr()函数进行检索，

>>> getattr(p,'x')
    11

使用\*\*操作符，可以将一个字典转换成namedtuple，

>>> d  = {'x':11,'y':22}
    >>> Point(**d)
    Point(x=11, y=22)

由于namedtuple也是Python中的一个类，因此再子类中，它很容易添加或者修改一些功能，如下是添加一个可计算名称和固定长度的输出格式；子类中的\_\_slots\_\_是一个空的元组，可以通过避免词典实例的创建来节约内存开销；

class Point(namedtuple('Point','x y')):
        __slots__ = ()
        @property
        def hypot(self):
            return (self.x ** 2 + self.y**2) ** 0.5
        def __str__(self):
            return "Point:x = %6.3f  y = %6.3f  hypot = %6.3f" %(self.x,self.y,self.hypot)
    
    for p in Point(3,4),Point(14,5/7.):
        print

控制台输出，

Point:x =  3.000  y =  4.000  hypot =  5.000
    Point:x = 14.000  y =  0.714  hypot = 14.018

子类在增加、存储名称时，并不是非常有用，相反，可以容易地通过\_fields属性来创建一个新的namedtuple；

>>> Point3D = namedtuple("Point3D",Point._fields + ('z',))
    >>> Point3D._fields
    ('x', 'y', 'z')

默认值可以通过\_replace()来实现，以便于标准化一个原型实例；

>>> Account = namedtuple('Account','owner balance transaction_count')
    >>> default_account = Account('<owner name>',0.0,0)
    >>> johns_account = default_account._replace(owner = "John")
    >>> johns_account
    Account(owner='John', balance=0.0, transaction_count=0)

枚举类型常量可以通过namedtuple来实现，更简单和有效的方式是通过意见简单的类声明；

Status = namedtuple('Status','open pending closed')._make(range(3))
    print Status
    
    class Status:
    open, pending, closed = range(3)
    
    print Status.open
    print Status.pending
    print Status.close

控制台输出，

Status(open=0, pending=1, closed=2)
    0
    1
    2

### 2.5 OrderedDict ###

OrderedDict类似于正常的词典，只是它记住了元素插入的顺序，当在有序的词典上迭代时，返回的元素就是它们第一次添加的顺序。

class collections.OrderedDict，返回已给dict的子类，支持常规的dict的方法，OrderedDict是一个记住元素首次插入顺序的词典，如果一个元素重写已经存在的元素，那么原始的插入位置保持不变，如果删除一个元素再重新插入，那么它就在末尾。

OrderedDict.popitem(last=True)，popitem方法返回和删除一个(key,value)对，如果last=True，就以LIFO方式执行，否则以FIFO方式执行。

OrderedDict也支持反向迭代，例如reversed()。

OrderedDict对象之间的相等测试，例如，list(od1.items()) == list(od2.items())，是对顺序敏感的；OrderedDict和其他的映射对象（例如常规的词典）之间的相等测试是顺序不敏感的，这就允许OrderedDict对象可以在使用常规词典的地方替换掉常规词典。

OrderedDict构造器和update()方法可以接受关键字变量，但是它们丢失了顺序，因为Python的函数调用机制是将一个无序的词典传入关键字变量。

一个有序的词典记住它的成员插入的顺序，可以使用排序函数，将其变为排序的词典，

>>> d = {"banana":3,"apple":2,"pear":1,"orange":4}
    >>> # dict sorted by key
    >>> OrderedDict(sorted(d.items(),key = lambda t:t[0]))
    OrderedDict([('apple', 2), ('banana', 3), ('orange', 4), ('pear', 1)])
    >>> # dict sorted by value
    >>> OrderedDict(sorted(d.items(),key = lambda t:t[1]))
    OrderedDict([('pear', 1), ('apple', 2), ('banana', 3), ('orange', 4)])
    >>> # dict sorted by length of key string
    >>>a =  OrderedDict(sorted(d.items(),key = lambda t:len(t[0])))
    >>>a
    OrderedDict([('pear', 1), ('apple', 2), ('orange', 4), ('banana', 3)])
    >>> del a['apple']
    >>> a
    OrderedDict([('pear', 1), ('orange', 4), ('banana', 3)])
    >>> a["apple"] = 2
    >>> a
    OrderedDict([('pear', 1), ('orange', 4), ('banana', 3), ('apple', 2)]当元素删除时，排好序的词典保持着排序的顺序；但是当新元素添加时，就会被添加到末尾，就不能保持已排序。

创建一个有序的词典，可以记住最后插入的key的顺序，如果一个新的元素要重写已经存在的元素，那么原始的插入位置就会改变成末尾，

>>> class LastUpdatedOrderedDict(OrderedDict):
    ...     def __setitem__(self,key,value):
    ...         if key in self:
    ...             del self[key]
    ...         OrderedDict.__setitem__(self, key, value)
    ... 
    >>> obj = LastUpdatedOrderedDict()
    >>> obj["apple"] = 2
    >>> obj["windows"] = 3
    >>> obj
    LastUpdatedOrderedDict([('apple', 2), ('windows', 3)])
    >>> obj["apple"] = 1
    >>> obj
    LastUpdatedOrderedDict([('windows', 3), ('apple', 1)])一个有序的词典可以和Counter类一起使用，counter对象就可以记住元素首次出现的顺序class OrderedCounter(Counter,OrderedDict):
        def __repr__(self):
            return "%s(%r)"%(self.__class__.__name__,OrderedDict(self))
    
        def __reduce__(self):
            return self.__class__,(OrderedDict(self))
    
    #和OrderDict一起使用的Counter对象
    obj = OrderedCounter()
    wordList = ["b","a","c","a","c","a"]
    for word in wordList:
        obj[word] += 1
    print obj
    
    # 普通的Counter对象
    cnt = Counter()
    wordList = ["b","a","c","a","c","a"]
    for word in wordList:
        cnt[word] += 1
    print cnt控制台输出，OrderedCounter(OrderedDict([('b', 1), ('a', 3), ('c', 2)]))
    Counter({'a': 3, 'c': 2, 'b': 1})3.Reference
    8.3. collections — High-performance container datatypes