python--队列

 

队列queue：先进先出

 

 

import threading

import queue  #队列模块

import time

def func(q):

    while True:

        #s=q.get()  #从队列里取值.如果q里没有值，会一直处于等待状态

        #q.get_nowait()    #从队列里取值.如果q里没有值，会抛出异常

        #z=q.qsize()   #返回队列的大小

        #b=q.empty()     #如果队列为空，返回True, 反之False

        b=q.full()     #如果队列满了，返回True, 反之False

        print(b)

        #q.task_done()   #发出信号，表示q.get()的返回数据已经被处理

        time.sleep(2)

q=queue.Queue(2)  #创建队列对象.参数：表示队列的最多数据个数

t=threading.Thread(target=func,args=(q,)).start()

for i in range(5):

    x=input('请输入数据:')

    q.put(x)        #往队列里放入数据；队列满，就等待

    #q.put_nowait(x)  #往队列里放入数据,存放前队列为空，就抛出异常

    time.sleep(1)

q.join()   #等待队列q中的数据全部执行完毕，再继续【所有的数据都q.task_done()之后】

 

 

 

LifoQueue队列：后进先出

import threading

import queue  #队列模块

import time

def func(q):

    while True:

        time.sleep(1)

        #s=q.get()  #从队列里取值.如果q里没有值，会一直处于等待状态

        #s=q.get_nowait()    #从队列里取值.如果q里没有值，会抛出异常

        z=q.qsize()   #返回队列的大小

        #b=q.empty()     #如果队列为空，返回True, 反之False

        #b=q.full()     #如果队列满了，返回True, 反之False

        print(z)

        #q.task_done()   #发出信号，表示q.get()的返回数据已经被处理

 

q=queue.LifoQueue()  #创建队列对象.参数：表示队列的最多数据个数

t=threading.Thread(target=func,args=(q,)).start()

for i in range(5):

    q.put(i)        #往队列里放入数据；队列满，就等待

    #q.put_nowait(x)  #往队列里放入数据,存放前队列为空，就抛出异常

#q.join()   #等待队列q中的数据全部执行完毕，再继续【所有的数据都q.task_done()之后】

 

 

deque（双向队列）

需要  from collections import deque

双向队列：既可以在前面放数据，也可以在后面放数据；既可以在前面取数据，也可以在后面取数据

d =deque()  #创建双向队列

d =deque([1,2])  创建时可以赋值

d.append(10)  #从右边放数据

d.appendleft(100)  #从左边放数据

例子

d =deque()  #创建双向队列

d.append(10)  #从右边放数据

d.append(20)

d.append(30)

d.appendleft(100)  #从左边放数据

d.appendleft(200)

d.appendleft(300)

print(d)

结果  deque([300, 200, 100, 10, 20, 30])  

 

x=d.pop() 从右边取数据

队列中没有数据就抛出异常

x=d.popleft()    从左边取数据

队列中没有数据就抛出异常

d.clear()    清空数据

e=d.copy()   把双向队列复制给e，复制后d和e的地址不相同

x=d.count(20)    返回指定元素的出现次数

没有返回0

d.extend([1000,2000])   在队列的右边放入列表的元素

按循序放入

d.extendleft([1000,2000])    在队列的左边放入列表的元素

按循序放入

x=d.index(200)   查找某个元素的索引位置

队列左边第一个数据的索引是0

参数1  元素

参数2  可选  查找的起始位置

参数3  可选  查找的结束位置

找不到 抛出异常

d.insert(2,'z')    在指定位置插入元素

参数1  位置

参数2   元素

如果指定位置大于最大序列号，就插入到最右边

d.remove(200)    删除指定元素

只删除左边找到的第一个

d.reverse()    队列反转

d.rotate(2)   把右边元素放到左边

参数  指定次数，默认1次

 

 

 

优先级队列PriorityQueue

 

import threading

import queue  #队列模块

import time

def func(q):

    while True:

        time.sleep(1)

        s=q.get()  #从队列里取值.如果q里没有值，会一直处于等待状态，先取级别高的

        #s=q.get_nowait()    #从队列里取值.如果q里没有值，会抛出异常

        #z=q.qsize()   #返回队列的大小

        #b=q.empty()     #如果队列为空，返回True, 反之False

        #b=q.full()     #如果队列满了，返回True, 反之False

        print(s)

        #q.task_done()   #发出信号，表示q.get()的返回数据已经被处理

 

q=queue.PriorityQueue()  #创建队列对象.参数：表示队列的最多数据个数

t=threading.Thread(target=func,args=(q,)).start()

q.put(10)        #往队列里放入数据；队列满，就等待;

q.put(50)

#q.put_nowait(x)  #往队列里放入数据,存放前队列为空，就抛出异常

#q.join()   #等待队列q中的数据全部执行完毕，再继续【所有的数据都q.task_done()之后】