python学习——collections模块之deque双端队列_python collection queue

一、collections模块介绍

• colletions是python内置的模块，里面有很多数据类型['deque', 'defaultdict', 'namedtuple', 'UserDict', 'UserList', 'UserString', 'Counter', 'OrderedDict', 'ChainMap']，这些数据类型让我们内置的list,dict,tuple,set操作更加方便。

二、deque(双端队列)

# 官方说明
* deque        list-like container with fast appends and pops on either end
1
2

• 在说deque的时候咱们先来看看queue
• 咱们知道，python内置有个queue队列，他只能单向的操作数据的进出，比如LIFO(后进先出)或FIFO(先进先出)
• 上代码queue.Queue先进先出，单向

import queue

# 先进先出
q = queue.Queue()
for i in range(10):
    q.put(i)

while not q.empty():
    print(q.get())
"""
打印结果 0 1 2 3 4 5 6 7 8 9
"""
1
2
3
4
5
6
7
8
9
10
11
12

• 上代码queue.LifoQueue后进先出，单向

import queue


# 先进后出
q = queue.LifoQueue()
for i in range(10):
    q.put(i)

while not q.empty():
    print(q.get())
"""
打印结果 9 8 7 6 5 4 3 2 1 0
"""
1
2
3
4
5
6
7
8
9
10
11
12
13

• 上代码queue.PriorityQueue优先级队列，也是先进先出，不过他会帮咱们进行排序

# 优先级队列
import random
import queue


q = queue.PriorityQueue()
for _ in range(10):
    num = random.randint(1,10)	# 这里是随机的
    q.put(num)

while not q.empty():
    print((q.get()))
"""
打印结果1 2 2 4 4 7 7 7 8 9
在q.put的时候，它内部会帮咱们对插入队列的值进行排序（升序）
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 可以看到，上面的三种队列都是单向插入值，然后单向取出值。
• 灵魂画家
• 假设咱们说的先进先出是从右边往左边插入值，那么取的时候就是从左边取出值，咱不能从右边取出值，所以是单向的。
  
• 假设后进先出是右边插入值，那么取的时候也是从右边取出值，可以看到，也是单向取值。
  
• 所以咱们说python内置的queue只能单向插入值和取出值
• 那么如果我有一个队列，我即想从左边插入值，我也想从右边插入值，或者我即想从左边取出值，也想从右边取出值呢？用咱们python内置的queue是做不到的，因为你在用queue的时候，你要么只能往左边插入值，要么就是往右边插入值，所以就有了deque这个双端队列。

三、生成deque对象

• 导入dequefrom colletions import deque查看源码
  
• 首先需要说明的是，deque是用c语言写的，速度很快，其次，咱们查看的源码只是用python代码的方式去描述c语言代码，让咱们更容易的理解这个数据类型。
• deque使用，咱们看__init__方法，第一个参数是可迭代对象，第二个参数是可选的，指定deque的最大长度为None，如果不写，则长度没有限制，maxlen>=0
• 再次强调，deque第一个参数接受的是一个可迭代对象，python中常见的可迭代对象：str list set dict tuple等，deque本身也是一个可迭代对象
  
• 接下来的deque代码就以截图的方式显示

1. 什么都不传的时候，打印的就是一个空的deque
   
2. 只传一个maxlen长度
   
3. 注意如果指明了maxlen，那么如果传入的可迭代对象大于maxlen的话，就会截取后面的数，这里列表长度是6，但是maxlen是3，所以最后结果是列表后面的三个数
   
4. 传入一个列表（注意，列表也是可迭代对象）
   
5. 如果传入的不是一个可迭代对象，那么就够抛出TypeError异常
   
6. 传入元组
   
7. 传入set
   
8. 传入dict，需要注意的是，如果传入的是一个字典，那么会将字典的key做为传入的值
   
9. 传入字符串
   
10. 传入咱们自己写一个可以迭代的类
    

四、 生成deque对象大概就上面的几种，接下来是查看deque有什么方法

1. append方法，从右边添加元素

    def append(self, *args, **kwargs): # real signature unknown
        """ Add an element to the right side of the deque. """
        pass
1
2
3

2. appendleft从左边添加元素

    def appendleft(self, *args, **kwargs): # real signature unknown
        """ Add an element to the left side of the deque. """
        pass
1
2
3

3. clear清空deque

    def clear(self, *args, **kwargs): # real signature unknown
        """ Remove all elements from the deque. """
        pass
1
2
3

4. copy浅拷贝

    def copy(self, *args, **kwargs): # real signature unknown
        """ Return a shallow copy of a deque. """
        pass
1
2
3

5. count统计个数，接受一个参数

    def count(self, value): # real signature unknown; restored from __doc__
        """ D.count(value) -> integer -- return number of occurrences of value """
        return 0
1
2
3

6. extend从右边合并，接受的参数也是一个可迭代对象（deque本身也是一个可迭代对象），会改变原始的值

    def extend(self, *args, **kwargs): # real signature unknown
        """ Extend the right side of the deque with elements from the iterable """
        pass
1
2
3

7. extendleft从左边合并，接受一个可迭代对象

    def extendleft(self, *args, **kwargs): # real signature unknown
        """ Extend the left side of the deque with elements from the iterable """
        pass
1
2
3

8. index找打第一个元素的索引值，找不到就抛出ValueError异常，第一个参数是要找的值，第二、三是可选参数，表示从哪里（索引值）开始找，类似切片，前取后不取

    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
        """
        D.index(value, [start, [stop]]) -> integer -- return first index of value.
        Raises ValueError if the value is not present.
        """
        return 0
1
2
3
4
5
6

9. insert在指定的索引值处插入对象

    def insert(self, index, p_object): # real signature unknown; restored from __doc__
        """ D.insert(index, object) -- insert object before index """
        pass
1
2
3

10. pop从右边取出值

    def pop(self, *args, **kwargs): # real signature unknown
        """ Remove and return the rightmost element. """
        pass
1
2
3

11. popleft从左边取出值

    def popleft(self, *args, **kwargs): # real signature unknown
        """ Remove and return the leftmost element. """
        pass
1
2
3

12. remove删除指定值

    def remove(self, value): # real signature unknown; restored from __doc__
        """ D.remove(value) -- remove first occurrence of value. """
        pass
1
2
3

13. reverse反转

    def reverse(self): # real signature unknown; restored from __doc__
        """ D.reverse() -- reverse *IN PLACE* """
        pass
1
2
3

14. rotate将最后的几个数放到前面

    def rotate(self, *args, **kwargs): # real signature unknown
        """ Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left. """
        pass
1
2
3

• 把后面三个数5，6，7放到deque的最前面去
  

五、全局完！