Python中heapq模块的各种用法实例

在中, 关于heapq模块的这种功能, 有很多的具体例子可以被展示出来。

本次编辑的时间为2025年09月17日 10:26:48, 作者则是进一步有进一步的欢喜。

的heapq模块里面包含了好几个函数, 这些函数的作用是来操作堆的, 并且所有函数都是基于列表来实现的, 接下来文章会主要去介绍中heapq模块各个用法的相关内容, 文中通过代码讲解得非常详细, 有需要的朋友都可以参考下文。

引言

heapq 这个模块, 它是用来处理堆这种数据结构的, 功能相当给力。所谓堆, 它有着自己独特的二叉树那样的特征, 所以在好多数算法还有各种各个的数据处理的场景里头, 都起着非常重要的作用。

说到 heapq 模块, 它在默认的情况下实现的是最小堆, 啥意思? 简单来说就是, 父节点上面的那个值总是小于或者等于它的子节点的值的。然后接下来我们就要好好地深入探索一下 heapq 到底能怎么用。

一、第一步是来进行一些heapq的基础操作, 具体做法是将列表转换为堆。

在实际编程工作里, 我们通常都会遇到这样的情况, 也就是把已经存在的一些数据结构变成堆, 这样做就是为了让可以利用到堆的那些特点去进行高效率的處理。

在里有那个被称为heapq的模块, 这个模块里面提供了一个叫做()函数, 它干的事情就是把一个列表就地转换成堆结构, 不用额外再去申请新的空间, 而且它完成这个任务所花费的时间复杂度是O(n), 这一点非常重要, 因为这意味着, 当处理那些数量非常庞大的大规模数据的时候, 进行转换也是非常快速和高效的。

brush:py; 复制代码
import heapq

nums = 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5

heapq.heapify(nums)

print(nums)

执行以上这些代码, 最终得到的输出结果是。

1, 1, 2, 3, 3, 9, 4, 6, 5, 5, 5

可以看到, 原本顺序比较乱的列表nums到现在已经成功地被转换成了一个符合最小堆定义的排列模式, 那个位于最顶层的元素也就是列表里面的第一个位置上的数, 恰好就是里面所有数字当中最小的那一个。

(二)向堆中添加元素

向堆中添加元素是一个十分常见的操作, heapq.()这个函数就是专门被拿来用在这个目的上的, 它在把新元素添加到堆里面的时候, 是会保持住堆的性质的, 这个操作的所用时间复杂度是O(log n), 这里的n是代表堆里面有多少个元素的数的意思, 有这个特性在的话, 就会让在处理规模很大的堆的时候, 添加元素的这个动作依然能是高效率地完成的。

brush:py; 复制代码
import heapq

heap = 1, 3, 5

heapq.heappush(heap, 2)

print(heap)

运行结果为

1, 2, 5, 3

元素2被很顺利就给添加到那个堆里面去了, 而且这个堆它本身所拥有的那种最小堆的这种性质, 也全部都得以维持了下来。

(三)把那个从堆里面取出来的、数值是最小的元素, 给移走。

当我们需要获取并移除堆中的最小元素时,heapq.()函数便能派上用场。该函数移除并返回堆中的最小元素,同时调整堆结构以保持堆性质,时间复杂度同样为O(log n)。

brush:py; 复制代码
import heapq

heap = 1, 2, 3, 4, 5

min_value = heapq.heappop(heap)

print(min_value)

print(heap)

上面这段代码执行完之后, 会打印出数字1。

2, 4, 3, 5

把1这个小元素从堆里拿掉了, 还把它返回了, 然后对堆的结构进行了调整, 现在2这个最小的元素到了最顶上。

(四)从那个叫作堆的东西里头, 把最小值的那个元素给找出来。

在有些场合, 大家仅仅是想要去观察一下存在堆里面那个最小的元素, 并不想对当前的堆这种结构做出任何修改操作。遇到这种情况的话, 直接去把堆列表里面的第1个元素给拉出来看就可以了, 因为在这个堆里面, 排在第一个的那个位置上的数据, 它就是始终如一对最小的那个元素的准确代表。

brush:py; 复制代码
import heapq

heap = 1, 3, 5, 7, 9

min_value = heap0

print(min_value)

输出结果是1, 借助于这样一种相对简单的处理手段, 大家伙能够对存放着数据的那个堆容器内部所含有的最小数值加以迅速获取操作, 同时呢, 这一过程并不会对原有堆容器的整体结构产生任何影响和改变。

二、关于heapq这个模块, 接下来会介绍一些进阶的使用内容, 第一部分内容主要讲解的是heapq.相关函数的具体使用方法。

heapq模块里面的那个函数, 它把移除堆里面最小元素, 还有把这个指定新元素加进去, 这两件事儿给合成到了一个原子操作里头去了。这个操作的过程是先从堆里面把最小的那个元素给取出来拿走了, 然后把说好的那个元素给加到堆里面去, 最后再把最开始拿出来的那个最小元素给返回给你。

你要是跟前头那两句话比的话, 先调用那个弹出最小元素的函数, 再调用那个添加新元素的函数, 用这个合并后的函数能在某种程度上把效率给提上去一些。

brush:py; 复制代码
import heapq

heap = 1, 3, 5, 7

replaced_value = heapq.heapreplace(heap, 4)

print(replaced_value)

print(heap)

运行结果为1和

3, 4, 5, 7

将那个最小的元素1给移除掉, 并且把它返回出去,与此同时, 再把元素4添加进这个堆里面去, 这样操作之后, 整个堆结构依然能够保持住它那种最小堆的性质。

(二)heapq.merge()合并多个已排序迭代器

在进行多个已排序数据集合的处理工作过程中, heapq.merge()这一个函数是非常实用的工具。它的主要作用在于合并多个已经排好序的迭代器对象, 这些迭代器对象的例子可以包括列表、元祖等类型在内。在合并之后, 这个函数会返回一个新的迭代器对象。

这个新的迭代器对象的特性, 是它能够按照升序排列的方式, 把来自所有输入迭代器里面的元素逐个生成出来。整个合并操作的具体过程, 主要是借助了堆这种数据结构来完成的。

关于时间复杂度方面的表现, 也就是O(N log k)这样的表述其中N代表的含义是所有输入迭代器内部所包含的全部元素的总数量, 而k所代表的含义则是这些输入迭代器的具体总个数。

brush:py; 复制代码
import heapq

list1 = 1, 4, 7

list2 = 2, 5, 8

list3 = 3, 6, 9

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

print(merged)

上述代码输出

1, 2, 3, 4, 5, 6, 7, 8, 9

可以通过使用heapq.merge()这个函数, 让那三个本来就已经排好序的列表被高效地合并起来, 最后会得到一个全新的、也是已经排好序的列表。

(三)heapq.()和heapq.()获取最值元素

heapq.()和heapq.()函数用于获取堆或可迭代对象中的前n个最大和最小元素。这两个函数在处理大数据集时优势明显,因为它们无需对整个数据集进行排序,而是利用堆的特性快速定位目标元素。

brush:py; 复制代码
import heapq

nums = 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5

largest_three = heapq.nlargest(3, nums)

smallest_two = heapq.nsmallest(2, nums)

print(largest_three)

print(smallest_two)

最终的显示结果是两个数值。通过调用heapq模块中的top函数, 并且输入的参数分别是数字3以及列表nums, 系统能够返回出这个列表中体积数居前的三个项。如果将参数改为数字2并依然使用列表nums作为输入数据, 该方法则会给出最小的两个项目的具体数值表现。

三、在实际的应用场景当中, 有一个叫做的东西, 它会用来做一件事情, 那就是把优先队列给实现出来。

优先队列在很多种算法以及很多种系统当中是非常关键的存在, 它会根据元素的优先级进行排序操作, 那些优先级显得更高的元素会排在前面并且率先从队列里面出去, 我们如果借助于heapq这个模块的话, 就可以非常容易地完成优先队列的实现工作, 具体做法就是把元素的本身数值和它所对应的优先级信息打包组合在一起放入一个元组里面, 然后把这个元组放进堆数据结构里面去, 这样就可以充分满足使用优先队列的所有必要需求了。

brush:py; 复制代码
import heapq

class PriorityQueue:

def init(self):

self.heap = \[\]

self.count = 0

def push(self, item, priority):

heapq.heappush(self.heap, (-priority, self.count, item))

self.count += 1

def pop(self):

_, _, item = heapq.heappop(self.heap)

return item

pq = PriorityQueue()

pq.push('task1', 3)

pq.push('task2', 1)

pq.push('task3', 2)

print(pq.pop())

print(pq.pop())

print(pq.pop())

上述代码定义了一个类, 这个类使用了heapq来实现优先队列。push方法的作用是, 把那个任务以及对应的优先级添加到堆里面去。

pop方法呢, 会移除掉并且返回那个优先级最高的任务。输出的结果就是task2、task3、task1这样的顺序。这样的结果符合优先队列按照优先级从高到低来进行出队的那个要求。

(二)咱们来算一算那个数据流里面的中位数, 把那些数从小到大排个队。

咱们在处理数据流的时候, 实时计算那些数据的中位数, 算是个很常见的、大家都需要的功能了。大家可以利用一下那个heapq模块, 然后呢, 一边维护着一个最大堆, 另一边再维护一个最小堆, 这样就能比较高效地实现这一样子的功能了。

只要把数据流里头的那些元素进行合理地分配, 让它们去到两个堆里面去, 那么就可以快速地算出中位数到底是什么了。

brush:py; 复制代码
import heapq

class MedianFinder:

def init(self):

self.small_heap = \[\] # 最大堆

self.large_heap = \[\] # 最小堆

def addNum(self, num):

if not self.small_heap or num <= -self.small_heap0:

heapq.heappush(self.small_heap, -num)

else:

heapq.heappush(self.large_heap, num)

if len(self.small_heap) > len(self.large_heap) + 1:

heapq.heappush(self.large_heap, -heapq.heappop(self.small_heap))

elif len(self.large_heap) > len(self.small_heap):

heapq.heappush(self.small_heap, -heapq.heappop(self.large_heap))

def findMedian(self):

if len(self.small_heap) == len(self.large_heap):

return (-self.small_heap0 + self.large_heap0) / 2

else:

return -self.small_heap0

mf = MedianFinder()

mf.addNum(1)

mf.addNum(2)

print(mf.findMedian())

mf.addNum(3)

print(mf.findMedian())

这段代码是用来定义一个类的, 类里面是通过两个堆来维护数据流的, 其中有一个是最大堆, 另一个是最小堆。在方法里, 会把新的元素添加到对应的堆里面去, 并且会保证这两个堆的大小保持平衡状态。另外, 还提供了一个方法, 是根据两个堆之间的大小关系来进行计算, 然后返回中位数的。

(三)算法的实现

该算法是一种用于在加权图里查找最短路径的经典算法, 在执行这个操作的时候, 它需要快速地取到那个离起点最近的节点, 而由heapq模块所提供的堆数据结构能够刚好满足这种需求, 从而让该算法的运行速度得到明显的提升。

brush:py; 复制代码
import heapq

def dijkstra(graph, start):

distances = {node: float('inf') for node in graph}

distancesstart = 0

pq = (0, start)

while pq:

dist, current = heapq.heappop(pq)

if dist > distancescurrent:

continue

for neighbor, weight in graphcurrent.items():

new_dist = dist + weight

if new_dist < distancesneighbor:

distancesneighbor = new_dist

heapq.heappush(pq, (new_dist, neighbor))

return distances

graph = {

'A': {'B': 1, 'C': 4},

'B': {'A': 1, 'C': 2, 'D': 5},

'C': {'A': 4, 'B': 2, 'D': 1},

'D': {'B': 5, 'C': 1}

}

start_node = 'A'

print(dijkstra(graph, start_node))

上述代码把算法给实现了, 它是靠着用那名为heapq的模块去维护着一个优先队列的状态, 然后在每一次的时候都需要从这个队里面把那个离源点最近的那个节点给取出来去做扩展的动作, 凭借这样的一种方式呢, 能够很高效地去算出从起始的那个源点到这个图里面所有的其他的各个节点之间的最短的距离信息。

四、总结

堆队列这个模块, 它是那个标准库里边很重要的一个部分, 它给开发的小伙伴们提供了一整套很高效的处理那个堆数据结构的好工具。

从最开始的那个创建堆、对里面的元素进行操作, 然后到后面稍微复杂一点的合并操作, 还有获取最值这些功能, 再到比如说在处理优先队列、计算中位数、运行最短路径算法这些实际使用场景的时候的应用, 这个堆队列模块充分地显示出了它特别强大的实用性以及特别的高效性表现。

在日常生活中写程序的时候, 特别是需要处理很多数据的情况之下, 如果能够合理地使用 heapq 这个模块的话, 就可以很大程度地来提高整个程序的速度和效率, 并且还能让代码的排列结构变得更加好一些。

到此结束这篇关于中heapq模块各种用法的文章的介绍, 更多相关heapq模块内容请搜索脚本之家以前的文章或者继续浏览下面的相关文章, 希望大家以后多多支持脚本之家!

相关推荐
大胖爱学习_MJ13 分钟前
超越向量检索:用 Spring Boot + Neo4j 手搓 GraphRAG 知识图谱记忆
java·后端·python
RobinDevNotes26 分钟前
24GB Mac 做数字人:声音放本地,画面租云端
人工智能·python·macos·开发工具
zaizai10071 小时前
算法(左程云)2
数据结构
漂流瓶jz2 小时前
UVA-1615 高速公路 题解答案代码 算法竞赛入门经典第二版
数据结构·算法·贪心算法·贪心·aoapc·算法竞赛入门经典·uva
学无止境小袁同学2 小时前
LlamaIndex Workflows 学习
python·llm·tensorflow·llamaindex·agent开发·多agent·workflows
夊2 小时前
数据结构第四课:栈与队列
数据结构
鲸渔3 小时前
【AI Agent系列课程13-Python 基础13】JSON 读写:结构化数据交换基础
开发语言·python·json·ai编程
凌冰_12 小时前
数据结构 - 时间空间复杂度(一)
数据结构·算法·软件工程
Pniubi13 小时前
力扣2 . 两数相加
算法·leetcode·职场和发展