D3_collections系列

位于collectons模块中，需导入模块。

#!/usr/bin/env python3
import collections

一、计数器（Counter）：对字典类型的补充，用于追踪值出现的次数，具备字典的所有功能。可以传入字符串、列表、元组。
类的定义：

class Counter(dict)
'''Counter类继承dict类，具备父类的所有功能'''

常用内部方法：

'''most_common(self,n=None):获取前n个元素及出现的次数'''
list_1 = ['a','b','c','a','a','c']
counter_1 = collections.Counter(list_1)
result_1 = counter_1.most_common()
print(result_1)
'''console:
[('a', 3), ('c', 2), ('b', 1)]
'''

'''elements(self):循环获取计数器中所有元素，返回所有的key，即获得原生数据'''
list_2 = ['a','b','c','a','a','c']
counter_2 = collections.Counter(list_2)
for i in counter_2.elements():
    print(i,end=',')
'''console:
b,c,c,a,a,a,
'''

'''items(self):循环返回所有元素及出现的次数，即获得处理完的数据'''
list_3 = ['a','b','c','a','a','c']
counter_3 = collections.Counter(list_3)
for k,v in counter_3.items():
    print(k,v)
'''console:
b 1
c 2
a 3
'''

'''update(*args,**kwds):更新计数器，传入一个序列，若没有则新建，若已存在则计数器增加'''
list_4 = ['a','b','c','a','a','c']
counter_4 = collections.Counter(list_4)
new_list = ['a','e']
counter_4.update(new_list)
print(counter_4)
'''console:
Counter({'a': 4, 'c': 2, 'e': 1, 'b': 1})
'''

'''subtract(*args,**kwds):删除传入序列中存在于原序列的值，若计数器已经为0则继续向下递减'''
list_5 = ['a','b','c','a','a','c']
counter_5 = collections.Counter(list_5)
del_list = ['a','b','f']
counter_5.subtract(del_list)
print(counter_5)
'''console:
Counter({'c': 2, 'a': 2, 'b': 0, 'f': -1})
'''

二、有序字典（OrderedDict）：对字典类型的补充，记录了字典元素添加的顺序。
普通方法构造有序字典，可声明用于记录顺序的列表：

dict_1 = {'k1':'v1','k2':'v2','k3':'v3'}
order_list = ['k1','k2','k3']
for i in order_list:
    print(dict_1[i],end=',')
'''console:
v1,v2,v3,
'''

可使用collections模块中OrderDict()声明有序字典，定义如下：

class OrderedDict(dict)
'''OrderedDict类继承dict类，具备父类的所有功能'''

声明一个有序字典并移入键值对：

ordered_dict_2 = collections.OrderedDict()
ordered_dict_2['k1'] = 'v1'
ordered_dict_2['k2'] = 'v2'
ordered_dict_2['k3'] = 'v3'
print(ordered_dict_2)
'''console:
OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
'''

常用内部方法：

'''move_to_end(self,key,last=True):将一组键值对移动到最后
ordered_dict_2 = OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])'''
ordered_dict_2.move_to_end('k1')
print(ordered_dict_2)
'''console:
OrderedDict([('k2', 'v2'), ('k3', 'v3'), ('k1', 'v1')])
'''

'''popitem(self,last=True):从最后一组开始移除一组键值对，类似栈（后进先出）
ordered_dict_2 = OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])'''
ordered_dict_2.popitem()
print(ordered_dict_2)
'''console:
OrderedDict([('k1', 'v1'), ('k2', 'v2')])
'''

三、默认字典（defaultdict）：定义字典值的默认类型。
使用collections模块的defaultdict类型，定义如下：

class defaultdict(dict)
'''defaultdict类继承dict类，具备父类的所有功能'''
'''默认传入类型为list'''

可用于实现比较分组功能：

list_1 = [1,2,3,4,5,6,7,8,9]
default_dict = collections.defaultdict(list)
for i in list_1:
    if i > 6:
        default_dict['>6'].append(i)
    else:
        default_dict['<6'].append(i)
print(default_dict)
'''console:
defaultdict(<class 'list'>, {'<6': [1, 2, 3, 4, 5, 6], '>6': [7, 8, 9]})
'''

四、可命名元组（namedtuple）：为每个元素命名，可通过名字访问元组中的元素。python中未提供可命名元组类，需要先创建类，再创建对象。

NamedtupleClass = collections.namedtuple('NamedtupleClass',['x','y','z'])
named_tuple_1 = NamedtupleClass(1,2,3)
print(named_tuple_1.x,named_tuple_1.y,named_tuple_1.z)
'''console:
1 2 3
'''

五、队列：提供内存级的队列支持
（1）双向队列（deque）：在collections模块中定义

class deque(object)

声明及常用内部方法：

deque_1 = collections.deque()

'''append(self,*args,**kwargs):向队列右侧添加元素'''
deque_list = [1,2,3,4,1,3]
deque_1 = collections.deque()
for i in deque_list:
    deque_1.append(i)
print(deque_1)
'''console:
deque([1, 2, 3, 4, 1, 3])
'''

'''appendleft(self,*args,**kwargs):向队列左侧添加元素。用法同append方法'''

'''count(self,value):计算某元素的个数
deque_1 = deque([1, 2, 3, 4, 1, 3])'''
result_1 = deque_1.count(3)
print(result_1)
'''console:
2
'''

'''extend(self,*args,**kwargs):将参数中序列添加进原队列右侧
deque_1 = deque([1, 2, 3, 4, 1, 3])'''
new_list = [5,6,7]
deque_1.extend(new_list)
print(deque_1)
'''console:
deque([1, 2, 3, 4, 1, 3, 5, 6, 7])
'''

'''extendleft(self,*args,**kwargs):将参数中序列添加进原队列左侧，用法同extend方法'''

'''index(self,value,start=None,stop=None):获取参数值的索引位置，可指定start、stop位置。只能获取第一个值的索引
deque_1 = deque([1, 2, 3, 4, 1, 3])'''
result_2 = deque_1.index(3)
print(result_2)
'''console:
2
'''

'''insert(self,index,p_object):向队列中插入元素
deque_1 = deque([1, 2, 3, 4, 1, 3])'''
deque_1.insert(2,10)
print(deque_1)
'''console:
deque([1, 2, 10, 3, 4, 1, 3])
'''

'''pop(self,*args,**kwargs):移除队列右侧的元素并返回移除的值
deque_1 = deque([1, 2, 3, 4, 1, 3])'''
result_3 = deque_1.pop()
print(deque_1)
print(result_3)
'''console:
deque([1, 2, 3, 4, 1])
3
'''

'''popleft(self,*args,**kwargs):移除队列左侧的元素并返回移除的值，用法与pop方法相同'''

'''reverse(self):反转队列中的元素排列
deque_1 = deque([1, 2, 3, 4, 1, 3])'''
deque_1.reverse()
print(deque_1)
'''console:
deque([3, 1, 4, 3, 2, 1])
'''

'''rotate(self,*args,**kwargs):将队列右侧指定数量的元素移到队列左侧
deque_1 = deque([1, 2, 3, 4, 1, 3])'''
deque_1.rotate(3)
print(deque_1)
'''console:
deque([4, 1, 3, 1, 2, 3])
'''

（2）单向队列（Queue）：在queue模块中定义

class Queue

使用前需要先导入模块

import queue

声明及常用内部方法：

queue_1 = queue.Queue()

'''put(self,item,block=True,timeout=None):向队列中插入元素'''
queue_list = [1,2,3,2,4]
queue_1 = queue.Queue()
for i in queue_list:
    queue_1.put(i)

'''get(self,block=True,timeout=None):从队列头删除并返回删除的元素'''
queue_1.get()

'''qsize(self):获得队列中元素个数'''
result_1 = queue_1.qsize()
print(result_1)
'''console:
5
'''

'''empty(self):清空队列'''
queue_1.empyt()