忍不住想報一句粗口“臥槽”這尼瑪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) # 進隊列

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

python之 棧與隊列