忍不住想报一句粗口“卧槽”这尼玛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) # 指示以前加入队列的任务已完成