精华内容
下载资源
问答
  • 一、队列queue队列:使用import queue,...如果还要类似计数器的功能可以加上task_done和joinFIFO 先进先出LIFO 后进先出优先级队列二、先进先出(FIFO)class queue.Queue(maxsize=0)### 普通队列q = queue.Queue(...

    一、队列

    queue队列:使用import queue,用法与进程Queue一样

    实际上这里就是Python解释器中的一种数据结构中的类型——队列

    这里直接使用队列也可以。

    如果还要类似计数器的功能可以加上task_done和join

    FIFO 先进先出

    LIFO 后进先出

    优先级队列

    二、先进先出(FIFO)

    class queue.Queue(maxsize=0)

    ### 普通队列

    q = queue.Queue()

    ### 没有计数器进行阻塞 FIFO

    q.put("first")

    q.put("second")

    q.put("third")

    print(q.get())

    print(q.get())

    print(q.get())

    ### 普通队列

    q = queue.Queue()

    ### 加了计数器进行阻塞的队列 FIFO

    q.put(1) # +1

    q.put(2) # +1

    q.put(3) # +1

    print(q.get())

    q.task_done() # -1

    print(q.get())

    q.task_done() # -1

    print(q.get())

    q.task_done() # -1

    q.join() # 判断计数器是否为0,不为零则会阻塞

    三、后进先出

    class queue.LifoQueue(maxsize=0)

    ### 栈

    q = queue.LifoQueue()

    ### 没有计数器进行阻塞 LIFO

    q.put(1) # +1

    q.put(2) # +1

    q.put(3) # +1

    print(q.get())

    print(q.get())

    print(q.get())

    ### 栈

    q = queue.LifoQueue()

    ### 加了计数器进行阻塞的队列 LIFO

    q.put(1) # +1

    q.put(2) # +1

    q.put(3) # +1

    print(q.get())

    q.task_done() # -1

    print(q.get())

    q.task_done() # -1

    print(q.get())

    q.task_done() # -1

    q.join() # 判断计数器是否为0,不为零则会阻塞

    四、优先级队列

    class queue.PriorityQueue(maxsize=0)

    数字越小优先级越高

    ### 设置优先级的队列

    q = queue.PriorityQueue()

    # put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高

    q.put((20,"a"))

    q.put((10,"b"))

    q.put((30,"c"))

    print(q.get())

    print(q.get())

    print(q.get())

    # 数字越小优先级越高

    展开全文
  • 一、线程队列queue队列:使用import queue,用法与进程Queue一样queue is especially useful in threaded programming when information must be exchanged ...二、先进先出class queue.Queue(maxsize=0)import ...

    一、线程队列

    queue队列:使用import queue,用法与进程Queue一样

    queue is especially useful in threaded programming when information must be exchanged safely between multiple threads.

    二、先进先出

    class queue.Queue(maxsize=0)

    import queue

    q=queue.Queue()

    q.put("first")

    q.put("second")

    q.put("third")

    print(q.get())

    print(q.get())

    print(q.get())

    """

    结果(先进先出):

    first

    second

    third

    """

    三、后进先出

    class queue.LifoQueue(maxsize=0)

    import queue

    q=queue.LifoQueue()

    q.put("first")

    q.put("second")

    q.put("third")

    print(q.get())

    print(q.get())

    print(q.get())

    """

    结果(后进先出):

    third

    second

    first

    """

    四、存储数据时可设置优先级的队列

    class queue.PriorityQueue(maxsize=0)

    4.1 优先级队列

    import queue

    q=queue.PriorityQueue()

    #put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高

    q.put((20,"a"))

    q.put((10,"b"))

    q.put((30,"c"))

    print(q.get())

    print(q.get())

    print(q.get())

    """

    结果(数字越小优先级越高,优先级高的优先出队):

    (10, "b")

    (20, "a")

    (30, "c")

    """

    4.2 更多方法说明

    Constructor for a priority queue. maxsize is an integer that sets the upperbound limit on the number of items that can be placed in the queue. Insertion will block once this size has been reached, until queue items are consumed. If maxsize is less than or equal to zero, the queue size is infinite.

    The lowest valued entries are retrieved first (the lowest valued entry is the one returned by sorted(list(entries))[0]). A typical pattern for entries is a tuple in the form: (priority_number, data).

    exception queue.Empty: Exception raised when non-blocking get() (or get_nowait()) is called on a Queue object which is empty.

    exception queue.Full: Exception raised when non-blocking put() (or put_nowait()) is called on a Queue object which is full.

    Queue.qsize()

    Queue.empty(): return True if empty

    Queue.full(): return True if full

    Queue.put(item, block=True, timeout=None): Put item into the queue. If optional args block is true and timeout is None (the default), block if necessary until a free slot is available. If timeout is a positive number, it blocks at most timeout seconds and raises the Full exception if no free slot was available within that time. Otherwise (block is false), put an item on the queue if a free slot is immediately available, else raise the Full exception (timeout is ignored in that case).

    Queue.put_nowait(item): Equivalent to put(item, False).

    Queue.get(block=True, timeout=None): Remove and return an item from the queue. If optional args block is true and timeout is None (the default), block if necessary until an item is available. If timeout is a positive number, it blocks at most timeout seconds and raises the Empty exception if no item was available within that time. Otherwise (block is false), return an item if one is immediately available, else raise the Empty exception (timeout is ignored in that case).

    Queue.get_nowait(): Equivalent to get(False).

    Two methods are offered to support tracking whether enqueued tasks have been fully processed by daemon consumer threads.

    Queue.task_done(): Indicate that a formerly enqueued task is complete. Used by queue consumer threads. For each get() used to fetch a task, a subsequent call to task_done() tells the queue that the processing on the task is complete.

    If a join() is currently blocking, it will resume when all items have been processed (meaning that a task_done() call was received for every item that had been put() into the queue).

    Raises a ValueError if called more times than there were items placed in the queue.

    Queue.join(): block直到queue被消费完毕。

    展开全文
  • Python 栈,栈是含有一组对象的容器,支持快速后进先出(LIFO)的插入和删除操作。与列表或数组不同,栈通常不允许随机访问所包含的对象。插入和删除操作通常称为入栈(push)和出栈(pop)。现实世界中与栈数据结构...

    Python 栈,栈是含有一组对象的容器,支持快速后进先出(LIFO)的插入和删除操作。与列表或数组不同,栈通常不允许随机访问所包含的对象。插入和删除操作通常称为入栈(push)和出栈(pop)。

    现实世界中与栈数据结构相似的是一叠盘子。

    新盘子会添加到栈的顶部。由于这些盘子非常宝贵且很重,所以只能移动最上面的盘子(后进先出)。要到达栈中位置较低的盘子,必须逐一移除最顶端的盘子。

    栈和队列相似,都是线性的元素集合,但元素的访问顺序不同。

    从队列删除元素时,移除的是最先添加的项(先进先出,FIFO);而栈是移除最近添加的项(后进先出,LIFO)。

    在性能方面,合理的栈实现在插入和删除操作的预期耗时是

    gif.latex

    栈在算法中有广泛的应用,比如用于语言解析和运行时的内存管理(“调用栈”)。树或图数据结构上的深度优先搜索(DFS)是简短而美丽的算法,其中就用到了栈。

    Python中有几种栈实现,每个实现的特性略有不同。下面来分别介绍并比较各自的特性。

    Python 栈 列表——简单的内置栈

    Python的内置列表类型能在正常的

    gif.latex时间内完成入栈和出栈操作,因此适合作为栈数据结构。

    Python的列表在内部以动态数组实现,这意味着在添加或删除时,列表偶尔需要调整元素的存储空间大小。列表会预先分配一些后备存储空间,因此并非每个入栈或出栈操作都需要调整大小,所以这些操作的均摊时间复杂度为

    gif.latex

    这么做的缺点是列表的性能不如基于链表的实现(如collections.deque,下面会介绍),后者能为插入和删除操作提供稳定的

    gif.latex时间复杂度。另一方面,列表能在

    gif.latex时间快速随机访问堆栈上的元素,这能带来额外的好处。

    使用列表作为堆栈应注意下面几个重要的性能问题。

    为了获得

    gif.latex的插入和删除性能,必须使用append()方法将新项添加到列表的末尾,删除时也要使用pop()从末尾删除。为了获得最佳性能,基于Python列表的栈应该向高索引增长并向低索引缩小。

    从列表前部添加和删除元素很慢,耗时为

    gif(2).latex,因为这种情况下必须移动现有元素来为新元素腾出空间。这是一个性能反模式,应尽可能避免。

    >>> s = []

    >>> s.append('eat')

    >>> s.append('sleep')

    >>> s.append('code')

    >>> s

    ['eat', 'sleep', 'code']

    >>> s.pop()

    'code'

    >>> s.pop()

    'sleep'

    >>> s.pop()

    'eat'

    >>> s.pop()

    IndexError: "pop from empty list"

    Python 栈 collections.deque——快速且稳健的栈

    deque类实现了一个双端队列,支持在

    gif.latex时间(非均摊)从两端添加和移除元素。因为双端队列支持从两端添加和删除元素,所以既可以作为队列也可以作为栈。

    Python的deque对象以双向链表实现,这为插入和删除元素提供了出色且一致的性能,但是随机访问位于栈中间元素的性能很差,耗时为

    gif(2).latex

    总之,如果想在Python的标准库中寻找一个具有链表性能特征的栈数据结构实现,那么collections.deque是不错的选择。

    >>> from collections import deque

    >>> s = deque()

    >>> s.append('eat')

    >>> s.append('sleep')

    >>> s.append('code')

    >>> s

    deque(['eat', 'sleep', 'code'])

    >>> s.pop()

    'code'

    >>> s.pop()

    'sleep'

    >>> s.pop()

    'eat'

    >>> s.pop()

    IndexError: "pop from an empty deque"

    Python 栈 queue.LifoQueue——为并行计算提供锁语义

    queue.LifoQueue这个位于Python标准库中的栈实现是同步的,提供了锁语义来支持多个并发的生产者和消费者。

    除了LifoQueue之外,queue模块还包含其他几个类,都实现了用于并行计算的多生产者/多用户队列。

    在不同情况下,锁语义即可能会带来帮助,也可能会导致不必要的开销。在后面这种情况下,最好使用list或deque作为通用栈。

    >>> from queue import LifoQueue

    >>> s = LifoQueue()

    >>> s.put('eat')

    >>> s.put('sleep')

    >>> s.put('code')

    >>> s

    >>> s.get()

    'code'

    >>> s.get()

    'sleep'

    >>> s.get()

    'eat'

    >>> s.get_nowait()

    queue.Empty

    >>> s.get()

    # 阻塞,永远停在这里……

    Python 栈 比较Python中各个栈的实现

    从上面可以看出,Python中有多种栈数据结构的实现,各自的特性稍有区别,在性能和用途上也各有优劣。

    如果不寻求并行处理支持(或者不想手动处理上锁和解锁),可选择内置列表类型或collections.deque。两者背后使用的数据结构和总体易用性有所不同。

    列表底层是动态数组,因此适用于快速随机访问,但在添加或删除元素时偶尔需要调整大小。列表会预先分配一些备用存储空间,因此不是每个入栈或出栈操作都需要调整大小,这些操作的均摊时间复杂度为

    gif.latex。但需要小心,只能用append()和pop()从“右侧”插入和删除元素,否则性能会下降为

    gif(2).latex

    collections.deque底层是双向链表,为从两端的添加和删除操作进行了优化,为这些操作提供了一致的

    gif.latex性能。collections.deque不仅性能稳定,而且便于使用,不必担心在“错误的一端”添加或删除项。

    总之,我认为collections.deque是在Python中实现栈(LIFO队列)的绝佳选择。

    关键要点

    Python中有几个栈实现,每种实现的性能和使用特性略有不同。

    collections.deque提供安全且快速的通用栈实现。

    内置列表类型可以作为栈使用,但要小心只能使用append()和pop()来添加和删除项,以避免性能下降。

    展开全文
  • python实现堆栈 后进先出 LIFO

    千次阅读 2017-07-18 12:42:25
    比较简单的数据结构,直接贴代码 stack=[] def pushit (): stack.append(raw_input('enter new string:').strip()) def popit (): if len(stack)==0: print 'Cannot pop from an...参考自python核心编程 p145

    比较简单的数据结构,直接贴代码

    stack=[]
    
    def pushit ():
        stack.append(raw_input('enter new string:').strip())
    
    def popit ():
        if len(stack)==0:
            print 'Cannot pop from an empty stack'
        else:
            print stack.pop()
    
    def viewstack():
        print stack
    
    CMDs = {'u':pushit, 'o':popit, 'v':viewstack}
    
    def showmenu():
        pr="""
    p(U)sh
    p(O)p
    (V)iew
    (Q)uit
    
    Enter Choice:"""
    
        while True:
            while True:
                try:
                    choice = raw_input(pr).strip()[0].lower()
                except (EOFError,KeyboardInterrupt,IndexError):
                    choice='q'
    
                print '\nYou picked: [%s]' % choice
                if choice not in 'uovq':
                    print 'Invalid option, try again'
                else:
                    break
    
            if choice == 'q':
                break
            CMDs[choice]()
    
    if __name__ == '__main__':
        showmenu()
    参考自python核心编程 p145
    展开全文
  • 先进先出/后进先出。 贴代码: from rediscluster import StrictRedisCluster def redis_queue(): redis_nodes = [ {'host': '192.168.30.153', 'port': 6383}, {'host': '192.168.30.15...
  • 栈的元素存储与利用是遵循后进先出(LIFO)的,如下图,我们可以用一个半开口的方框表示栈,开口的一端称为栈顶,就是这端进行着压栈(push)和出栈(pop)操作。 对于给定的待判断序列,比如这里的A选项453126,我们可以...
  • 堆栈是一个后进先出的数据结构,在这里,利用堆栈的后进先出的原理实现倒序 二、代码 小栗子如下: 1 2 3 4 5 6 7 8 9 10 11 12 13 stack=[12,45,67,56,89,23,54] defpopit(num): jieguo=[] while...
  • 列表Python中列表是可变的,这是它区别于字符串和元组的最重要的特点,一句话概括即:列表可以修改,而字符串和元组不能。以下是 Python 中列表的方法:方法和描述list.append(x) 把一个元素添加到列表的结尾,相当...
  • 后进先出”的栈

    千次阅读 2012-10-02 23:01:53
    栈的修改遵循后进先出的原则,因此栈又称为后进先出的线性表,简称LIFO结构。 栈一般采用数组作为其存储结构,这样做可以避免使用指针,简化程序,当然数组需要预先声明静态数据区的大小,但这不是问题,因为即便是...
  • 栈:后进先出(LIFO:last in first out) 例如:自助餐中的自取餐盘 面试题目:有六个元素6 5 4 3 2 1 的顺序进栈,哪一个不是合法的出栈序列: A. 5 4 3 6 1 2 B.4 5 3 2 1 6 C.3 4 6 5 2 1 D.2 3 4 1 5 6 ...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 在栈中,元素以“后进先出”的方式获取。在队列中,元素以“先进先出”方法获取。该类包含: 一个名为element的int[]类型的数据域,保存队列中的int值 一个名为size的数据域,保存队列中的元素个数 一个构造方法,...
  • class Stack: def __init__(self, stack): self.stack = [] for x in stack: self.push(x) def isEmpty(self): return not self.stack def push(self, obj): self.stack.append(obj) ...
  • python3】 list列表实现Queue队列先进先出的功能1.背景2.code3.参考 1.背景 1.1 队列与列表 队列内会有一个有顺序的容器,列表与这个容器是有区别的; 列表中数据虽然是排列的,但数据被取走后还会保留,而队列中...
  • python队列

    2021-07-01 10:03:06
    一、核心作用 解耦:使程序直接实现松耦合,修改一个函数,不会有串联关系。 ...LifoQueue:LIFO,即last in first out 后进先出 PriorityQueue:优先队列,级别越低,越优先 deque:双边队列 ...
  • Python

    2019-08-11 15:06:46
    后进先出(LIFO,Last in First Out) class Stack: '''栈''' def __init__(self): self.__list = [] def push(self, item): '''添加一个新的元素item到栈顶''' self.__list.append(ite...
  • python

    2020-04-24 19:30:11
    栈是一种**后进先出(Last in First out, LIFO)亦或先进后出(First in Last out, FILO)**的基本数据结构。例如,将子弹一个个装入弹夹,先装入弹夹的子弹后被打出,后装入弹夹的子弹先被打出。 栈的LIFO操作 ...
  • python 队列

    2019-09-22 00:59:12
    通常而言,队列是一种先进先出的数据结构,与之对应的是堆栈这种后进先出的结构。但是在python中,它内置了一个queue模块,它不但提供普通的队列,还提供一些特殊的队列。具体如下: queue.Queue :先进先出队列 ...
  • https://www.xin3721.com/eschool/python.htmlpython实现堆栈堆栈是一个后进先出的数据结构,其工作方式就像一堆汽车排队进去一个死胡同里面,最先进去的一定是最后出来。我们可以设置一个类,用列表来存放栈中元素...
  • Python 队列

    2021-02-15 10:05:06
    一、队列的定义 二、Python队列的种类 Queue:普通的先进先出(FIFO)队列。 LifoQueue:后进先出(LIFO)队列,类似于栈。 PriorityQueue deque
  • Python的队列

    2016-01-02 22:58:12
    Python的队列:先进先出后进后出
  • Python queue队列

    2020-10-09 11:48:07
    队列是一种先进先出的数据结构,与之对应的是堆栈这种后进先出的结构。但是在python中,它内置了一个queue模块,它不但提供普通的队列,还提供一些特殊的队列。具体如下: queue.Queue :先进先出队列 queue....
  • Python

    2020-07-09 16:46:53
    Python 基础语法 1.跨平台 面向对象 解释型编程语言 ​ python是解释型语言,但为了提高运行速度,使用了一种编译的方法。编译之后得到pyc文件,存储了字节码(特定于Python的表现形式,不是机器码)。 ​ 源代码 ...
  • Python 数据结构_堆栈

    千次阅读 2016-08-30 16:41:02
    堆栈堆栈堆栈是一个后进先出(LIFO)的数据结构. 堆栈这个数据结构可以用于处理大部分具有后进先出的特性的程序流 . 在堆栈中, push 和 pop 是常用术语: push: 意思是把一个对象入栈. pop: 意思是把一个对象出栈. ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,149
精华内容 3,259
关键字:

python后进先出

python 订阅