锐客网

  1. 首页 > 睿知 > it技术 > >

python队列函数 python 队列

IT技术队列

Python实现简单多线程任务队列Python实现简单多线程任务队列
最近我在用梯度下降算法绘制神经网络的数据时 ， 遇到了一些算法性能的问题 。梯度下降算法的代码如下（伪代码）：
defgradient_descent():# the gradient descent codeplotly.write(X, Y)
一般来说，当网络请求 plot.ly 绘图时会阻塞等待返回，于是也会影响到其他的梯度下降函数的执行速度 。
一种解决办法是每调用一次 plotly.write 函数就开启一个新的线程，但是这种方法感觉不是很好 。我不想用一个像 cerely（一种分布式任务队列）一样大而全的任务队列框架，因为框架对于我的这点需求来说太重了，并且我的绘图也并不需要 redis 来持久化数据 。
那用什么办法解决呢？我在 python 中写了一个很小的任务队列，它可以在一个单独的线程中调用 plotly.write函数 。下面是程序代码 。
fromthreadingimportThreadimportQueueimporttime classTaskQueue(Queue.Queue):
首先我们继承 Queue.Queue 类 。从 Queue.Queue 类可以继承 get 和 put 方法，以及队列的行为 。
def__init__(self, num_workers=1):Queue.Queue.__init__(self)self.num_workers=num_workersself.start_workers()
初始化的时候，我们可以不用考虑工作线程的数量 。
defadd_task(self, task,*args,**kwargs):args=argsor()kwargs=kwargsor{}self.put((task, args, kwargs))
我们把 task, args, kwargs 以元组的形式存储在队列中 。*args 可以传递数量不等的参数，**kwargs 可以传递命名参数 。
defstart_workers(self):foriinrange(self.num_workers):t=Thread(target=self.worker)t.daemon=Truet.start()
我们为每个 worker 创建一个线程 ， 然后在后台删除 。
下面是 worker 函数的代码：
defworker(self):whileTrue:tupl=self.get()item, args, kwargs=self.get()item(*args,**kwargs)self.task_done()
worker 函数获取队列顶端的任务，并根据输入参数运行，除此之外 ， 没有其他的功能 。下面是队列的代码：
我们可以通过下面的代码测试：
defblokkah(*args,**kwargs):time.sleep(5)print“Blokkah mofo!” q=TaskQueue(num_workers=5) foriteminrange(1):q.add_task(blokkah) q.join()# wait for all the tasks to finish. print“Alldone!”
Blokkah 是我们要做的任务名称 。队列已经缓存在内存中，并且没有执行很多任务 。下面的步骤是把主队列当做单独的进程来运行，这样主程序退出以及执行数据库持久化时，队列任务不会停止运行 。但是这个例子很好地展示了如何从一个很简单的小任务写成像工作队列这样复杂的程序 。
defgradient_descent():# the gradient descent codequeue.add_task(plotly.write, x=X, y=Y)
修改之后 ， 我的梯度下降算法工作效率似乎更高了 。如果你很感兴趣的话 ， 可以参考下面的代码 。fromthreadingimportThreadimportQueueimporttime classTaskQueue(Queue.Queue): def__init__(self, num_workers=1):Queue.Queue.__init__(self)self.num_workers=num_workersself.start_workers() defadd_task(self, task,*args,**kwargs):args=argsor()kwargs=kwargsor{}self.put((task, args, kwargs)) defstart_workers(self):foriinrange(self.num_workers):t=Thread(target=self.worker)t.daemon=Truet.start() defworker(self):whileTrue:tupl=self.get()item, args, kwargs=self.get()item(*args,**kwargs)self.task_done() deftests():defblokkah(*args,**kwargs):time.sleep(5)print"Blokkah mofo!" q=TaskQueue(num_workers=5) foriteminrange(10):q.add_task(blokkah) q.join()# block until all tasks are doneprint"All done!" if__name__=="__main__":tests()
Python Queue 入门Queue 叫队列python队列函数，是数据结构中的一种python队列函数，基本上所有成熟的编程语言都内置了对 Queue 的支持 。
Python 中的 Queue 模块实现了多生产者和多消费者模型，当需要在多线程编程中非常实用 。而且该模块中的 Queue 类实现了锁原语，不需要再考虑多线程安全问题 。
该模块内置了三种类型的 Queue，分别是class queue.Queue(maxsize=0) ， class queue.LifoQueue(maxsize=0)和class queue.PriorityQueue(maxsize=0)。它们三个的区别仅仅是取出时的顺序不一致而已 。
Queue 是一个 FIFO 队列 ， 任务按照添加的顺序被取出 。
LifoQueue 是一个 LIFO 队列 ， 类似堆栈，后添加的任务先被取出 。
PriorityQueue 是一个优先级队列，队列里面的任务按照优先级排序，优先级高的先被取出 。
如python队列函数你所见，就是上面所说的三种不同类型的内置队列，其中 maxsize 是个整数，用于设置可以放入队列中的任务数的上限 。当达到这个大小的时候，插入操作将阻塞至队列中的任务被消费掉 。如果 maxsize 小于等于零，则队列尺寸为无限大 。
向队列中添加任务，直接调用put()函数即可
put()函数完整的函数签名如下Queue.put(item, block=True, timeout=None)，如你所见，该函数有两个可选参数 。
默认情况下，在队列满时，该函数会一直阻塞，直到队列中有空余的位置可以添加任务为止 。如果 timeout 是正数，则最多阻塞 timeout 秒，如果这段时间内还没有空余的位置出来 ， 则会引发Full异常 。
当 block 为 false 时 ， timeout 参数将失效 。同时如果队列中没有空余的位置可添加任务则会引发Full异常，否则会直接把任务放入队列并返回，不会阻塞 。
另外，还可以通过Queue.put_nowait(item)来添加任务，相当于Queue.put(item, False)，不再赘述 。同样，在队列满时 ， 该操作会引发Full异常 。
从队列中获取任务，直接调用get()函数即可 。
与put()函数一样，get()函数也有两个可选参数，完整签名如下Queue.get(block=True, timeout=None)。
默认情况下，当队列空时调用该函数会一直阻塞，直到队列中有任务可获取为止 。如果 timeout 是正数，则最多阻塞 timeout 秒，如果这段时间内还没有任务可获取，则会引发Empty异常 。
当 block 为 false 时，timeout 参数将失效 。同时如果队列中没有任务可获取则会立刻引发Empty异常 ， 否则会直接获取一个任务并返回 ， 不会阻塞 。
另外 ， 还可以通过Queue.get_nowait()来获取任务，相当于Queue.get(False)，不再赘述 。同样 ， 在队列为空时 ， 该操作会引发Empty异常 。
Queue.qsize()函数返回队列的大小 。注意这个大小不是精确的，qsize()0 不保证后续的 get() 不被阻塞，同样 qsize()maxsize 也不保证 put() 不被阻塞 。
如果队列为空，返回True，否则返回False。如果 empty() 返回True，不保证后续调用的 put() 不被阻塞 。类似的，如果 empty() 返回False，也不保证后续调用的 get() 不被阻塞 。
如果队列是满的返回True，否则返回False。如果 full() 返回True不保证后续调用的 get() 不被阻塞 。类似的，如果 full() 返回False也不保证后续调用的 put() 不被阻塞 。
queue.Queue()是 FIFO 队列，出队顺序跟入队顺序是一致的 。
queue.LifoQueue()是 LIFO 队列，出队顺序跟入队顺序是完全相反的 ， 类似于栈 。
优先级队列中的任务顺序跟放入时的顺序是无关的，而是按照任务的大小来排序，最小值先被取出 。那任务比较大小的规则是怎么样的呢 。
注意 ， 因为列表的比较对规则是按照下标顺序来比较的，所以在没有比较出大小之前 ，队列中所有列表对应下标位置的元素类型要一致 。
好比[2,1]和["1","b"]因为第一个位置的元素类型不一样，所以是没有办法比较大小的，所以也就放入不了优先级队列 。
然而对于[2,1]和[1,"b"]来说即使第二个元素的类型不一致也是可以放入优先级队列的，因为只需要比较第一个位置元素的大小就可以比较出结果了，就不需要比较第二个位置元素的大小了 。
但是对于[2,1]和 1[2,"b"]来说，则同样不可以放入优先级队列，因为需要比较第二个位置的元素才可以比较出结果，然而第二个位置的元素类型是不一致的，无法比较大小 。
综上，也就是说 ， 直到在比较出结果之前 ， 对应下标位置的元素类型都是需要一致的。
下面我们自定义一个动物类型，希望按照年龄大小来做优先级排序 。年龄越小优先级越高 。
本章节介绍了队列以及其常用操作 。因为队列默认实现了锁原语，因此在多线程编程中就不需要再考虑多线程安全问题了，对于程序员来说相当友好了 。
python_队列1.队列是先进先出python队列函数，列表可以读取某个指定数据
2.队列如果将储存的数据都读完就结束python队列函数，列表可以反复读取
例如：
二、具体介绍一下queue
在使用queue的时候要先引入queue模块python队列函数，创建对象~
其中queue可以创建出三种对象分别是
1.先进先出行Queue（maxsize = ？）
通过上面的例子我们能发现python队列函数，put 方法是往队列放数据，但是队列跟列表不同取完之后数据就没有了，如果取的数据大于列表存放的数据就会卡住这时候有两种解决办法 ， 第一种调用get_nowait（）方法 ， 这时候就会报异常queue.Empty，第二种就是从get自身解决，get(block = False),默认的时候block是True 。
2.后进先出LifeQueue()是个缩写是Last in first out
3.priorityQueue可以理解成vip，看python队列函数你的心情让那先出就先出
三、利用queue和多线程写一个生产者消费者
Python 异步任务队列Celery 使用 在 Python 中定义 Celery 的时候，我们要引入 Broker，中文翻译过来就是“中间人”的意思 。在工头(生产者)提出任务的时候，把所有的任务放到 Broker 里面，在 Broker 的另外一头，一群码农(消费者)等着取出一个个任务准备着手做 。这种模式注定了整个系统会是个开环系统 ， 工头对于码农们把任务做的怎样是不知情的 。所以我们要引入 Backend 来保存每次任务的结果 。这个 Backend 也是存储任务的信息用的 ， 只不过这里存的是那些任务的返回结果 。我们可以选择只让错误执行的任务返回结果到 Backend ， 这样我们取回结果，便可以知道有多少任务执行失败了 。
其实现架构如下图所示：
可以看到，Celery 主要包含以下几个模块：
celery可以通过pip自动安装 。
broker 可选择使用RabbitMQ/redis，backend可选择使用RabbitMQ/redis/MongoDB 。RabbitMQ/redis/mongoDB的安装请参考对应的官方文档 。
------------------------------rabbitmq相关----------------------------------------------------------
官网安装方法：
启动管理插件：sbin/rabbitmq-plugins enable rabbitmq_management 启动rabbitmq：sbin/rabbitmq-server -detached
rabbitmq已经启动，可以打开页面来看看 地址：
用户名密码都是guest。进入可以看到具体页面 。关于rabbitmq的配置，网上很多 自己去搜以下就ok了 。
------------------------------rabbitmq相关--------------------------------------------------------
项目结构如下：
使用前，需要三个方面：celery配置，celery实例，需执行的任务函数，如下：
Celery 的配置比较多，可以在 官方配置文档：查询每个配置项的含义 。
当然，要保证上述异步任务and下述定时任务都能正常执行，就需要先启动celery worker，启动命令行如下:
需 启动beat ，执行定时任务时, Celery会通过celery beat进程来完成 。Celery beat会保持运行, 一旦到了某一定时任务需要执行时, Celery beat便将其加入到queue中. 不像worker进程, Celery beat只需要一个即可 。而且为了避免有重复的任务被发送出去，所以Celery beat仅能有一个 。
命令行启动：
如果你想将celery worker/beat要放到后台运行，推荐可以扔给supervisor 。
supervisor.conf如下：
python实现堆栈与队列的方法python实现堆栈与队列的方法
本文实例讲述了python实现堆栈与队列的方法 。分享给大家供大家参考 。具体分析如下：
1、python实现堆栈，可先将Stack类写入文件stack.py，在其它程序文件中使用from stack import Stack，然后就可以使用堆栈了 。
stack.py的程序:
代码如下:class Stack():
def __init__(self,size):
self.size=size;
self.stack=[];
self.top=-1;
def push(self,ele):#入栈之前检查栈是否已满
if self.isfull():
raise exception("out of range");
else:
self.stack.append(ele);
self.top=self.top 1;
def pop(self):# 出栈之前检查栈是否为空
if self.isempty():
raise exception("stack is empty");
else:
self.top=self.top-1;
return self.stack.pop();
def isfull(self):
return self.top 1==self.size;
def isempty(self):
return self.top==-1;
再写一个程序文件 ， stacktest.py,使用栈，内容如下:
代码如下:#!/usr/bin/python
from stack import Stack
s=Stack(20);
for i in range(3):
s.push(i);
s.pop()
print s.isempty();
2、python 实现队列:
复制代码代码如下:class Queue():
def __init__(self,size):
self.size=size;
self.front=-1;
self.rear=-1;
self.queue=[];
def enqueue(self,ele):#入队操作
if self.isfull():
raise exception("queue is full");
else:
self.queue.append(ele);
self.rear=self.rear 1;
def dequeue(self):#出队操作
if self.isempty():
raise exception("queue is empty");
else:
self.front=self.front 1;
return self.queue[self.front];
def isfull(self):
return self.rear-self.front 1==self.size;
def isempty(self):
return self.front==self.rear;
q=Queue(10);
for i in range(3):
q.enqueue(i);
print q.dequeue();
print q.isempty();
希望本文所述对大家的Python程序设计有所帮助 。
【python队列函数 python 队列】python队列函数的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于python 队列、python队列函数的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：南通红书如何营销的简单介绍

    下一篇：我国区块链产业应用现状，我国区块链技术