Python数据结构之队列

开发 后端
python内置的queue模块实现了三种类型的队列,因此没有必要重复造轮子,它们的区别仅仅是条目取回的顺序。

[[411623]]

python内置的queue模块实现了三种类型的队列,因此没有必要重复造轮子,它们的区别仅仅是条目取回的顺序。在 FIFO 队列中,先添加的任务先取回。在 LIFO 队列中,最近被添加的条目先取回(操作类似一个堆栈)。优先级队列中,条目将保持排序( 使用 heapq 模块 ) 并且最小值的条目第一个返回。

  1. class queue.Queue(maxsize=0) 

FIFO 先入先出队列构造函数。maxsize 是个整数,用于设置可以放入队列中的项目数的上限。当达到这个大小的时候,插入操作将阻塞至队列中的项目被消费掉。如果 maxsize 小于等于零,队列尺寸为无限大。

  1. maxsize is an integer that sets the upperbound limit on the number of items that can be placed in the queue.  
  2. class queue.LifoQueue(maxsize=0) 

LIFO 后入先出队列构造函数。maxsize 是个整数,用于设置可以放入队列中的项目数的上限。当达到这个大小的时候,插入操作将阻塞至队列中的项目被消费掉。如果 maxsize 小于等于零,队列尺寸为无限大。

  1. class queue.PriorityQueue(maxsize=0) 

PriorityQueue优先级队列构造函数。maxsize 是个整数,用于设置可以放入队列中的项目数的上限。当达到这个大小的时候,插入操作将阻塞至队列中的项目被消费掉。如果 maxsize 小于等于零,队列尺寸为无限大。

通用方法:

Queue.qsize() 返回队列的大致大小

Queue.empty() 如果队列为空,返回 True ,否则返回 False 。

Queue.full() 如果队列是满的返回 True ,否则返回 False 。

Queue.put(item, block=True, timeout=None) 将 item 放入队列。

如果可选参数 block 是 true 并且 timeout 是 None (默认),则在必要时阻塞至有空闲插槽可用。

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

反之 (block 是 false),如果空闲插槽立即可用,则把 item 放入队列,否则引发 Full 异常 ( 在这种情况下,timeout 将被忽略)。

Queue.put_nowait(item) 相当于 put(item, False) 。

Queue.get(block=True, timeout=None) 从队列中移除并返回一个项目。

如果可选参数 block 是 true 并且 timeout 是 None (默认值),则在必要时阻塞至项目可得到。

如果 timeout 是个正数,将最多阻塞 timeout 秒,如果在这段时间内项目不能得到,将引发 Empty 异常。

反之 (block 是 false) , 如果一个项目立即可得到,则返回一个项目,否则引发 Empty 异常 (这种情况下,timeout 将被忽略)。

Queue.get_nowait() 相当于 get(False) 。

提供了两个方法,用于支持跟踪 排队的任务 是否 被守护的消费者线程 完整的处理。

  1. Queue.task_done() 

表示前面排队的任务已经被完成。被队列的消费者线程使用。每个 get() 被用于获取一个任务, 后续调用 task_done() 告诉队列,该任务的处理已经完成。

如果 join() 当前正在阻塞,在所有条目都被处理后,将解除阻塞(意味着每个 put() 进队列的条目的 task_done() 都被收到)。

如果被调用的次数多于放入队列中的项目数量,将引发 ValueError 异常 。

  1. Queue.join() 

阻塞至队列中所有的元素都被接收和处理完毕。

当条目添加到队列的时候,未完成任务的计数就会增加。

每当消费者线程调用 task_done() 表示这个条目已经被回收,该条目所有工作已经完成,未完成计数就会减少。

当未完成计数降到零的时候, join() 阻塞被解除。

代码如下:

  1. #!/usr/bin/env python 
  2. # -*- coding: UTF-8 -*- 
  3. #                     _ooOoo_ 
  4. #                   o8888888o 
  5. #                    88" . "88 
  6. #                 ( | -  _  - | ) 
  7. #                     O\ = /O 
  8. #                 ____/`---'\____ 
  9. #                  .' \\| |// `. 
  10. #                 / \\|||:|||// \ 
  11. #               / _|||||-:- |||||- \ 
  12. #                | | \\\ - /// | | 
  13. #              | \_| ''\---/'' | _/ | 
  14. #               \ .-\__ `-` ___/-. / 
  15. #            ___`. .' /--.--\ `. . __ 
  16. #         ."" '< `.___\_<|>_/___.' >'""
  17. #       | | : `- \`.;`\  _ /`;.`/ - ` : | | 
  18. #          \ \ `-. \_ __\ /__ _/ .-` / / 
  19. #      ==`-.____`-.___\_____/___.-`____.-'== 
  20. #                     `=---=' 
  21. ''
  22. @Project :pythonalgorithms  
  23. @File :queuedatastructure.py 
  24. @Author :不胜人生一场醉 
  25. @Date :2021/7/15 1:53  
  26. ''
  27. from queue import Queue, LifoQueue, PriorityQueue, SimpleQueue 
  28. import random 
  29.  
  30. if __name__ == '__main__'
  31.     q = Queue()  # 先进先出队列 
  32.     lq = LifoQueue()  # 先进后厨队列 
  33.     pq = PriorityQueue()  # 优先级队列 
  34.     sq = SimpleQueue()  # 简单队列 
  35.     # 插入队列数据 
  36.     for i in range(10): 
  37.         q.put(i) 
  38.         lq.put(i) 
  39.         pq.put(random.randint(1, 20), i) 
  40.         sq.put(i) 
  41.     for i in range(10): 
  42.         print(q.get(), end=' '
  43.     # 0 1 2 3 4 5 6 7 8 9  
  44.     print('\r'
  45.     for i in range(10): 
  46.         print(lq.get(), end=' '
  47.     # 9 8 7 6 5 4 3 2 1 0  
  48.     print('\r'
  49.     for i in range(10): 
  50.         print(pq.get(), end=' '
  51.     # 6 7 13 16 17 18 18 19 20 20  
  52.     print('\r'
  53.     for i in range(10): 
  54.         print(sq.get(), end=' '
  55.     # 0 1 2 3 4 5 6 7 8 9  
  56.  
  57.     q = Queue(3) 
  58.     print('\r'
  59.     print('queue.qsize=', q.qsize()) 
  60.     # queue.qsize= 0 
  61.     print('queue.empty=', q.empty()) 
  62.     # queue.empty= True 
  63.     q.put(5) 
  64.     q.put(9) 
  65.     q.put(1) 
  66.     print('queue.full=', q.full()) 
  67.     # queue.fullTrue 
  68.     # q.put(10) 
  69.     # print(q) 
  70.     # q.put(11,block=True,timeout=1)  #在timeout=1秒左右,返回 raise Full 
  71.     # print(q) 
  72.     # q.put(11, block=False, timeout=1)  # 立刻 返回 raise Full,忽略时间 
  73.     # print(q) 

输出结果为:

 

责任编辑:武晓燕 来源: python与大数据分析
相关推荐

2009-08-11 14:43:42

C#数据结构与算法

2011-04-11 11:23:17

队列数据结构

2011-04-11 12:48:36

队列数据结构C++

2021-07-15 06:43:12

Python数据结构

2021-07-13 07:52:03

Python数据结构

2017-03-01 13:58:46

Python数据结构链表

2021-07-11 12:06:43

python数据结构

2021-06-11 06:10:09

Python数据结构算法

2022-09-01 16:27:19

JavaScriptWeb开发

2021-03-09 06:30:32

JAVA数据结构算法

2021-03-29 08:01:20

JavaScript数据结构

2023-03-28 07:44:23

数据结构数组

2020-12-17 10:12:33

数据结构算法队列

2009-07-02 14:59:28

Java考研试题

2012-02-02 10:21:05

单链表nexthead

2024-10-11 16:43:05

高并发数据结构技巧

2023-09-26 12:22:37

队列Python

2021-05-10 07:08:41

数据结构缓存

2020-12-31 05:31:01

数据结构算法

2018-06-06 08:54:23

数据结构存储
点赞
收藏

51CTO技术栈公众号