heapq

Posted 2021-03-07 wenshu

# 怎样从一个集合中获得最大或者最小的 N 个元素列表？

 

import heapq

nums = (1, 8, 2, 23, 7, -4, 18, 23, 42, 37, 2)

print(heapq.nlargest(1, nums)) # Prints [42, 37, 23]

print(heapq.nsmallest(3, nums)) # Prints [-4, 1, 2]

 

 

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(1, portfolio, key=lambda s: s[‘price‘])   # 上面代码在对每个元素进行对比的时候，会以 price 的值进行比较

expensive = heapq.nlargest(1, portfolio, key=lambda s: s[‘price‘])

print(cheap)

print(expensive)

 

 

# print(min(nums))

# print(max(nums))

 

nums = [1, 8, 2, 23, 7, -4, 18, 23, 42, 37, 2]

heapq.heapify(nums)  # 转换list成为heapq(必须要为list)

print(nums)  # 堆数据结构最重要的特征是 heap[0] 永远是最小的元素。并且剩余的元素可以很

# 容易的通过调用 heapq.heappop() 方法得到，该方法会先将第一个元素弹出来，然后

# 用下一个最小的元素来取代被弹出元素

min = heapq.heappop(nums)   # 需要先转换成堆结构

print(min)

 

# 总结：当要查找的元素个数相对比较小的时候，函数 nlargest() 和 nsmallest() 是很

# 合适的。如果你仅仅想查找唯一的最小或最大 (N=1) 的元素的话，那么使用 min() 和

# max() 函数会更快些。类似的，如果 N 的大小和集合大小接近的时候，通常先排序这

# 个集合然后再使用切片操作会更快点 ( sorted(items)[:N] 或者是 sorted(items)[-

# N:] )。需要在正确场合使用函数 nlargest() 和 nsmallest() 才能发挥它们的优势 (如果

# N 快接近集合大小了，那么使用排序操作会更好些)。

 

 

 

class PriorityQueue:

    ‘‘‘

    优先级队列

    ‘‘‘

    def __init__(self):

        self._queue = []

        self._index = 0

 

    def push(self,item,priority):

        heapq.heappush(self._queue,(-priority,self._index,item))

        self._index+=1

 

    def pop(self):

        return heapq.heappop(self._queue)[-1]

 

    def __str__(self):

        return str(self._queue)

 

class Item:

    def __init__(self,name):

        self.name = name

 

    def  __repr__(self):

        return ‘Item({!r})‘.format(self.name)

q = PriorityQueue()

q.push(Item(‘foo‘), 1)

q.push(Item(‘bar‘), 5)

q.push(Item(‘spam‘), 4)

q.push(Item(‘grok‘), 1)

print(q)

print(q.pop())

print(q.pop())

print(q.pop())

print(q.pop())

 

 

 

 

#函 数 heapq.heappush() 和

# heapq.heappop() 分别在队列 queue 上插入和删除第一个元素，并且队列 queue 保证

# 第一个元素拥有最小优先级 (1.4 节已经讨论过这个问题)。 heappop() 函数总是返回”

# 最小的” 的元素，这就是保证队列 pop 操作返回正确元素的关键。另外，由于 push 和

# pop（会对元组得数据进行比较） 操作时间复杂度为 O(log N)，其中 N 是堆的大小，因此就算是 N 很大的时候它们

# 运行速度也依旧很快。

# 在上面代码中，队列包含了一个 (-priority, index, item) 的元组。优先级为负

# 数的目的是使得元素按照优先级从高到低排序。这个跟普通的按优先级从低到高排序

# 的堆排序恰巧相反。

# index 变量的作用是保证同等优先级元素的正确排序。通过保存一个不断增加的

# index 下标变量，可以确保元素按照它们插入的顺序排序。而且， index 变量也在相

# 同优先级元素比较的时候起到重要作用

 

 

aa= [(0,1,2),(1,2,2),(0,1,3),(0,1,4),(2,1,3)]

heapq.heapify(aa)

a1= heapq.heappop(aa)

print(a1)

a2= heapq.heappop(aa)

print(a2)

a3= heapq.heappop(aa)

print(a3)

a4= heapq.heappop(aa)  # heappop会根据元组得大小进行弹出

print(a4)

result:

(0, 1, 2)

(0, 1, 3)

(0, 1, 4)

(1, 2, 2)