锐客网

  1. 首页 > 生活百科 > it技术 > >

python函数队列 python中队列的定义

IT技术队列

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实现简单多线程任务队列
最近我在用梯度下降算法绘制神经网络的数据时，遇到了一些算法性能的问题 。梯度下降算法的代码如下（伪代码）：
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 叫队列 ， 是数据结构中的一种，基本上所有成熟的编程语言都内置了对 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 是一个优先级队列，队列里面的任务按照优先级排序，优先级高的先被取出 。
如你所见，就是上面所说的三种不同类型的内置队列 ， 其中 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.队列先进先出，栈先进后出 。
2.
对插入和删除操作的"限定" 。
栈是限定只能在表的一端进行插入和删除操作的线性表 。
队列是限定只能在表的一端进行插入和在另一端进行删除操作的线性表 。
从"数据结构"的角度看，它们都是线性结构，即数据元素之间的关系相同 。但它们是完全不同的数据类型 。除了它们各自的基本操作集不同外 ， 主要区别是对插入和删除操作的"限定" 。
栈和队列是在程序设计中被广泛使用的两种线性数据结构，它们的特点在于基本操作的特殊性，栈必须按"后进先出"的规则进行操作，而队列必须按"先进先出"
的规则进行操作 。和线性表相比，它们的插入和删除操作受更多的约束和限定，故又称为限定性的线性表结构 。
3.遍历数据速度不同 。栈只能从头部取数据
也就最先放入的需要遍历整个栈最后才能取出来 ， 而且在遍历数据的时候还得为数据开辟临时空间，保持数据在遍历前的一致性队列怎不同，他基于地址指针进行遍历，而且可以从头或尾部开始遍历 ， 但不能同时遍历，无需开辟临时空间，因为在遍历的过程中不影像数据结构，速度要快的多
栈（stack）是限定只能在表的一端进行插入和删除操作的线性表 。
队列（queue）是限定只能在表的一端进行插入和在另一端进行删除操作的线性表 。
从"数据结构"的角度看，它们都是线性结构，即数据元素之间的关系相同 。但它们是完全不同的数据类型 。除了它们各自的基本操作集不同外，主要区别是对插入和删除操作的"限定" 。
栈和队列是在程序设计中被广泛使用的两种线性数据结构 ， 它们的特点在于基本操作的特殊性 ， 栈必须按"后进先出"的规则进行操作，而队列必须按"先进先出"的规则进行操作 。和线性表相比，它们的插入和删除操作受更多的约束和限定，故又称为限定性的线性表结构 。
【python函数队列 python中队列的定义】python函数队列的介绍就聊到这里吧 ， 感谢你花时间阅读本站内容，更多关于python中队列的定义、python函数队列的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：Linux打开修改命令，linux打开文件修改命令

    下一篇：com网站制作，zm网站制作