Python的内置容器（堆 队列 优先队列 双向队列 栈）

目录

• Python模块
• • [import 语句](#import 语句)
  • [from ... import 语句](#from … import 语句)
  • [from ... import * 语句](#from … import * 语句)
  • __name__属性
• 堆（heapq）
• • 引用模块
  • 对应函数
• 队列（Queue）
• • 引用模块
  • 对应函数
• 优先队列（PriorityQueue）
• • 引用模块
  • 对应函数
• 双向队列（deque）
• • 引用模块
  • 对应函数
• 栈（LifoQueue）
• • 引用模块
  • 对应函数

---

Python模块

import 语句

在该语句下引用模块中的内容，需要在引用内容前加上模块的名字。

想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：

（类似于C++的 #include）

import module1[, module2[,... moduleN]

一个模块只会被导入一次，不管你执行了多少次 import。这样可以防止导入模块被一遍又一遍地执行。

from ... import 语句

在该语句下引用模块中的内容，不需要在引用内容前加上模块的名字。

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

from modname import name1[, name2[, ... nameN]]

from ... import * 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import *

__name__属性

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用 __name__ 属性来使该程序块仅在该模块自身运行时执行。

#!/usr/bin/python3
# Filename: using_name.py

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

说明： 每个模块都有一个 __name__ 属性，当其值是 __main__ 时，表明该模块自身在运行，否则是被引入。

堆（heapq）

引用模块

import heapq

from heapq import *

对应函数

1. heapq.heapify(heap)
   将一个可迭代对象转换成堆数据结构，括号内不可为空 。
   示例：

heapq.heapify(list)

2. heapq.heappush(heap, element)
   将元素推入堆中，并保持堆的不变性。
   示例：

heapq.heappush(heap, 4)

3. heapq.heappop(heap)
   弹出并返回堆中的最小元素。
   示例：

min_element = heapq.heappop(heap)

4. heapq.heappushpop(heap, element)
   将元素推入堆中，然后弹出并返回堆中的最小元素。
   示例：

min_element = heapq.heappushpop(heap, 5)

5. heapq.heapreplace(heap, element)
   弹出并返回堆中的最小元素，然后将新元素推入堆中。
   示例：

min_element = heapq.heapreplace(heap, 6)

6. heapq.nlargest(n, iterable, key=None)
   返回可迭代对象中的前 n 个最大元素。
   示例：

largest_elements = heapq.nlargest(3, iterable)

7. heapq.nsmallest(n, iterable, key=None)
   返回可迭代对象中的前 n 个最小元素。
   示例：

smallest_elements = heapq.nsmallest(3, iterable)

8. heapq.merge(iterables, key=None, reverse=False)
   合并多个已排序的可迭代对象，返回一个新的已排序的迭代器。
   示例：

sorted_result = list(heapq.merge(list1, list2, list3))

队列（Queue）

引用模块

from queue import Queue

对应函数

1. queue.Queue(maxsize=0)

• maxsize：可选参数，指定队列的最大容量。如果为正整数，表示队列的最大容量，超过此容量时再往队列中放入元素会阻塞。如果为负数或未指定，队列的容量为无限大。

2. queue.put(item, block=True, timeout=None)

• 将 item 放入队列。
• 如果 block 为 True，则在队列未满时立即返回；否则，在队列未满时会阻塞，直到有空间为止。
• 如果指定了 timeout，则在超时前等待 timeout 秒，如果仍无法放入 item，则引发 queue.Full 异常。

3. queue.get(block=True, timeout=None)

• 从队列中获取元素并在获取后将其从队列中删除。
• 如果 block 为 True，则在队列非空时立即返回；否则，在队列非空时会阻塞，直到有元素为止。
• 如果指定了 timeout，则在超时前等待 timeout 秒，如果仍无法获取元素，则引发 queue.Empty 异常。

4. queue.qsize()

   返回队列的大小，即队列中当前的元素个数。

5. queue.empty()

• 如果队列为空，返回 True；否则返回 False。

6. queue.full()

• 如果队列已满，返回 True；否则返回 False。

7. queue.get_nowait()

• get 方法的非阻塞版本，在队列为空时立即引发 queue.Empty 异常。

8. queue.put_nowait(item)

• put 方法的非阻塞版本，在队列已满时立即引发 queue.Full 异常。

9. queue.clear()

• 清空队列，移除队列中所有的元素。注意，该方法在 Python 3.9 之前的版本中可能不存在。

优先队列（PriorityQueue）

引用模块

from queue import PriorityQueue

对应函数

1. PriorityQueue(iterable) ：括号可以为空，即创建了一个空对象。若用可迭代对象初始化必须要 优先级 + 元素 的方式来初始化。

# 创建一个空的优先级队列
my_priority_queue = PriorityQueue()
# 通过可迭代对象初始化优先级队列
data = [(1, "Task 1"), (3, "Task 3"), (2, "Task 2")]
my_priority_queue = PriorityQueue(data)

2. put(item)：向优先级队列中插入元素 item，item 是一个元组，第一个元素为优先级。

3. get()：从优先级队列中获取元素，返回值是一个元组 (priority, data)，其中 priority 是优先级，data 是实际的数据。

4. qsize()：返回优先级队列的大小，即队列中当前的元素个数。

5. empty()：如果优先级队列为空，返回 True；否则返回 False。

6. full()：如果优先级队列已满，返回 True；否则返回 False。在 PriorityQueue 中，永远返回 False，因为它没有固定的最大容量。

双向队列（deque）

引用模块

from collections import deque

对应函数

1. deque(iterable, maxlen=None)：创建一个新的双端队列对象。iterable是可迭代对象，用于初始化队列的元素；maxlen是一个可选参数，用于指定队列的最大长度，如果不指定则队列长度无限制。

from collections import deque

# 创建一个空的deque
d1 = deque()

# 用可迭代对象初始化deque
d2 = deque([1, 2, 3])

# 创建带有最大长度限制的deque
d3 = deque(maxlen=5)

2. append(x)：在双端队列的右端添加元素x。

d = deque([1, 2, 3])
d.append(4)
print(d)  # 输出：deque([1, 2, 3, 4])

3. appendleft(x)：在双端队列的左端添加元素x。

d = deque([1, 2, 3])
d.appendleft(0)
print(d)  # 输出：deque([0, 1, 2, 3])

4. pop()：弹出并返回双端队列右端的元素。

d = deque([1, 2, 3])
print(d.pop())  # 输出：3
print(d)  # 输出：deque([1, 2])

5. popleft()：弹出并返回双端队列左端的元素。

d = deque([1, 2, 3])
print(d.popleft())  # 输出：1
print(d)  # 输出：deque([2, 3])

6. extend(iterable)：在双端队列的右端添加可迭代对象iterable中的所有元素。

d = deque([1, 2, 3])
d.extend([4, 5])
print(d)  # 输出：deque([1, 2, 3, 4, 5])

7. extendleft(iterable)：在双端队列的左端添加可迭代对象iterable中的所有元素。注意，元素的顺序与在iterable中的顺序相反。

d = deque([1, 2, 3])
d.extendleft([0, -1])
print(d)  # 输出：deque([-1, 0, 1, 2, 3])

8. rotate(n)：将双端队列向右旋转n步（如果n为负数，则向左旋转abs(n)步）。

d = deque([1, 2, 3, 4, 5])
d.rotate(2)
print(d)  # 输出：deque([4, 5, 1, 2, 3])

9. remove(value)：从双端队列中删除第一次出现的值为value的元素。如果找不到该值，会抛出ValueError异常。

d = deque([1, 2, 3, 2, 4])
d.remove(2)
print(d)  # 输出：deque([1, 3, 2, 4])

10. count(value)：返回双端队列中值为value的元素个数。

d = deque([1, 2, 3, 2, 4])
count_2 = d.count(2)
print(count_2)  # 输出：2

栈（LifoQueue）

引用模块

from queue import LifoQueue

对应函数

1. LifoQueue()：创建一个空的后进先出队列（栈）。

2. put(item, block=True, timeout=None)：将 item 入栈。

• 如果 block 为 True（默认值），则在队列未满时立即返回；如果为 False，则在队列未满时阻塞，直到有空间为止。
• 如果指定了 timeout，则在超时前等待 timeout 秒，如果仍无法入栈，则引发 queue.Full 异常。

3. get(block=True, timeout=None)：出栈并返回元素。

• 如果 block 为 True（默认值），则在队列非空时立即返回；如果为 False，则在队列非空时阻塞，直到有元素为止。
• 如果指定了 timeout，则在超时前等待 timeout 秒，如果仍无法出栈，则引发 queue.Empty 异常。

4. qsize()：返回队列的大小，即队列中当前的元素个数。

5. empty()：如果队列为空，返回 True；否则返回 False。

6. full()：如果队列已满，返回 True；否则返回 False。