python 中的queue, deque

创建双向队列

import collections
d = collections.deque()

append(往右边添加一个元素)

import collections
d = collections.deque()
d.append(1)
d.append(2)
print(d)

#输出：deque([1, 2])

appendleft（往左边添加一个元素）

import collections
d = collections.deque()
d.append(1)
d.appendleft(2)
print(d)

#输出：deque([2, 1])

clear(清空队列)

import collections
d = collections.deque()
d.append(1)
d.clear()
print(d)

#输出：deque([])

copy(浅拷贝)

import collections
d = collections.deque()
d.append(1)
new_d = d.copy()
print(new_d)

#输出：deque([1])

count(返回指定元素的出现次数)

import collections
d = collections.deque()
d.append(1)
d.append(1)
print(d.count(1))

#输出：2

extend(从队列右边扩展一个列表的元素)

import collections
d = collections.deque()
d.append(1)
d.extend([3,4,5])
print(d)

#输出：deque([1, 3, 4, 5])

extendleft(从队列左边扩展一个列表的元素)

import collections
d = collections.deque()
d.append(1)
d.extendleft([3,4,5])
print(d)
#
# #输出：deque([5, 4, 3, 1])

index（查找某个元素的索引位置）

import collections
d = collections.deque()
d.extend([‘a‘,‘b‘,‘c‘,‘d‘,‘e‘])
print(d)
print(d.index(‘e‘))
print(d.index(‘c‘,0,3))  #指定查找区间

#输出：deque([‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘])
#     4
#     2

insert（在指定位置插入元素）

import collections
d = collections.deque()
d.extend([‘a‘,‘b‘,‘c‘,‘d‘,‘e‘])
d.insert(2,‘z‘)
print(d)

#输出：deque([‘a‘, ‘b‘, ‘z‘, ‘c‘, ‘d‘, ‘e‘])

pop（获取最右边一个元素，并在队列中删除）

import collections
d = collections.deque()
d.extend([‘a‘,‘b‘,‘c‘,‘d‘,‘e‘])
x = d.pop()
print(x,d)

#输出：e deque([‘a‘, ‘b‘, ‘c‘, ‘d‘])

popleft（获取最左边一个元素，并在队列中删除）

import collections
d = collections.deque()
d.extend([‘a‘,‘b‘,‘c‘,‘d‘,‘e‘])
x = d.popleft()
print(x,d)

#输出：a deque([‘b‘, ‘c‘, ‘d‘, ‘e‘])

remove（删除指定元素）

import collections
d = collections.deque()
d.extend([‘a‘,‘b‘,‘c‘,‘d‘,‘e‘])
d.remove(‘c‘)
print(d)

#输出：deque([‘a‘, ‘b‘, ‘d‘, ‘e‘])

reverse（队列反转）

import collections
d = collections.deque()
d.extend([‘a‘,‘b‘,‘c‘,‘d‘,‘e‘])
d.reverse()
print(d)

#输出：deque([‘e‘, ‘d‘, ‘c‘, ‘b‘, ‘a‘])

rotate（把右边元素放到左边）

import collections
d = collections.deque()
d.extend([‘a‘,‘b‘,‘c‘,‘d‘,‘e‘])
d.rotate(2)   #指定次数，默认1次
print(d)

#输出：deque([‘d‘, ‘e‘, ‘a‘, ‘b‘, ‘c‘])

queue模块介绍

模块实现了3种类型的队列，区别在于队列中条目检索的顺序不同。在FIFO队列中，按照先进先出的顺序检索条目。在LIFO队列中，最后添加的条目最先检索到（操作类似一个栈）。在优先级队列中，条目被保存为有序的（使用heapq模块）并且最小值的条目被最先检索。

queue模块定义了下面的类和异常：

class queue.Queue(maxsize=0)

FIFO队列的构造器。maxsize为一个整数，表示队列的最大条目数。一旦队列满，插入将被阻塞直到队列中存在空闲空间。如果maxsize小于等于0，队列大小为无限。maxsize默认为0

import queue
import time

q = queue.Queue()

#FIFO队列先进先出
q.put(2)
q.put(1)
q.put(3)

while not q.empty():
    next_item = q.get()
    print(next_item)
    time.sleep(1)

执行结果：
2
1
3

class queue.LifoQueue(maxsize=0)

LIFO队列的构造器。maxsize是一个整数，表示队列的最大条目数。一旦队列满，插入将被阻塞直到队列中存在空闲空间。如果maxsize小于等于0，队列大小为无限。maxsize默认为0

import queue
import time

q = queue.LifoQueue()

#LIFO队列后进先出
q.put(2)
q.put(1)
q.put(3)

while not q.empty():
    next_item = q.get()
    print(next_item)
    time.sleep(1)

执行结果：
3
1
2

class queue.PriorityQueue(maxsize=0)

优先队列，有别于普通队列的先入先出（虽然字面上还是队列，但其实无论从含义还是实现上，和普通队列都有很大的区别），也有别于栈的先入后出。在实现上，它一般通过堆这一数据结构，而堆其实是一种完全二叉树，它会对进入容器的元素进行排序（根据事先指定的规则），出队的顺序则会是二叉树的根结点代表的元素。

from queue import PriorityQueue
import time

q = PriorityQueue()

q.put((2, ‘code‘))
q.put((1, ‘eat‘))
q.put((3, ‘sleep‘))

while not q.empty():
    next_item = q.get()
    print(next_item)
    time.sleep(3)

执行结果：
(1, ‘eat‘)
(2, ‘code‘)
(3, ‘sleep‘)

exception queue.Empty

当Queue为空时，非阻塞的get()或者get_nowait()被调用时，将抛出该异常。

exception queue.Full

当队列满时，非阻塞的put()或者put_nowait()被调用，将抛出该异常。

Queue对象（Queue、LifoQueue或者PriorityQueue）提供了以下方法：

Queue.qsize()

返回队列的近似大小。注意，qsize() > 0并不能保证接下来的get()方法不被阻塞；同样，qsize() < maxsize也不能保证put()将不被阻塞。

import queue
import time

q = queue.Queue()

q.put(2)
q.put(1)
q.put(3)
q.put(‘python‘)

print(‘queue long:%s‘%q.qsize())

执行结果：
queue long:4

Queue.empty()
如果队列是空的，则返回True，否则False。如果empty()返回True，并不能保证接下来的put()调用将不被阻塞。类似的，empty()返回False也不能保证接下来的get()调用将不被阻塞。

import queue

q = queue.Queue()
que = queue.Queue()

q.put(2)
q.put(1)
q.put(3)
q.put(‘python‘)

print(‘q is empty? :%s‘%q.empty())
print(‘que is empty? :%s‘%que.empty())
执行结果：
q is empty? :False    #队列不为空则返回False
que is empty? :True    #队列未空则返回True

Queue.full()
如果队列满则返回True，否则返回False。如果full()返回True，并不能保证接下来的get()调用将不被阻塞。类似的，full()返回False也不能保证接下来的put()调用将不被阻塞。

import queue

q = queue.Queue(maxsize=4)
que = queue.Queue()

q.put(2)
q.put(1)
q.put(3)
q.put(‘python‘)

print(‘q is full? :%s‘%q.full())
print(‘que is full? :%s‘%que.full())
执行结果：
q is full? :True
que is full? :False

Queue.put(item, block=True, timeout=None)
放item到队列中。如果block是True，且timeout是None，该方法将一直等待直到有队列有空余空间(默认block=True,timeout=None)。如果timeout是一个正整数，该方法则最多阻塞timeout秒并抛出Full异常。如果block是False并且队列满，则直接抛出Full异常（这时timeout将被忽略）。

block为True

import queue
import time

q = queue.Queue(maxsize=2)

#将q队列填满
q.put(‘python‘)
q.put(‘linux‘)

print(time.ctime())    #打印当前时间
try:    #捕获queue.Full异常
    #q.put(‘shell‘, timeout=3)    #默认block=True
    #q.put(‘shell‘, True, timeout=3)    #可以省略block=；直接写True；timeout=可以省略直接写3
    q.put(‘shell‘, block=True, timeout=3)    #q队列已满，再次将数据放入q中，将阻塞3s后抛出异常queue.Full
except queue.Full:
    print(‘queue is full!‘)
    print(time.ctime())    #打印当前时间，可看出q队列阻塞时长
执行结果：
Fri Nov  3 15:06:43 2017
queue is full!
Fri Nov  3 15:06:46 2017

block为False

import queue
import time

q = queue.Queue(maxsize=2)

#将q队列填满
q.put(‘python‘)
q.put(‘linux‘)

print(time.ctime())    #打印当前时间
try:    #捕获queue.Full异常
    q.put(‘shell‘, False, timeout=3)    #block为False时，timeout失效会立即抛出queue.Full异常；故timeout选项可以省略不写
except queue.Full:
    print(‘queue is full!‘)
    print(time.ctime())    #打印当前时间，可看出q队列阻塞时长

执行结果：

Queue.put_nowait(item)
等价于put(item, False)。

Queue.get(block=True, timeout=None)
从队列中移除被返回一个条目。如果block是True并且timeout是None(默认block=True，timeout=None)，该方法将阻塞直到队列中有条目可用。如果timeout是正整数，该方法将最多阻塞timeout秒并抛出Empty异常。如果block是False并且队列为空，则直接抛出Empty异常（这时timeout将被忽略）。

block为True

import queue
import time

q = queue.Queue(maxsize=2)

#当前q队列填为空
print(time.ctime())    #打印当前时间
try:    #捕获queue.Empty异常
    q.get(True, 5)    #Queue.get()获取数据阻塞5s
except queue.Empty:
    print(‘queue is empty!‘)
    print(time.ctime())    #打印当前时间，可看出q队列阻塞时长
执行结果：

block为False

import queue
import time

q = queue.Queue(maxsize=2)

#当前q队列填为空
print(time.ctime())    #打印当前时间
try:    #捕获queue.Empty异常
    #q.get(False, 5)    #Queue.get()获取数据阻塞5s,block=/timeout=可以省略；block=False时timeout可以省略
    q.get(False)
except queue.Empty:
    print(‘queue is empty!‘)
    print(time.ctime())    #打印当前时间，可看出q队列阻塞时长
执行结果：
Fri Nov  3 15:38:23 2017
queue is empty!
Fri Nov  3 15:38:23 2017

Queue.get_nowait()
等价于get(False)。

Queue.task_done()
表示一个先前的队列中的任务完成了。被队列消费者线程使用。对于每个get()获取到的任务，接下来的task_done()的调用告诉队列该任务的处理已经完成。
如果join()调用正在阻塞，当队列中所有的条目被处理后它将恢复执行（意味着task_done()调用将被放入队列中的每个条目接收到）。
如果调用次数超过了队列中放置的条目数目，将抛出ValueError异常。

Queue.join()

阻塞直到队列中所有条目都被获取并处理。
当一个条目被增加到队列时，未完成任务的计数将增加。当一个消费者线程调用task_done()时，未完成任务的计数将减少。当未完成任务的计数减少到0时，join()解锁。

#!/usr/bin/env python3

import queue
import time
import subprocess
import threading

q = queue.Queue()
hosts = [‘192.168.1.68‘, ‘192.168.1.118‘, ‘192.168.1.101‘, ‘192.168.1.250‘, ‘192.168.1.133‘]

def run():
    while True:    #防止线程少于len(hosts)时卡死，不用while循环线程数少时就会导致队列数据无法全部取完，就会造成queue.join()一直阻塞状态
        host = q.get()
        if host == ‘192.168.1.118‘:    #如果ip等于192.168.1.118就休眠10S，用于判读queue.join()是否阻塞直到queue.task_doen()通知后接触阻塞
            time.sleep(10)
        print(‘host ip is:%s‘% host)
        q.task_done()    #当前线程任务完成

def main():
    for i in range(10):
        t = threading.Thread(target=run)
        t.setDaemon(True)
        t.start()

    for item in hosts:
        q.put(item)

    q.join()    #阻塞直至所有线程queue.task_done()返回  

start = time.time()
main()
print("Elapsed Time: %s" % (time.time() - start))
执行结果：
host ip is:192.168.88.68
host ip is:192.168.68.101
host ip is:192.168.66.250
host ip is:192.168.88.133
host ip is:192.168.88.118
Elapsed Time: 10.013836145401001    #由于192.168.1.118大约阻塞了10S

原文地址：https://www.cnblogs.com/MY0213/p/8997461.html

时间： 2024-11-05 20:34:59

python 中的queue, deque的相关文章

python中的Queue与多进程（multiprocessing）

最近接触一个项目,要在多个虚拟机中运行任务,参考别人之前项目的代码,采用了多进程来处理,于是上网查了查python中的多进程 一.先说说Queue(队列对象) Queue是python中的标准库,可以直接import 引用,之前学习的时候有听过著名的"先吃先拉"与"后吃先吐",其实就是这里说的队列,队列的构造的时候可以定义它的容量,别吃撑了,吃多了,就会报错,构造的时候不写或者写个小于1的数则表示无限多 import Queue q = Queue.Queue(10

练习--python中的Queue与多进程（multiprocessing）

按官方说法: This module is OBSOLETE and is only provided on PyPI to support old projects that still use it. Please DO NOT USE IT FOR NEW PROJECTS! Use modern alternatives like the multiprocessing module in the standard library or even an asynchroneous app

python中的进程、线程（threading、multiprocessing、Queue、subprocess）

Python中的进程与线程 学习知识,我们不但要知其然,还是知其所以然.你做到了你就比别人NB. 我们先了解一下什么是进程和线程. 进程与线程的历史 我们都知道计算机是由硬件和软件组成的.硬件中的CPU是计算机的核心,它承担计算机的所有任务. 操作系统是运行在硬件之上的软件,是计算机的管理者,它负责资源的管理和分配.任务的调度. 程序是运行在系统上的具有某种功能的软件,比如说浏览器,音乐播放器等. 每次执行程序的时候,都会完成一定的功能,比如说浏览器帮我们打开网页,为了保证其独立性,就需要一个专

26 python 中deque模块详解

deque模块是python标准库collections中的一项,它提供了两端都可以操作的序列,这意味着,在序列的前后你都可以执行添加或删除操作. 1.创建deque序列: from collections import deque d=deque() 2.deque提供了类似list的操作方法: d=deque() d.append(3) d.append(8) d.append(1) 那么此时 d=deque([3,8,1]),len(d)=3,d[0]=3,d[-1]=1 3.两端都使用p

第一章 python中重要的数据结构（上）

最近,由于工作需要,使用python开发公司的运维自动化平台,所以找本书来并结合官方手册,开始python的学习之旅. 一.列表 [含义]:列表用中括号表示,通过逗号进行分隔一组数据(可以为不同的数据类型),如以下的声明: 1 >>> language = ['chinese','english','japanese'] 2 >>> contries = ['China','Amercia','England','Japan'] 3 4 >>> edw

python中的线程（zz）

引言 一.线程 1.1 普通的多线程1.2 自定义线程类1.3 线程锁1.3.1 未使用锁1.3.2 普通锁Lock和RLock1.3.3 信号量(Semaphore)1.3.4 事件(Event)1.3.5 条件(condition)1.3 全局解释器锁(GIL)1.4 定时器(Timer)1.5 队列1.5.1 Queue:先进先出队列1.5.2 LifoQueue:后进先出队列1.5.3 PriorityQueue:优先级队列1.5.4 deque:双向队列1.6 生产者消费者模型1.7

python中的特殊数据类型

一.python中的特殊数据类型 对于python,一切事物都是对象,对象基于类创建.像是"wangming",38,[11,12,22]均可以视为对象,并且是根据不同的类生成的对象. 参照:http://www.cnblogs.com/wupeiqi/articles/4911365.html 1.列表 如[12,12,23].['wan','fad','dfjap]等 列表具备的功能: class list(object): """ list() -&

Python中的高级数据结构(转)

add by zhj: Python中的高级数据结构 数据结构 数据结构的概念很好理解,就是用来将数据组织在一起的结构.换句话说,数据结构是用来存储一系列关联数据的东西.在Python中有四种内建的数据 结构,分别是List.Tuple.Dictionary以及Set.大部分的应用程序不需要其他类型的数据结构,但若是真需要也有很多高级数据结构可供 选择,例如Collection.Array.Heapq.Bisect.Weakref.Copy以及Pprint.本文将介绍这些数据结构的用法,看 看它

python中常用的函数与库一

1, collections.deque 在python里如果我们用列表作为队列使用也是可以的,只是当从队尾删除或者增加元素的时候是很快的,但是从队首删除或者增加元素则要慢得多,这是因为在队首进行操作其他的元素都要逐一改变. collections.deque就是为队列设计的,它能迅速得删除或者增加元素,无论是队首还是队尾 >>> from collections import deque >>> queue = deque(["Eric", &qu