python中heapq模块,python heapq的具体用法

　　这篇文章主要介绍了大蟒中heapq堆排算法的实现，该模块提供了堆排序算法的实现。堆是二叉树，最大堆中父节点大于或等于两个子节点，最小堆父节点小于或等于两个子节点。下面文章更多详细介绍，需要的小伙伴可以参考一下

目录

一、创建堆

　　heapq有两种方式创建堆， 一种是使用一个空列表，然后使用heapq.heappush()函数把值加入堆中，另外一种就是使用heap.heapify(列表)转换列表成为堆结构

　　导入heapq

　　# 第一种

　　函数定义：

　　heapq.heappush(堆，项目)

　　-将值项推到堆上，保持堆不变。

　　heapq.heappop(堆)

　　-弹出并返回堆中最小的项，保持堆不变。

　　如果堆为空，将引发索引错误.要访问最小的项而不弹出它，请使用堆[0].

　　nums=[2，3，5，1，54，23，132]

　　堆=[]

　　对于nums:中的数字

　　heapq.heappush(堆，数量)#加入堆

　　print(heap[0]) #如果只是想获取最小值而不是弹出，使用堆[0]

　　打印([heapq。范围内_的堆弹出(堆)(len(nums))])#堆排序结果

　　# out: [一，二，三，五，二十三，五十四，一百三十二]

　　# 第二种

　　nums=[2，3，5，1，54，23，132]

　　heapq.heapify(nums)

　　打印([heapq。范围内_的堆弹出(堆)(len(nums))])#堆排序结果

　　# out: [一，二，三，五，二十三，五十四，一百三十二]

　　heapq模块还有一个heapq.merge(*iterables)方法，用于合并多个排序后的序列成一个排序后的序列， 返回排序后的值的迭代器。

　　类似于已排序(itertools.chain(*iterables))，但返回的是可迭代的。

　　函数定义：

　　heapq.merge(*iterables)

　　-将多个排序的输入合并为一个排序的输出(例如，合并多个日志文件中带有时间戳的条目)。返回

　　已排序值的迭代器。

　　-类似于已排序(ITER工具。chain(* iterables))，但返回一个可迭代的，不将数据一次全部拉入内存，并假定

　　每个输入流已经被排序(从最小到最大)。

　　导入heapq

　　num1=[32，3，5，34，54，23，132]

　　num2=[23，2，12，656，324，23，54]

　　num1=已排序(num1)

　　num2=已排序(数字2)

　　res=heapq.merge(num1，num2)

　　打印(列表(结果))

二、访问堆内容

　　堆创建好后，可以通过` heapq.heappop()函数弹出堆中最小值。

　　导入heapq

　　nums=[2，43，45，23，12]

　　heapq.heapify(nums)

　　print(heapq.heappop(nums))

　　# out: 2

　　# 如果需要所有堆排序后的元素

　　结果=[ra中_的heapq.heappop(nums)

　　nge(len(nums))]

　　print(result)

　　# out: [12, 23, 43, 45]

　　如果需要删除堆中最小元素并加入一个元素，可以使用​​heapq.heaprepalce()​​函数

import heapq
　　nums = [1, 2, 4, 5, 3]
　　heapq.heapify(nums)
　　heapq.heapreplace(nums, 23)
　　print([heapq.heappop(nums) for _ in range(len(nums))])
　　# out: [2, 3, 4, 5, 23]

三、获取堆最大或最小值

　　如果需要获取堆中最大或最小的范围值，则可以使用​​heapq.nlargest()​​​或​​heapq.nsmallest()​​函数

"""
　　函数定义：
　　heapq.nlargest(n, iterable[, key])¶
　　- Return a list with the n largest elements from the dataset defined by iterable.
　　- key if provided, specifies a function of one argument that is used to extract a comparison key from each element in the iterable: key=str.lower
　　- Equivalent to: sorted(iterable, key=key, reverse=True)[:n]
　　"""
　　import heapq
　　nums = [1, 3, 4, 5, 2]
　　print(heapq.nlargest(3, nums))
　　print(heapq.nsmallest(3, nums))
　　"""
　　输出：
　　[5, 4, 3]
　　[1, 2, 3]
　　"""

　　这两个函数还接受一个key参数，用于dict或其他数据结构类型使用

import heapq
　　from pprint import pprint
　　portfolio = [
　　{name: IBM, shares: 100, price: 91.1},
　　{name: AAPL, shares: 50, price: 543.22},
　　{name: FB, shares: 200, price: 21.09},
　　{name: HPQ, shares: 35, price: 31.75},
　　{name: YHOO, shares: 45, price: 16.35},
　　{name: ACME, shares: 75, price: 115.65}
　　]
　　cheap = heapq.nsmallest(3, portfolio, key=lambda s: s[price])
　　expensive = heapq.nlargest(3, portfolio, key=lambda s: s[price])
　　pprint(cheap)
　　pprint(expensive)
　　"""
　　输出：
　　[{name: YHOO, price: 16.35, shares: 45},
　　{name: FB, price: 21.09, shares: 200},
　　{name: HPQ, price: 31.75, shares: 35}]
　　[{name: AAPL, price: 543.22, shares: 50},
　　{name: ACME, price: 115.65, shares: 75},
　　{name: IBM, price: 91.1, shares: 100}]
　　"""

四、heapq应用

　　实现heap堆排序算法：

>>> def heapsort(iterable):
　　... h = []
　　... for value in iterable:
　　... heappush(h, value)
　　... return [heappop(h) for i in range(len(h))]
　　...
　　>>> heapsort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])
　　[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

　　该算法和​​sorted(iterable)​​类似，但是它是不稳定的。

　　堆的值可以是元组类型，可以实现对带权值的元素进行排序。

>>> h = []
　　>>> heappush(h, (5, write code))
　　>>> heappush(h, (7, release product))
　　>>> heappush(h, (1, write spec))
　　>>> heappush(h, (3, create tests))
　　>>> heappop(h)
　　(1, write spec)

　　到此这篇关于python中heapq堆排算法的实现的文章就介绍到这了,更多相关python heapq 堆内容请搜索盛行IT软件开发工作室以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT软件开发工作室！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。