八、collection系列-----计数器、有序字典、默认字典、可命名元组、双向队列、单向队列一.计数器（对字典的扩展）

一.计数器（对字典的扩展）

有如下一个字典：

dic = {'k1':123,'k2':123,'k3':12}

统计12出现的次数，123出现的次数

 

1.统计出现次数

>>> import collections
>>> c = collections.Counter("rewqfsdvcxzfgafrwqerwgfdjg;ldskj")
>>> c
Counter({'f': 4, 'r': 3, 'g': 3, 'w': 3, 'd': 3, 'q': 2, 'e': 2, 's': 2, 'j': 2, 'z': 1, 'k': 1, 'x': 1, ';': 1, 'c': 1, 'a': 1, 'l': 1, 'v': 1}) ======》它告诉了你f出现了4次，r出现了3次。。。。。。。

2.返回前几名

>>> c.most_common(1)
[('f', 4)]
>>> c.most_common(2)
[('f', 4), ('r', 3)]
>>> c.most_common(3)
[('f', 4), ('r', 3), ('g', 3)]
>>> c.most_common(4)
[('f', 4), ('r', 3), ('g', 3), ('w', 3)]
>>> c.most_common(5)
[('f', 4), ('r', 3), ('g', 3), ('w', 3), ('d', 3)]
>>> c.most_common(6)
[('f', 4), ('r', 3), ('g', 3), ('w', 3), ('d', 3), ('q', 2)]

3.相加

>>> c1 = collections.Counter('aabc')
>>> c2 = collections.Counter('aac')
>>> c1
Counter({'a': 2, 'c': 1, 'b': 1})
>>> c2
Counter({'a': 2, 'c': 1})
>>> c1.update(c2)
>>> c1
Counter({'a': 4, 'c': 2, 'b': 1})

4.相减

>>> c1
Counter({'a': 4, 'c': 2, 'b': 1})
>>> c2
Counter({'a': 2, 'c': 1})
>>> c1.subtract(c2)
>>> c1
Counter({'a': 2, 'c': 1, 'b': 1})

5.迭代器 =====> element

>>> c1
Counter({'a': 4, 'c': 2, 'b': 1})
>>> for item in c1.elements():print (item)
 
c
c
a
a
a
a
b

二.有序字典======>和dict字典是一模一样的，只是它排序了

o1 = collections.OrderedDict()
o1['k1'] = 1
o1['k2'] = 2
o1['k3'] = 3
>>> o1
OrderedDict([('k1', 1), ('k2', 2), ('k3', 3)])

三.默认字典========>普通字典的默认value值是None，通过defaultdict修改其默认值为列表；即为你字典里的value设置一个默认类型

collections.defaultdict

传统方式:需要做判断，判断里面的值是否是列表，因为它默认value是None，不能用append方法

dic = {}
if 'k1' in dic.keys():
dic['k1'].append(1)
else:
dic['k1'] = [1,]

默认字典方式：=========>相当于给你设定了一个默认值，默认值就是一个空列表

>>> dic = collections.defaultdict(list)
>>> dic
defaultdict(<class 'list'>, {})
>>> dic['k1'].append(1)
>>> dic
defaultdict(<class 'list'>, {'k1': [1]})

四.可命名元组(对元组的扩展)

例:

(1,4)
1,4是我们的位置上的某个点，分别代表x轴和y轴，但是，这样的表述方法只有我们知道，别人不知道，所以需要给元组命名为x=1,y=4,z=5........可命名元组的使用步骤为：
 
1.创建类
Mytuple = collections.namedtuple('Mytuple',['x','y']) 这个命令用于创建一个扩展tuple的类，类名叫Mytuple
 
2.使用类创建对象
我们在创建元组的时候是这样的：
t1 = (1,2)<====================>t1 = tuple(1,2) 你执行前面一个实际上Python的内部机制还是回去调后面这种方式，现在我们自己定义了一个元组扩展的类，可以看看
 
>>>t2 = Mytuple(1,2) 发现它返回了一个（x=1，y=2）的元组
>>>t2
Mytuple(x=1, y=2)
 
3.使用对象
 
>>> t2.x 现在我们就可以使用t2.x和t2.y分别取访问这两个元素了
1
>>> t2.y
2
 
我们自己创建的类也是有方法的，通过
dir(Mytuple)或者help(Mytuple)可以查看到
 
>>> help(Mytuple)
Help on class Mytuple in module __main__:
class Mytuple(builtins.tuple) =====>这句话表示Mytuple是通过tuple扩展的类，即tuple是Mytuple的父类，这个 也叫作继承，子类继承父类，表示它可以继承它的父类里的所有东西供自己使用
Mytuple(x, y)
 
 
>>> dir(Mytuple)
['__add__', '__class__', '__contains__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__module__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__slots__', '__str__', '__subclasshook__', '_asdict', '_fields', '_make', '_replace', '_source', 'count', 'index', 'x', 'y']
 

五.双向队列

特性1.两头都可以插，两头都可以取

特性2.线程安全，即多个线程来拿的时候我就会给你加个锁，谁先拿了其他人就不能来碰了，这就叫线程安全。

>>> help(collections.deque)
 
>>> q = collections.deque() ======>创建了一个空的双向队列
>>> q.append(1) ======>append了几个值
>>> q.append(2)
>>> q.append(3)
>>> q.append(4)
>>> q.append(5)
>>> q
deque([1, 2, 3, 4, 5])

六.单向队列（不在collection模块里，在queue模块里，也是线程安全的）

>>> import queue
>>> dir(queue)
['Empty', 'Full', 'LifoQueue', 'PriorityQueue', 'Queue', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'deque', 'heappop', 'heappush', 'threading', 'time']
 
创建一个单向队列
>>> q = queue.Queue(10) =======>10代表这个单向队列里面最多放10条数据
>>> q
<queue.Queue object at 0x02AC2E50>
往里加数据：
>>> q.put(1)
>>> q.put(2)
>>> q.put(3)
往外拿数据：
>>> q.get()
1
>>> q.get()
2
>>> q.get()
3
>>> q.get() =====>当里面没有数据了，光标就停在那里等待，直到里面有了，我就可以拿到了