collection系列功能介绍
1. 常用的集中类
1. Counter(计数器)
计数器的常用方法如下：
-
创建一个字典计数器
格式：collections.Counter(obj) 例如：print(collections.Counter('abcab')) >>> Counter({'a': 2, 'c': 2, 'b': 1}) 返回值：collections.Counter #把传入的字符串进行单个字符拆分，字符作为字典计数器的key，字符出现的个数作为字典计数器的value。 print(collections.Counter([1,2,3,2,3])) >>> Counter({1: 1, 2: 2, 3: 2}) 返回值：collections.Counter #把元祖的元素进行统计，返回每个元素的个数。 print(collections.Counter((1,2,3,1,3))) >>> Counter({1: 2, 2: 1, 3: 2}) 返回值：collections.Counter #把元祖的元素进行统计，返回每个元素的个数。 print(collections.Counter({1,2,3})) >>> Counter({1: 1, 2: 1, 3: 1}) 返回值：collections.Counter #统计集合中元素的个数，由于集合天生除重，因此每个元素的个数均为1。 print(collections.Counter({'a':'b','b':'c'})) >>> Counter({'b': 'c', 'a': 'b'}) 返回值：collections.Counter #当参数为字典时，返回值不再是统计个数。注：由于该类是对字典的增强，因此字典拥有的方法，该类都有。
-
clear(清空字典计数器)
格式：collections.Counter(obj).clear() 例如：print(collections.Counter('abcab').clear()) >>> Counter() 返回值：collections.Counter #对原字典计数器进行操作，清空所有元素。 -
copy(复制)
格式：collections.Counter(obj).copy() 例如：print(collections.Counter('abccc').copy()) >>> Counter({'c': 3, 'a': 1, 'b': 1}) 返回值：collections.Counter #复制一个字典计数器 -
elements(成员)
格式：collections.Counter(obj).elements() 例如：print(collections.Counter('abccc').elements()) >>> itertools.chain object at 0x0000000000D26518 返回值：itertools.chain for i in collections.Counter('abccc').elements(): print(i) >>> 'a' >>> 'b' >>> 'c' #获取成员后生成一个迭代器，遍历时得到的是字典计数器中的key。 -
get(获取字典计数器的值)
格式：collections.Counter(obj).get(key[,value]) 例如：print(collections.Counter('abccc').get('c')) >>> 3 print(collections.Counter('abccc').get('d','adc')) >>> 'adc' 返回值：obj #获取字典计数器指定key的value,如果key不存在时，可以指定key的value。 -
items(所有的键值对)
格式：collections.Counter(obj).items() 例如：print(collections.Counter('abccc').items()) >>> dict_items([('a', 1), ('c', 3), ('b', 1)]) 返回值：dict_items #获取字典计数器的键值对，每对字典计数器的key和value作为一个元祖的两个元素，该元祖又作为列表的元素返回。可以通过遍历获取字典计数器的key和value。 -
keys(所有的键)
格式：collections.Counter(obj).keys() 例如：print(collections.Counter('abccc').keys()) >>> dict_keys(['a', 'c', 'b']) 返回值：dict_keys #把字典计数器中所有的key作为列表的元素返回。 -
most_common(取前面的N个元素)
格式：collections.Counter(obj).most_common(number) 例如：print(collections.Counter('abccc').most_common()) >>> [('c', 3), ('a', 1), ('b', 1)] print(collections.Counter('abccc').most_common(1)) >>> [('c', 3)] 返回值：list #把每对key和value作为元祖的两个元素，该元祖又作为列表的元组返回，对返回的列表进行排序，默认倒序，参考依据为列表中元祖的第二个元素，也就是原字典计数器中元素的个数。 -
pop(指定键删除字典计数器的值)
格式：collections.Counter(obj).pop(key[,value]) 例如：print(collections.Counter('abccc').pop('a')) >>> 1 print(collections.Counter('abccc').pop('d',5)) >>> 5 返回值：obj #指定字典计数器的key进行删除，同时返回被删除的value，当key不存在时，如果不指定value,程序将报错，当指定value时，将返回value。 -
popitem(随机删一对键值对)
格式：collections.Counter(obj).popitem() 例如：print(collections.Counter('abccc').popitem()) >>> ('a',1) 返回值：tuple #随机删除一对键值对，并以元祖的形式返回被删除的键值对。 -
setdefault(默认字典计数器)
格式：collections.Counter(obj).setdefault(key[,value]) 例如：print(collections.Counter('abccc').setdefault('a')) >>> 1 print(collections.Counter('abccc').setdefault('a',6)) >>> 1 print(collections.Counter('abccc').setdefault('d')) >>> None print(collections.Counter('abccc').setdefault('e',5)) >>> 5 返回值：obj #设置字典计数器的默认value，当该key存在时，该操作不改变原字典计数器，当key不存在时，如果不知道value，则默认为None,如果指定value，则字典新增key的值即为value。 -
subtract(减去)
格式：collections.Counter(obj).subtract(*args,**kwargs) 例如：sub = collections.Counter('abccc') print(sub) >>> Counter({'c': 3, 'a': 1, 'b': 1}) sub1 = sub.subtract('a') print(sub1) >>> None print(sub) >>> Counter({'c': 3, 'b': 1, 'a': 0}) 返回值：None sub2 = sub.subtract('d') print(sub) >>> Counter({'c': 3, 'b': 1, 'a': 0, 'd': -1}) sub3 = sub.subtract(('b',3)) >>> Counter({'c': 3, 'a': 0, 'b': 0, 'd': -1, 3: -1}) sub4 = sub.subtract({'a':2}) >>> Counter({'c': 3, 'b': 0, 'd': -1, 3: -1, 'a': -2}) #更新原字典计数器，如果传入的参数为字符串，那么该字符串将作为字典计数器的key，如果该key存在，则直接key对于的value减去1，当key不存在，则新增一对键值对，value为-1，当传入的参数为元祖时，元祖的元素均作为key更新原字典计数器，如果传入的参数为字典计数器时，如果有key相同，则value直接相减，如果key不同，则value为-value。 -
update(更新字典计数器)
格式：collections.Counter(obj) 返回值：None #该方法为相加与subtract刚好相反，具体实例参考上述方法。 -
values(所有的值)
格式：collections.Counter(obj).values() 例如：print(collections.Counter('abccc').values()) >>> dict_values([1, 3, 1]) 返回值：dict_values #把字典计数器中所有的value作为列表的元素返回。
2.OrderedDict(有序字典)
有序字典的常用方法如下：
-
创建一个有序字典
格式：collections.OrderedDict(variable=value) 例如：print(collections.OrderedDict(a='abcd')) >>> OrderedDict([('a', 'abcd')]) 格式：collections.OrderedDict(dict) 例如：print(collections.OrderedDict({'a':'ab','b':'bc'})) >>> OrderedDict([('b', 'bc'), ('a', 'ab')]) 返回值：collections.OrderedDict #创建一个有序的字典常用的还是第二种，第一种方法一次只能创建一对键值对的有序字典。注：有序字典的键值对和字典不一样，有序字典的键值对是以元祖的形式存在,但字典所拥有的功能，有序字典也有。
-
clear(清空字典)
格式：collections.OrderecDict(dict).clear() 例如：print(collections.OrderedDict({'a':'ab','b':'bc'}).clear()) >>> None 返回值：None #把原有序字典进行清空 -
copy(复制)
格式：collections.OrderedDict(dict).copy() 例如：print(collections.OrderedDict({'a':'ab','b':'bc'}).copy()) >>> OrderedDict([('b', 'bc'), ('a', 'ab')]) 返回值：collections.OrderedDict #复制原有序字典，生成新的一个有序字典。 -
fromkeys(创建值相同的新有序字典)
格式：collections.OrderedDict(dict).fromkeys(obj[,value]) 例如：print(collections.OrderedDict({'a':'ab','b':'bc'}).fromkeys('xyz')) >>> OrderedDict([('x', None), ('y', None), ('z', None)]) 返回值：collections.OrderedDict #创建新默认有序字典，顺序从左到右，传入的第一个参数（int类除外）将作为新有序字典的key，当第一个参数为字典时，将只取其key作为新有序字典的key，第二个参数为新有序字典的value，默认为None。注：创建新有序字典时，元素的位置为传入时的，从左到右。
-
get(获取有序字典的值)
格式：collections.OrderedDict(dict).get(k[,value]) 例如：print(collections.OrderedDict({'a':'ab','b':'bc'}).get('c','xx')) >>> 'xx' 返回值：obj #当指定获取有序字典的key时，如果key存在，将直接返回有序字典的value，忽略第二个参数，当key不存在时，将直接返回传入的第二个参数，默认为None。 -
items(获取有序字典的键值对)
格式：collections.OrderedDict(dict).items() 例如：print(collections.OrderedDict({'a':'ab','b':'bc'}).items()) >>> odict_items([('b', 'bc'), ('a', 'ab')]) 返回值：odict_items #由于有序字典里面其实也是一个列表，因此该方法获取到的内容和元素和有序字典的元素是一样的。 -
keys(获取有序字典所有的键)
格式：collections.OrderedDict(dict).keys() 例如：print(collections.OrderedDict({'a':'ab','b':'bc'}).keys() >>> odict_keys(['b', 'a']) 返回值：odict_keys #把有序字典所有的key作为列表的元素返回。 -
movetoend(指定键的键值对移动到末尾)
格式：collections.OrderedDict(dict).move_to_end(key) 例如：print(collections.OrderedDict({'a':'ab','b':'bc'}).move_to_end('a')) >>> None 返回值：None #该方法直接操作原有序字典，指定key的键值对将移动到有序字典的最右边，如果该键值对已在有序字典的最右边，程序也不会报错。 -
pop(删除指定键的键值对)
格式：collections.OrderedDict(dict).pop(key[,value]) 例如：print(collections.OrderedDict({'a':'ab','b':'bc'}).pop('a')) >>> 'ab' 返回值：obj #删除指定key的键值对，并返回该键值对的value，当key存在时，将返回key对应的value,当key不存在时，如果指定第二个参数将返回第二个参数，否则将报错。 -
popitem(删除最右边的键值对)
格式：collections.OrderedDict(dict).popitem() 例如：print(collections.OrderedDict({'a':'ab','b':'bc'}).popitem()) >>> ('a', 'ab') 返回值：tuple #删除有序字典最右边的键值对，并返回该键值对，由于有序字典的键值对是一元祖的形式存在，因此返回的类型为元祖类型。 -
setdefault(设置默认有序字典)
格式：collections.OrderedDict(dict).setdefault(key[,value]) 例如：print(collections.OrderedDict({'a':'ab','b':'bc'}).setdefault('a')) >>> 'ab' 返回值：obj #设置有序字典的默认value,当key存在时，将不进行修改，当key不存在时，第二个参数将作为新key的默认value，当不指定第二个参数时，默认value为None。 -
update(更新有序字典)
格式：collections.OrderedDict(dict).update(dict) 例如：print(collections.OrderedDict({'a':'ab','b':'bc'}).update({'c':'cd'})) >>> None 返回值：None #更新原有序字典，传入参数的字典的键值对作为有序字典的元祖。 -
values(获取有序字典所有的值)
格式：collections.OrderedDict(dict).values() 例如：print(collections.OrderedDict({'a':'ab','b':'bc'}).values()) >>> odict_values(['bc', 'ab']) 返回值：odict_values #把有序字典所有的values作为列表的元素返回。
3. defaultdict(默认字典)
格式：collections.defaultdict(type)
例如：dic_l = collections.defaultdict(list)#创建一个空的默认字典，默认值的类型为list。
dic['k1'].append(1)
print(dic)
>>> defaultdict(<class 'list'>, {'k1':[1]})
返回值：defaultdict(<class 'list'>, {})
#可以设置默认字典默认值的类型为list、tuple、dict和set，添加键值对时，就可以调用相应类的方法。由于其方法与字典和有序字典一样，因此这里不做详细介绍。
4. namedtuple(可命名元祖)
由于该系列没有定义该类，需要手动创建类。
-
创建类
格式：name = collections.namedtuple('name',type) tu = name(obj) 例如：name_tuple = collections.namedtuple('name_tuple',['x','y','z']) tu = name_tuple(1,3,4) print(tu) >>> name_tuple(x=1,y=3,z=4) #定义该类时，指定类的名字和元祖元素的名字的类型，常用list和tuple，因为dict和set是无序的，因此在传入参数时不能按照定义类时，元祖元素的名字一致。注：定义类时，指定元祖元素名字的类型时，其个数与创建元祖时需要一致，当定义的类型为dict时，只取dict的key。
-
调用方法
例如：print(tu.x) >>> 1 print(tu[2]) >>> 4 #一般元祖获取元素时，只能通过切片的方法，但如果不知道该元素的下标时，将无法获取，该方法就是通过命名直接获取，无需知道元素的下标，当然也是可以切片方法获取。由于元祖不可能修改，因此方法只有index和count两种，由于这两种方法的参数是value，因此这里也不做详细介绍。
5. deque(双向队列)
-
创建双向队列
格式：collections.deque(obj[,maxlen]) 例如：print(collections.deque())#创建空队列 >>> deque([]) 返回值：collections.deque print(collections.deque('abc'))#元素为字符串的队列,未指定最大长度 >>> deque(['a', 'b', 'c']) print(collections.deque('abc',2))#指定最大长度 >>> deque(['b', 'c'], maxlen=2) #当指定最大长度时，如果队列长度大于限定的最大长度时，将删除最先传入的元素。 print(collections.deque([1,2,3,4],5))#元素为列表的队列 >>> deque([1, 2, 3, 4], maxlen=5) #当限定的最大长度大于队列的实际长度时，将不会增加默认元素。 -
append(右边添加元素)
格式：collections.deque(obj[,maxlen]).append(obj) 例如：que = collections.deque([1,2,3,4],5) print(que.append((1,2,3,))) >>> None 返回值：None print(que) >>> deque([1, 2, 3, 4, (1, 2, 3)], maxlen=5) #直接在原队列的最右边添加，传入的参数可以是int类型，而且传入的参数作为一个整体传入到队列中，如果超出限定的最大长度时，将删除最左边的元素。 -
appendleft(左边添加元素)
格式：collections.deque(obj[,maxlen]).appendleft(obj) 例如：que = collections.deque([1,2,3,4],5) print(que.appendleft((1,2,3,))) >>> None 返回值：None print(que) >>> deque([(1, 2, 3), 1, 2, 3, 4], maxlen=5) #直接在原队列的最左边添加，传入的参数可以是int类型，而且传入的参数作为一个整体传入到队列中，如果超出限定的最大长度时，将删除最右边的元素。 -
clear(清空队列)
格式：collections.deque(obj[,maxlen]).clear() 例如：que = collections.deque([1,2,3,4],5) print(que.clear()) >>> None 返回值：None print(que) >>> deque([], maxlen=5) #清空原队列。 -
copy(复制队列)
格式：collections.deque(obj[,maxlen]).copy() 例如：que = collections.deque([1,2,3,4],5) print(que.copy()) >>> deque([1, 2, 3, 4], maxlen=5) 返回值：collections.deque #复制原队列，生成一个新队列。 -
count(计数)
格式：collections.deque(obj[,maxlen]).count(value) 例如：que = collections.deque([1,2,3,4],5) print(que.count(2)) >>> 1 返回值：int #统计队列中元素的个数。 -
extend(扩展队列)
格式：collections.deque(obj[,maxlen]).extend(obj) 例如：que = collections.deque([1,2,3,4],5) print(que.extend('abc')) >>> None 返回值：None print(que) >>> deque([3, 4, 'a', 'b', 'c'], maxlen=5) #扩展也是在队列的最右边进行扩展，如果队列长度超出最大限度长度，将删除队列最左边的元素。 -
index(查找元素下标)
格式：collections.deque(obj[,maxlen]).index(value[start,[stop]]) 例如：que = collections.deque([1,2,3,4],5) print(que.index(4)) >>> 3 返回值：int #返回元素的下标，可以指定开始和结束范围，当元素不存在时，程序报错。 -
insert(插入)
格式：collections.deque(obj[,maxlen]).insert(index,obj) 例如：que = collections.deque([1,2,3,4],5) print(que.insert(3,'abc')) >>> None 返回值：None print(que) >>> deque([1, 2, 3, 'abc', 4], maxlen=5) #指定位置插入元素，直接修改原队列。 -
pop(删除最右边的元素)
格式：collections.deque(obj[,maxlen]).pop() 例如：que = collections.deque([1,2,3,4],5) print(que.pop()) >>> 4 返回值：obj #删除原队列最右边的元素，同时返回删除的对象。 -
popleft(删除最左边的元素)
格式：collections.deque(obj[,maxlen]).popleft() 例如：que = collections.deque([1,2,3,4],5) print(que.popleft()) >>> 1 返回值：obj #删除原队列最左边的元素，同时返回删除的对象。 -
remove(删除指定元素)
格式：collections.deque(obj[,maxlen]).remove(value) 例如：que = collections.deque([1,2,3,4],5) print(que.remove(4)) >>> None 返回值：None #直接删除原队列中指定的元素。 -
reverse(反转)
格式：collections.deque(obj[,maxlen]).reverse() 例如：que = collections.deque([1,2,3,4],5) print(que.reverse()) >>> None 返回值：None print(que) >>> deque([4, 3, 2, 1], maxlen=5) #直接对原队列进行反转排序。 -
rotate(元素位置移动)
格式：collections.deque(obj[,maxlen]).rotate(number) 例如：que = collections.deque([1,2,3,4],5) print(que.rotate(2)) >>> None 返回值：None print(que) >>> deque([3, 4, 1, 2], maxlen=5) #把元素从左边移动到右边，默认一次只移动一步，属于整体移动，所以最右边的将移动到最左边。 -
maxlen(最大长度)
格式：collections.deque(obj[,maxlen]).maxlen 例如：que = collections.deque([1,2,3,4],5) print(que.maxlen) >>> 5 返回值：int #当不限定最大长度时，该返回值为None。注：该方法为队列的变量，并不是函数，因此不能被调用。