Python 队列Queue和PriorityQueue
Python的Queue模块
适用于多线程编程的FIFO实现。它可用于在生产者(producer)和消费者(consumer)之间线程安全(thread-safe)地传递消息或其它数据，因此多个线程可以共用同一个Queue实例。
- FIFO: First in, First out.先进先出
- LIFO: Last in, First out.后进先出
优先级队列PriorityQueue的特点
- 给定一个优先级（Priority）
- 每次pop操作都会返回一个拥有最高优先级的项
from queue import Queue#先进先出队列
from queue import PriorityQueue#优先级队列
import time
#队列：先进先出
q = Queue()#创建一个空队列，队列大小没有指定
#判断队列是是否为空
#当一个队列为空的时候如果再用get取则会堵塞，所以取队列的时候一般是用到
#get_nowait()方法，这种方法在向一个空队列取值的时候会抛一个Empty异常
#所以更常用的方法是先判断一个队列是否为空，如果不为空则取值
print(q.empty())
#队列的操作：存--put() 取--get()
q.put('page1')
q.put('page2')
q.put('page3')
print(q.empty())
#判断队列是否已经满了
print(q.full())
q1 = Queue(3)#在创建队列时，指定队列大小（表示该队列最多能存多少个元素）
q1.put('1')
q1.put('1')
q1.put('1')
print(q1.full())
q2 = Queue(3)
q2.put('1')
q2.put('2')
q2.put('3')
value = q2.get()#遵循的原则是：先进先出
print(value)
print(q2.full())
#存数据---阻塞
q3 = Queue(3)
q3.put(1)
q3.put(2)
q3.put(3)
# q3.put(4)#如果队列已经满了，等着（阻塞），一直等到队列腾出空间，然后把值存入到队列当中。
#取数据--阻塞
q4 = Queue(3)
q4.put(1)
value = q4.get()#1,此时队列为空
print('q4:',value)
# value = q4.get()#阻塞，直到队列当中有新值的时候，取出，结束阻塞。
#非阻塞
q5 = Queue(3)
q5.put(1)
#1.取
print('q5.qsize:',q5.qsize())#当前队列当中的元素个数
#方法1：
# while not q5.empty():
# value2 = q5.get(block=False)#block为Ture，表示阻塞，否则为非阻塞。非阻塞就是“强取”
# print('q5：',value2)
#方法2：
while q5.qsize()>0:
value2 = q5.get(block=False)
print('q5：',value2)
print('q5.qsize:',q5.qsize())
#存
q6 = Queue(3)
#方法1：
# print(q6.maxsize)#得到队列最大容量
# i = 0
# while i<q6.maxsize:
# q6.put(i)
# i+=1
#方法2：
while not q6.full():
q6.put(1,block=False)#非阻塞
'''------------------------------其它的属性和方法-----------------------------'''
q7 = Queue(3)
# q7.get(block=False)
print(time.time())
try:
q7.get(timeout=2)#阻塞时长
except:
pass
print(time.time())
q8 = Queue(3)
# q8.get_nowait()#强取
'''------------------------------优先级队列-----------------------------'''
q = PriorityQueue()
# 格式：q.put((数字,值))
#特点：数字越小，优先级越高
q.put((1,'lori'))
q.put((-1,'Jseon'))
q.put((10,'King'))
i = 0
while i<q.qsize():
print(q.get())python 实现一个优先级队列
import heapq
class PriorityQueue(object):
def __init__(self):
self._queue = [] #创建一个空列表用于存放队列
self._index = 0 #指针用于记录push的次序
def push(self, item, priority):
"""队列由（priority, index, item)形式的元祖构成"""
heapq.heappush(self._queue, (-priority, self._index, item))
self._index += 1
def pop(self):
return heapq.heappop(self._queue)[-1] #返回拥有最高优先级的项
class Item(object):
def __init__(self, name):
self.name = name
def __repr__(self):
return 'Item: {!r}'.format(self.name)
if __name__ == '__main__':
q = PriorityQueue()
q.push(Item('foo'), 5)
q.push(Item('bar'), 1)
q.push(Item('spam'), 3)
q.push(Item('grok'), 1)
for i in range(4):
print(q._queue)
print(q.pop())对队列进行4次pop()操作，打印结果如下：
[(-5, 0, Item: 'foo'), (-1, 1, Item: 'bar'), (-3, 2, Item: 'spam'), (-1, 3, Item: 'grok')]
Item: 'foo'
[(-3, 2, Item: 'spam'), (-1, 1, Item: 'bar'), (-1, 3, Item: 'grok')]
Item: 'spam'
[(-1, 1, Item: 'bar'), (-1, 3, Item: 'grok')]
Item: 'bar'
[(-1, 3, Item: 'grok')]
Item: 'grok'
可以观察出pop()是如何返回一个拥有最高优先级的项。对于拥有相同优先级的项（bar和grok），会按照被插入队列的顺序来返回。
代码的核心是利用heapq模块，之前已经说过，heapq.heappop()会返回最小值项，因此需要把 priority 的值变为负，才能让队列将每一项按从最高到最低优先级的顺序级来排序。
python 优先队列PriorityQueue
普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在优先队列中，元素被赋予优先级。
当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出的行为特征。通常采用堆数据结构来实现。
我们可以利用优先队列中元素被赋予优先级的这个特点来保存到当前状态下的若干个最大的元素值，这样优先级越高那么元素就可以先被处理，PriorityQueue属于queue模块中的一个类，其中经常使用到的有三个方法：声明一个优先队列、往优先队列中加入元素、往优先队列中移除元素
- ① 声明一个优先队列：queue.PriorityQueue()
- ② 往队列中加入元素：queue.put(self, item, block=True, timeout=None)
- ③ 往队列中删除元素：queue.get(self, block=True, timeout=None)
在往队列中加入元素的时候第一个元素值表示的是元素的优先级，并且值越小那么优先级越高，所以队首元素的优先级是最高的，而且经常加入队列的元素类型为元组这样就可以在队列中保存多个值，
下面是具体的例子
import queue
if __name__ == '__main__':
queue = queue.PriorityQueue()
queue.put((100, 100))
queue.put((-12, -7))
queue.put((7, 8))
while not queue.empty():
print(queue.get())输出结果：
以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程网。
