python 队列

cliffordl

已于 2024-02-23 17:41:36 修改

阅读量1k

点赞数 21

分类专栏： python 文章标签： python 网络 java

于 2024-02-20 11:12:53 首次发布

本文链接：https://blog.csdn.net/cliffordl/article/details/136184153

版权

python 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1. Queue

在 Python 中 Queue 模块提供了一个同步的线程安全的队列类，它包括常见的 FIFO（先入先出）、LIFO（后入先出）、PriorityQueue（按优先级队列）以及先入先出类型的简单队列（SimpleQueue）。

1.1. 常用方法

1.1.1. 初始化操作

import queue
# 先进先出
q = queue.Queue(maxsize=5)
# 后进先出
q = queue.LifoQueue(maxsize=5)
# 优先级队列
q = queue.PriorityQueue(maxsize=5)
# 先进先出类型的简单队列，没有大小限制
q = queue.SimpleQueue()

参数 maxsize 是一个整数，表示队列的最大长度，在实际操作中，当队列达到上限时，插入数据会被阻塞，直到有数据出队之后，才可被插入。
该参数默认为 0，即表示队列长度不限制，如果设置为负数，队列长度也无限（一般无人设置为负数）。

1.1.2. 队列新增数据

即将一个值放入队列中，格式如下：

Queue.put(item, [block[, timeout]])

item 必填参数，即插入的值；block 默认为 True。
如果当 block 为 True 时且 timeout 是 None (默认)，put() 方法就使调用线程阻塞在这里，直到空出一个数据单元。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间没有可用的空闲插槽，将引发 Full 异常。
如果 block 是 False，如果空闲插槽立即可用，则把 item 放入队列，否则引发 Full 异常 ( 在这种情况下，timeout 将被忽略)。

     raise Full
queue.Full

1.1.3. 取队列值

格式如下：

Queue.get(block=True, timeout=None)

该函数表示从队列头部获取一个值，并在队列中删除该值，如果可选参数 block 是 True 并且 timeout 是 None (默认值)，则在必要时阻塞至项目可得到。
如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间内项目不能得到，将引发 Empty 异常。反之 (block 是 False) , 如果一个项目立即可得到，则返回一个项目，否则引发 Empty 异常 (这种情况下，timeout 将被忽略)。

1.1.4. 操作总结

Queue.qsize() 返回队列的大小
Queue.empty() 如果队列为空，返回True,反之False
Queue.full() 如果队列满了，返回True,反之False，Queue.full 与 maxsize 大小对应
Queue.get([block[, timeout]])获取队列，timeout等待时间
Queue.get_nowait() 相当于Queue.get(False)，非阻塞方法
Queue.put(item) 写入队列，timeout等待时间
Queue.put_nowait(item)：等价于 q.put(item, False)；
Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号。每个get()调用得到一个任务，接下来task_done()调用告诉队列该任务已经处理完毕。
Queue.join() 实际上意味着等到队列为空，再执行别的操作

1.2. LILO

先进先出，只能在尾部插入元素，只能从头部取出元素。

from queue import Queue
q = Queue()    # 创建队列对象
q.put(1)       # 队列尾部插入元素
q.put(2)
q.put(3)
print(q.queue) # 查看队列中的所有元素
a = q.get()    # 返回并删除队列头部元素
print(a)
print(q.queue) # 运行结果deque([2,3])

1.3. LIFO

先进后出，类似栈；

from queue import LifoQueue
lifoQueue = LifoQueue()  # 创建对象
lifoQueue.put(1)
lifoQueue.put(2)
lifoQueue.put(3)
print(lifoQueue.queue)
lifoQueue.get()          # 返回并删除队列尾部元素
print(lifoQueue.queue)   # 运行结果[1,2]

1.4. 优先队列

队列元素为元组类型，即(优先级，数据)。

from queue import PriorityQueue as pq
pq = pq()        # 创建有限队列
pq.put(1)
pq.put(4)
pq.put(3)  
print(pq.queue)  # 运行结果[1,3,4]
pq.get()         # 返回并删除优先级最低的元素
print(pq.queue)  # 运行结果[3,4]

参考：
https://zhuanlan.zhihu.com/p/445507165?utm_id=0

2. 双端队列

两端都能编辑，deque既可以用来实现栈（stack）也可以用来实现队列（queue）。
deque

2.1. 基本操作

2.1.1. 入队操作

q.append(4)：右端入队一个元素
q.appendleft(5)：左端入队一个元素
q.extend([a,b,x])：右端入队多个元素，相当于多次q.append
q.extendleft([x,y,z])：左端入队多个元素，相当于多次q.appendleft

2.1.2. 出队操作

q.pop()：右端出队
q.popleft()：左端出队

2.1.3. 清空队列

q.clear()：清空队列

2.1.4. 队列容量

q.maxlen：队列的最大容量。

如果初始化队列时未指定队列最大容量，那么它是None。

2.1.5. 队列长度

len(q)：用函数len测量双端队列q的长度

2.1.6. 队列是否满

q.maxlen == q.popleft()：当前长度等于最大长度，双端队列满

2.1.7. 队列是否空

not q：True表示队列为空，否则非空。

2.1.8. 元素个数计算

用于统计相同元素的个数

q=deque([1,2,2,3,4,5,6])
print(q.count(2))#2

2.1.9. 删除指定元素

只删除首个元素

q=deque([1,2,2,3,4,5,6])
print(q.remove(2))
print(q)	#deque([1,2,3,4,5,6)]

2.1.10 翻转顺序 reverse

q=deque([1,2,3,4,5,6])
print(q.reverse())	#deque([6,5,4,3,2,1)]

2.1.11. 轮转 rotate

q=deque([1,2,3,4,5,6])
print(q.rotate(1))#deque([6,1,2,3,4,5)]

q=deque([1,2,3,4,5,6])
print(q.rotate(2))#deque([5,6,1,2,3,4)]

q=deque([1,2,3,4,5,6])
print(q.rotate(-1))#deque([2,3,4,5,6,1)]

q=deque([1,2,3,4,5,6])
print(q.rotate(-2))#deque([3,4,5,6,1,2)]

2.2. 特点总结

存储任何数据类型的元素
是可变数据类型
支持带 in 操作符的成员操作
支持索引，比如deque[i]
支持对序列和可迭代对象进行操作的内置函数，比如len()，sorted()，reversed()等
支持正常迭代和反向迭代
支持使用 pickle
支持 maxlen，指定 deque 的最大长度

不支持切片，比如deque[0:2]
不支持 inplace 排序

insert(i, value)	# 在索引为i的 deque 容器中插入一个名为 value 的元素
remove(value)		# 删除第一个出现的 value，如果 value 不存在则引发 ValueError
deque[i]			# 从 deque 容器中检索出索引为 i 的项。
del deque[i]		# 从 deque 容器中移出索引为i的项

2.3. 实例1

from collections import deque   # 双端队列
dequeQueue = deque(['Eric','John','Smith'])
print(dequeQueue)
# deque(['Eric', 'John', 'Smith'])

dequeQueue.append('Tom')        # 在右侧插入新元素
dequeQueue.appendleft('Terry')  # 在左侧插入新元素
print(dequeQueue)
# deque(['Terry', 'Eric', 'John', 'Smith', 'Tom'])

dequeQueue.rotate(2)            #循环右移2次
print(dequeQueue)
# deque(['Smith', 'Tom', 'Terry', 'Eric', 'John'])

dequeQueue.popleft()            # 返回并删除队列最左端元素'Smith'
print(dequeQueue)
# deque(['Tom', 'Terry', 'Eric', 'John'])

dequeQueue.pop()                # 返回并删除队列最右端元素'John'
print(dequeQueue)
# deque(['Tom', 'Terry', 'Eric'])

参考：
https://www.php.cn/faq/514200.html

cliffordl

关注

21
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
python 队列

Queue.qsize() 返回队列的大小Queue.empty() 如果队列为空，返回True,反之FalseQueue.full() 如果队列满了，返回True,反之False，Queue.full 与 maxsize 大小对应Queue.get([block[, timeout]])获取队列，timeout等待时间Queue.get_nowait() 相当于Queue.get(False)，非阻塞方法Queue.put(item) 写入队列，timeout等待时间。
复制链接

扫一扫