学完数据结构，队列到底有什么用？

class Queue(object):
    def __init__(self):
        self.items = []

    def __len__(self):
        return len(self.items)

    def is_empty(self):
        return len(self.items) == 0

    def add(self, value):
        # 数据插入队列
        return self.items.append(value)

    # 出队
    def delete(self):
        if self.is_empty():
            raise Exception("队列为空")
        # pop是删除数据，默认删除最后一个
        return self.items.pop(0)

    # 输出队列数据
    def show_queue(self):
        print(self.items)
     
#或者通过继承列表改写
class Queue2(list):
    #改写列表规则
    def pop(self):
        if len(self) == 0:
            raise Exception("队列为空")
        #继承后覆盖pop()方法
        super(Queue2,self).pop(0)


q=Queue()
print("初始化队列",q.items)
print("队列是否为空","是" if q.is_empty() else "否")

for i in range(1,5):
    q.add(i)

q.show_queue()
print("队列是否为空","是" if q.is_empty() else "否")

q.delete()
q.show_queue()

q.add(5)
q.show_queue()
q.delete()
q.delete()
q.delete()
q.show_queue()

初始化队列 []
队列是否为空 是
[1, 2, 3, 4]
队列是否为空 否
[2, 3, 4]
[2, 3, 4, 5]
[5]

import queue
q = queue.Queue()

#方法介绍
# q.qsize()  # 返回当前队列长度
# q.empty()  # 判断队列是否为空，如果队列为空返回True 反之False
# q.full()  # 判断队列是否达到最大长度限制，如果队列满了，返回True 反之False
# q.get()  # 获取队列头部元素，get(self, block=True,timeout=None) block表示是否等待 timeout表示等待多久
# q.put(item)  # 写入队列，尾部添加元素， put(self, item, block=True,timeout=None) block表示是否等待 timeout表示等待多久
# q.get_nowait()  # 相当于q.get(False) 获取不等待
# q.put_nowait()  # 相当于 q.put(item,False) 写入不等待，满了会报错
# q.task_done()  # 在完成一项工作之后，使用这个方法可以向队列发送一个信号，表示该任务执行完毕
# q.join()  # 等待队列中所有任务（数据）执行完毕之后再往下执行，否则一直等待

# 初始化队列：创建一个空队列
import queue
q1 = queue.Queue(maxsize=2)   #参数 maxsize 是一个整数，表示队列的最大长度;该参数默认为 0，即表示队列长度不限制，如果设置为负数，队列长度也无限（一般无人设置为负数）。
print(type(q1))

# 入队：把数据添加到对位
# queue.Queue.put(item, [block[, timeout]])
# 其中item必填参数，即插入的值，block 默认为True；如果当block为True时且timeout是None(默认)，put()方法就使调用线程阻塞在这里，直到空出一个数据单元。

q1.put(10,block=True)  # 等待插入
q1.put(20,block=True)
q1.put(30,block=True)

print(q1)

# 如果 timeout 是个正数，将最多阻塞 timeout秒，如果在这段时间没有可用的空闲插槽，将引发 Full 异常。

q1.put(10,block=True)  # 等待插入
q1.put(20,block=True)
q1.put(30,block=True,timeout=3)

print(q1)

q1.put(30,block=False) # 如果block是False，满了之后就报错,如果空闲立即可用，则把item放入队列，否则引发 Full异常 (在这种情况下，timeout 将被忽略)。
q1.put_nowait(30)  # 不等待插入 满了之后报错


# 出队：从队首取数据
# Queue.get(block=True, timeout=None)
# 该函数表示从队列头部获取一个值，并在队列中删除该值，如果可选参数block是True并且timeout是None(默认值)，则在必要时阻塞至可得到。

print(q1.get(block=True,timeout=None))  # 先入先出
print(q1.get(block=True,timeout=None))
print(q1.get(block=True,timeout=10))    # 如果timeout是个正数，将最多阻塞timeout秒,如果在这段时间内项目不能得到，将引发 Empty 异常。


print(q1.get(block=False))  # 不等待获取 队列为空报错
print(q1.get_nowait()) # 不等待获取 队列为空报错

print(q1.qsize())  # 获取队列中的任务数/消息数
print(q1.full())  # 判断队列是否已满
print(q1.empty())  # 判断队列是否为空

注：使用常见问题
 1、阻塞模式
当队列q被（其他线程）写满后，这段代码就会阻塞，直至其他线程取走数据。
Queue.put（）方法加上 block=False 的参数，即可解决这个隐蔽的问题。
但要注意，非阻塞方式写队列，当队列满时会抛出 exception Queue.Full的异常。
Queue.get()默认的也是阻塞方式读取数据；队列为空时，不会抛出except Queue.Empty，而是进入阻塞直至超时，因此得加上block=False的参数。




2）、用 collections.deque 来实现队列操作。
两端都能编辑，deque既可以用来实现栈也可以用来实现队列。
前面使用 list 实现队列的例子中，插入数据的部分是通过 insert() 方法实现的，这种方法效率并不高，因为每次从列表的开头插入一个数据，列表中所有元素都得向后移动一个位置。
from collections import deque

my_queue = deque(maxlen=8)

for i in range(8):
    my_queue.append(i+1) # 在右侧插入新元素
    # my_queue.appendleft(i+1)  # 在左侧插入新元素

print(my_queue)


my_queue.rotate(2) #循环右移2次
print('循环右移2次后的队列',my_queue)

my_queue.popleft()    #返回并删除队列最左端元素
print('删除最左端元素后的队列：',my_queue)

my_queue.pop()    #返回并删除队列最右端元素
print('删除最右端元素后的队列：',my_queue)

# 现在我们来看一下如果继续向里面添加数字会发生什么。
for i in range(8, 12):
    my_queue.append(i+1)

print(my_queue)


deque([1, 2, 3, 4, 5, 6, 7, 8], maxlen=8)
循环右移2次后的队列 deque([7, 8, 1, 2, 3, 4, 5, 6], maxlen=8)
删除最左端元素后的队列：deque([8, 1, 2, 3, 4, 5, 6], maxlen=8)
删除最右端元素后的队列：deque([8, 1, 2, 3, 4, 5], maxlen=8)
deque([2, 3, 4, 5, 9, 10, 11, 12], maxlen=8)

collections 库中的 deque 对该功能进行了优化。这个方法的一个关键特性是保持队列长度一直不变，也就是说，如果你将 queue 的最大大小设置为 8，那么 deque 将根据 FIFO 原则添加和删除元素，以保持 queue 的最大大小为 8。是不是有点固定窗口大小的的意思，这点非常有用。

from collections import deque
M=400 #平均值
C=20 #标准差（正常数据）
sw_width =7 #滑动窗口的窗口宽度
# input_data=[randint(M-2*C,M+5*C) for i in range(200)]

input_data = [100, 202,305, 437, 585, 598,601,701, 520, 981, 991, 1000, 1000, 1000, 1280, 1331, 725]
print("生成数据",input_data)


q = deque(maxlen=7)

# 单调递增序列
def is_monotonic(lst):
    if any(lst[i+1] <= lst[i] for i in range(0,len(lst)-1)):
        return False
    else:
        return True


for data in input_data:
    q.append(data)
    #队列长度是否达到要求
    if len(q) == sw_width:

        result=abs(sum(q)/sw_width-M)
        print(q)

        # 非单调递增
        if is_monotonic(q) == False:
            print("---------",is_monotonic(q))
            print("机器出错", "错误数据为：", q)
            #极值数据，平均值超过标准差3倍(跳表情况)
            if result > 3*C and max(q)!=q[-1]:
                print("异常值---------", q[-1])
                print("平均值为：",result)

            #数据恒定不变（掉线情况，更新失败）
            elif len(set(q))<len(q):
                from collections import Counter
                b = dict(Counter(q))
                print("存在重复数据",{key:value for key,value in b.items()if value > 1})

        else:
            print("数据合格")