Python标准模块--collections

Python标准模块--collections



1.模块简介

collections包含了一些特殊的容器，针对Python内置的容器，例如list、dict、set和tuple，提供了另一种选择；



namedtuple，可以创建包含名称的tuple；



deque，类似于list的容器，可以快速的在队列头部和尾部添加、删除元素；



Counter，dict的子类，计算可hash的对象；



OrderedDict，dict的子类，可以记住元素的添加顺序；



defaultdict，dict的子类，可以调用提供默认值的函数；



2.模块使用

2.1Counter



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



fromcollectionsimport



cnt=Counter()

wordList=["a","b","c","c","a","a"]

forwordinwordList:

cnt[word]+=1

printcnt

控制台输出，



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''依然存在

>>>delc[''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.2deque



deque是栈和队列的一种广义实现，deque是"double-endqueue"的简称；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代替。



>>>fromcollectionsimportdeque

>>>d=deque(''ghi'')#新建一个deque，有三个元素

>>>foreleind:#遍历deque

...printele.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''ind#在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(mostrecentcalllast):

File"",line1,in

IndexError:popfromanemptydeque

>>>d.extendleft(''abc'')#以输入的逆序向左扩展

>>>d

deque([''c'',''b'',''a''])

其他的应用：



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



fromcollectionsimportdeque



deftail(filename,n=10):

"Returnthelastnlinesofafile"

returndeque(open(filename),n)



printtail("temp.txt",10)

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



fromcollectionsimportdeque

importitertools



defmoving_average(iterable,n=3):

it=iter(iterable)

d=deque(itertools.islice(it,n-1))

#第一次只有两个元素，再右移的过程中，需要先删除最左端的元素，因此现在最左端加入0

d.appendleft(0)

s=sum(d)

foreleinit:

#删除最左端的元素，再加上新元素

s+=ele-d.popleft()

#右端添加新元素

d.append(ele)

yields/float(n)



array=[40,30,50,46,39,44]

foreleinmoving_average(array,n=3):

printele

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



fromcollectionsimportdeque



defdelete_nth(d,n):

#将前n个元素翻转到右侧

d.rotate(-n)

#删除第n个元素

d.popleft()

#再将后n个元素翻转到左侧

d.rotate(n)



d=deque("abcdefg")

delete_nth(d,n=3)

printd

4.slice依赖于rotate方法的纯Python实现，如下，



fromcollectionsimportdeque



defslice(d,m,n):

#先将前面m个元素翻转到右侧

d.rotate(-m)

i=m

sliceList=[]

#依次将[m,n]区间内的元素出栈

whilei
item=d.popleft()

sliceList.append(item)

i+=1

#再将出栈的元素扩展到deque右侧

d.extend(sliceList)

#再将后面n个元素翻转到左侧

d.rotate(n)

returnsliceList



d=deque("abcdefg")

printslice(d,1,5)

2.3defaultdict



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异常；

如果default_factory不为None，就会向给定的key提供一个默认值，这个值插入到词典中，并返回；

如果调用default_factory报出异常，这个异常在传播时不会改变；

这个方法是当要求的key不存在时，dict类中的__getitem()__方法所调用，无论它返回或者报出什么，最终返回或报出给__getitem()__；

只有__getitem__()才能调用__missing__()，这意味着，如果get()起作用，如普通的词典，将会返回None作为默认值，而不是使用default_factory；

default_factory，这个属性用于__missing__()方法，使用构造器中的第一个参数初始化；



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



>>>fromcollectionsimport

>>>s=[(''yellow'',1),(''blue'',2),(''yellow'',3),(''blue'',4),(''red'',5)]

>>>d=defaultdict(list)

>>>fork,vins: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={}

>>>fork,vins:e.setdefault(k,[]).append(v)

...

>>>e.items()

[(''blue'',[2,4]),(''red'',[5]),(''yellow'',[1,3])]

设置default_factory为int，使得defaultdict可以用于计数，



>>>s="mississippi"

>>>d=defaultdict(int)

>>>forkins:d[k]+=1

...

>>>d.items()

[(''i'',4),(''p'',2),(''s'',4),(''m'',1)]

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



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



>>>importitertools

>>>defconstant_factory(value):

...returnitertools.repeat(value).next

...

>>>d=defaultdict(constant_factory(''''))

>>>d.update(name="John",action="ran")

>>>"%(name)s%(action)sto%(object)s"%d

''Johnranto''

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



>>>s=[(''red'',1),(''blue'',2),(''red'',3),(''blue'',4),(''red'',1),(''blue'',

4)]

>>>d=defaultdict(set)

>>>fork,vins:d[k].add(v)

...

>>>d.items()

[(''blue'',set([2,4])),(''red'',set([1,3]))]

2.4namedtuple



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



>>>fromcollectionsimport

>>>Point=namedtuple(''Point'',[''x'',''y''],verbose=True)

classPoint(tuple):

''Point(x,y)''



__slots__=()



_fields=(''x'',''y'')



def__new__(_cls,x,y):

''CreatenewinstanceofPoint(x,y)''

return_tuple.__new__(_cls,(x,y))



@classmethod

def_make(cls,iterable,new=tuple.__new__,len=len):

''MakeanewPointobjectfromasequenceoriterable''

result=new(cls,iterable)

iflen(result)!=2:

raiseTypeError(''Expected2arguments,got%d''%len(result))

returnresult



def__repr__(self):

''Returnanicelyformattedrepresentationstring''

return''Point(x=%r,y=%r)''%self



def_asdict(self):

''ReturnanewOrderedDictwhichmapsfieldnamestotheirvalues''

returnOrderedDict(zip(self._fields,self))



def_replace(_self,kwds):

''ReturnanewPointobjectreplacingspecifiedfieldswithnewvalues''

result=_self._make(map(kwds.pop,(''x'',''y''),_self))

ifkwds:

raiseValueError(''Gotunexpectedfieldnames:%r''%kwds.keys())

returnresult



def__getnewargs__(self):

''Returnselfasaplaintuple.Usedbycopyandpickle.''

returntuple(self)



__dict__=_property(_asdict)



def__getstate__(self):

''ExcludetheOrderedDictfrompickling''

pass



x=_property(_itemgetter(0),doc=''Aliasforfieldnumber0'')



y=_property(_itemgetter(1),doc=''Aliasforfieldnumber1'')





>>>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返回的元组附上名称特别有用，



fromcollectionsimport

importcsv



EmployeeRecord=namedtuple(''EmployeeRecord'',''name,age,title,department,paygrade'')

forempinmap(EmployeeRecord._make,csv.reader(open("employee.csv","rb"))):

printemp.name,emp.title



#importsqlite3

#conn=sqlite3.connect(''/companydata'')

#cursor=conn.cursor()

#cursor.execute(''SELECTname,age,title,department,paygradeFROMemployees'')

#forempinmap(EmployeeRecord._make,cursor.fetchall()):

#printemp.name,emp.title

控制台输出，



JimRD

TomManager

除了从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'',"redgreenblu")

>>>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__是一个空的元组，可以通过避免词典实例的创建来节约内存开销；



classPoint(namedtuple(''Point'',''xy'')):

__slots__=()

@property

defhypot(self):

return(self.x2+self.y2)0.5

def__str__(self):

return"Point:x=%6.3fy=%6.3fhypot=%6.3f"%(self.x,self.y,self.hypot)



forpinPoint(3,4),Point(14,5/7.):

printp

控制台输出，



Point:x=3.000y=4.000hypot=5.000

Point:x=14.000y=0.714hypot=14.018

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



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

>>>Point3D._fields

(''x'',''y'',''z'')

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



>>>Account=namedtuple(''Account'',''ownerbalancetransaction_count'')

>>>default_account=Account('''',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'',''openpendingclosed'')._make(range(3))

printStatus



classStatus:

open,pending,closed=range(3)



printStatus.open

printStatus.pending

printStatus.closed

控制台输出，



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

0

1

2

2.5OrderedDict



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



classcollections.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}

>>>#dictsortedbykey

>>>OrderedDict(sorted(d.items(),key=lambdat:t[0]))

OrderedDict([(''apple'',2),(''banana'',3),(''orange'',4),(''pear'',1)])

>>>#dictsortedbyvalue

>>>OrderedDict(sorted(d.items(),key=lambdat:t[1]))

OrderedDict([(''pear'',1),(''apple'',2),(''banana'',3),(''orange'',4)])

>>>#dictsortedbylenwww.wang027.comgthofkeystring

>>>a=OrderedDict(sorted(d.items(),key=lambdat:len(t[0])))

>>>a

OrderedDict([(''pear'',1),(''apple'',2),(''orange'',4),(''banana'',3)])

>>>dela[''apple'']

>>>a

OrderedDict([(''pear'',1),(''orange'',4),(''banana'',3)])

>>>a["apple"]=2

>>>a

OrderedDict([(''pear'',1),(''orange'',4),(''banana'',3),(''apple'',2)])

当元素删除时，排好序的词典保持着排序的顺序；但是当新元素添加时，就会被添加到末尾，就不能保持已排序。



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



>>>classLastUpdatedOrderedDict(OrderedDict):

...def__setitem__(self,key,value):

...ifkeyinself:

...delself[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对象就可以记住元素首次出现的顺序；



classOrderedCounter(Counter,OrderedDict):

def__repr__(self):

return"%s(%r)"%(self.__class__.__name__,OrderedDict(self))



def__reduce__(self):

returnself.__class__,(OrderedDict(self))



#和OrderDict一起使用的Counter对象

obj=OrderedCounter()

wordList=["b","a","c","a","c","a"]

forwordinwordList:

obj[word]+=1

printobj



#普通的Counter对象

cnt=Counter()

wordList=["b","a","c","a","c","a"]

forwordinwordList:

cnt[word]+=1

printcnt

控制台输出，



OrderedCounter(OrderedDict([(''b'',1),(''a'',3),(''c'',2)]))

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