python之 栈与队列

忍不住想报一句粗口“卧槽”这尼玛python的数据结构也太特么方便了吧

想到当初学c语言的数据结构的时候，真的是一笔一划都要自己写出来，这python尼玛直接一个模块就ok

真的是没有对比就没有伤害啊，之前试着用类来模拟栈与队列的时候就感觉，我擦这还挺方便的。

现在直接就可以import了，直接使用函数了，唉，这这这现在只想说一声，

人生苦短，我用python 

当然栈好像没有这个库

.栈(stacks)是一种只能通过访问其一端来实现数据存储与检索的线性数据结构，具有后进先出(last in first out，LIFO)的特征

我们可以用这张图来说明栈的应用，那么栈呢有以下功能

    def push(self, num):
    # 把一个元素添加到栈的最顶层
    def pop(self):
    # 删除栈最顶层的元素，并返回这个元素
    def peek(self):
    # 返回最顶层的元素，并不删除它
    def isEmpty(self):
    # 判断栈是否为空
    def size(self):
    # 返回栈中元素的个数

我们这里用顺序来实现栈的功能

class Stack(object):
    def __init__(self):
        self.__Stack = []
    def push(self, num):
    # 把一个元素添加到栈的最顶层
        self.__Stack.append(num)
    def pop(self):
    # 删除栈最顶层的元素，并返回这个元素
        return self.__Stack.pop()
    def peek(self):
        return self.__Stack[len(self.__Stack)-1]
    # 返回最顶层的元素，并不删除它
    def isEmpty(self):
        return self.__Stack == []
    # 判断栈是否为空
    def size(self):
        return len(self.__Stack)
    # 返回栈中元素的个数

s = Stack()

当然如果你愿意的话同样可以构成一个链式的栈

队列（queue·）我操，这个就厉害了直接导入一个函数就ok了 

import queue

我们不妨大胆的help一下    help(queue)

就有了这样的东西

我们只需要关注 queue 和lifoqueue（先进先出队列），priorityqueue（优先级队列）

当然一般的queue都是先进后出啦，

 empty(self)
     |      Return True if the queue is empty, False otherwise (not     
            reliable!).
     |      
     |      This method is likely to be removed at some point.  Use 
            qsize() == 0
     |      as a direct substitute, but be aware that either approach 
             risks a race
     |      condition where a queue can grow before the result of 
            empty() or
     |      qsize() can be used.
     |      
     |      To create code that needs to wait for all queued tasks to 
             be
     |      completed, the preferred technique is to use the join() 
            method.
     |  
     |  full(self)
     |      Return True if the queue is full, False otherwise (not 
            reliable!).
     |      
     |      This method is likely to be removed at some point.  Use 
            qsize() >= n
     |      as a direct substitute, but be aware that either approach 
            risks a race
     |      condition where a queue can shrink before the result of 
             full() or
     |      qsize() can be used.
     |  
     |  get(self, 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 non-negative 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).
     |  
     |  get_nowait(self)
     |      Remove and return an item from the queue without 
            blocking.
     |      
     |      Only get an item if one is immediately available. 
            Otherwise
     |      raise the Empty exception.
     |  
     |  join(self)
     |      Blocks until all items in the Queue have been gotten and 
            processed.
     |      
     |      The count of unfinished tasks goes up whenever an item 
            is added to the
     |      queue. The count goes down whenever a consumer 
            thread calls task_done()
     |      to indicate the item was retrieved and all work on it is 
            complete.
     |      
     |      When the count of unfinished tasks drops to zero, join() 
            unblocks.
     |  
     |  put(self, item, block=True, timeout=None)
     |      Put an 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 non-negative 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).
     |  
     |  put_nowait(self, item)
     |      Put an item into the queue without blocking.
     |      
     |      Only enqueue the item if a free slot is immediately 
             available.
     |      Otherwise raise the Full exception.
     |  
     |  qsize(self)
     |      Return the approximate size of the queue (not reliable!).
     |  
     |  task_done(self)
     |      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.        

好啦这是直接help出来的，总结一下就是

get(self, block=True, timeout=None) # 出队列

put(self, item, block=True, timeout=None) # 进队列 block是堵塞的意思，如果等于false则报错，

task_done(self) # 指示以前加入队列的任务已完成