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。注：该方法为队列的变量，并不是函数，因此不能被调用。