python 标准库中的内置数据类型和类来实现的栈和队列

• 从队列删除元素时，移除的是最先添加的项（先进先出，FIFO）；
• 而栈是移除最近添加的项（后进先出，LIFO）。

1. Python 栈（后进先出）

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

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

Python的内置列表类型能在正常的时间内完成入栈和出栈操作，因此适合作为栈数据结构。

• append()方法将新项添加到列表的末尾；
• pop()从末尾删除；

s = []
s.append('eat')
s.append('sleep')
s.append('code')
print(s)#['eat', 'sleep', 'code']
s.pop()#'code'
s.pop()#'sleep'
s.pop()#'eat'
s.pop()#IndexError: "pop from empty list"

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

deque类实现了一个双端队列

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

from collections import deque
s = deque()
s.append('eat')
s.append('sleep')
s.append('code')
print(s)#deque(['eat', 'sleep', 'code'])
s.pop()#'code'
s.pop()#'sleep'
s.pop()#'eat'
s.pop()#IndexError: "pop from an empty deque"

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

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

from queue import LifoQueue
s = LifoQueue()
s.put('eat')
s.put('sleep')
s.put('code')
print(s)#<queue.LifoQueue object at 0x108298dd8>
s.get()#'code'
s.get()#'sleep'
s.get()#'eat'
s.get_nowait()#queue.Empty
s.get()## 阻塞，永远停在这里……

• collections.deque提供安全且快速的通用栈实现。
• 内置列表类型可以作为栈使用，但要小心只能使用append()和pop()来添加和删除项，以避免性能下降。

2. Python 队列（先进先出）

队列是含有一组对象的容器，支持快速插入和删除的先进先出语义。插入和删除操作有时称为入队（enqueue）和出队（dequeue）。与列表或数组不同，队列通常不允许随机访问所包含的对象。

2.1 Python 队列 列表——非常慢的队列

s = []
s.append('eat')
s.append('sleep')
s.append('code')
print(s)#['eat', 'sleep', 'code']
s.pop()#'code'# 小心，这种操作很慢！
s.pop()#'sleep'# 小心，这种操作很慢！

2.2 Python 队列 collections.deque——快速和稳健的队列

from collections import deque
s = deque()
s.append('eat')
s.append('sleep')
s.append('code')
print(s)#deque(['eat', 'sleep', 'code'])
s.popleft()#'eat'
s.popleft()#'sleep'
s.popleft()#'code'
s.popleft()#IndexError: "pop from an empty deque"

2.3 Python 队列 queue.Queue——为并行计算提供的锁语义

from queue import Queue
q = Queue()
q.put('eat')
q.put('sleep')
q.put('code')
print(q)#<queue.Queue object at 0x1070f5b38>
q.get()#'eat'
q.get()#'sleep'
q.get()#'code'
q.get_nowait()#queue.Empty
q.get()## 阻塞，永远停在这里……

2.4 Python 队列 multiprocessing.Queue——共享作业队列

multiprocessing.Queue作为共享作业队列来实现，允许多个并发worker并行处理队列中的元素。由于CPython中存在全局解释器锁（GIL），因此无法在单个解释器进程上执行某些并行化过程，只能转向基于进程的并行化。
作为专门用于在进程间共享数据的队列实现，使用multiprocessing.Queue能够方便地在多个进程中分派工作，以此来绕过GIL的限制。这种类型的队列可以跨进程存储和传输任何可pickle的对象。

from multiprocessing import Queue
q = Queue()
q.put('eat')
q.put('sleep')
q.put('code')
print(q)#<multiprocessing.queues.Queue object at 0x1081c12b0>
q.get()#'eat'
q.get()#'sleep'
q.get()#'code'
q.get()## 阻塞，永远停在这里……

2.5 Python 优先队列

Python 优先队列，优先队列是一个容器数据结构，使用具有全序关系的键（例如用数值表示的权重）来管理元素，以便快速访问容器中键值最小或最大的元素，或作插队调整顺序处理。

优先队列可被视为队列的改进版，其中元素的顺序不是基于插入时间，而是基于优先级的。对键进行处理能得到每个元素的优先级。

2.5.1 Python 优先队列 列表——手动维护有序队列

使用有序列表能够快速识别并删除最小或最大的元素，缺点是向列表插入元素表是很慢的。

q = []

q.append((2, 'code'))
q.append((1, 'eat'))
q.append((3, 'sleep'))

# 注意：每当添加新元素或调用bisect.insort()时，都要重新排序。
q.sort(reverse=True)

while q:
    next_item = q.pop()
    print(next_item)

# 结果：
#   (1, 'eat')
#   (2, 'code')
#   (3, 'sleep')

2.5.2 Python 优先队列 heapq——基于列表的二叉堆

heapq模块是在Python中不错的优先级队列实现。由于heapq在技术上只提供最小堆实现，因此必须添加额外步骤来确保排序稳定性，以此来获得“实际”的优先级队列中所含有的预期特性。

import heapq

q = []

heapq.heappush(q, (2, 'code'))
heapq.heappush(q, (1, 'eat'))
heapq.heappush(q, (3, 'sleep'))

while q:
    next_item = heapq.heappop(q)
    print(next_item)

# 结果：
#   (1, 'eat')
#   (2, 'code')
#   (3, 'sleep')

2.5.3 Python 优先队列 queue.PriorityQueue——美丽的优先级队列

queue.PriorityQueue这个优先级队列的实现在内部使用了heapq，时间和空间复杂度与heapq相同。

区别在于PriorityQueue是同步的，提供了锁语义来支持多个并发的生产者和消费者。

from queue import PriorityQueue

q = PriorityQueue()

q.put((2, 'code'))
q.put((1, 'eat'))
q.put((3, 'sleep'))

while not q.empty():
    next_item = q.get()
    print(next_item)

# 结果：
#   (1, 'eat')
#   (2, 'code')
#   (3, 'sleep')