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

---

Python模块

import 语句

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

想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：
（类似于C++的 #include）

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

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

from … import 语句

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

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

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

from … import * 语句

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

from modname import *
1

__name__属性

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

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

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')
1
2
3
4
5
6
7

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

堆（heapq）

引用模块

import heapq
1

from heapq import *
1

对应函数

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

heapq.heapify(list)
1

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

heapq.heappush(heap, 4)
1

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

min_element = heapq.heappop(heap)
1

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

min_element = heapq.heappushpop(heap, 5)
1

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

min_element = heapq.heapreplace(heap, 6)
1

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

largest_elements = heapq.nlargest(3, iterable)
1

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

smallest_elements = heapq.nsmallest(3, iterable)
1

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

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

队列（Queue）

引用模块

from queue import Queue
1

对应函数

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

对应函数

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

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

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

对应函数

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)

1
2
3
4
5
6
7
8
9
10
11

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

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

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

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

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

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

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

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

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

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

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

d = deque([1, 2, 3])
d.extendleft([0, -1])
print(d)  # 输出：deque([-1, 0, 1, 2, 3])
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])
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])
1
2
3

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

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

栈（LifoQueue）

引用模块

from queue import LifoQueue
1

对应函数

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。