Question

Python有Queue.PriorityQueue，但是我找不到一种方法来使其中的每个值都是唯一的，因为没有方法可以检查某个值是否已经存在（如find（name）或类似）。此外，PriorityQueue需要优先级保持在该值内，因此我甚至无法搜索我的值，因为我还必须知道优先级。您将使用（0.5，myvalue）作为PriorityQueue中的值，然后它将按元组的第一个元素排序。

另一方面，collections.deque类提供了一个函数，用于检查值是否已经存在并且在使用中更自然（没有锁定，但仍然是原子的），但是它没有提供按优先级排序的方法

stackq流上有一些其他的实现与heapq，但heapq也使用值内的优先级（例如在元组的第一个位置），所以它似乎不是很好的比较已有的值。

Creating a python priority Queue

https://stackoverflow.com/questions/3306179/priority-queue-problem-in-python

使用唯一值创建原子优先级队列（=可以从多个线程使用）的最佳方法是什么？

我要添加的示例：

优先级：0.2，值：value1
优先级：0.3，价值：value2
优先级：0.1，值：value3（应首先自动检索）
优先级：0.4，值：value1（即使优先级不同，也不得再次添加）

Answer 1

您可以将优先级队列与集合组合：

import heapq

class PrioritySet(object):
    def __init__(self):
        self.heap = []
        self.set = set()

    def add(self, d, pri):
        if not d in self.set:
            heapq.heappush(self.heap, (pri, d))
            self.set.add(d)

    def get(self):
        pri, d = heapq.heappop(self.heap)
        self.set.remove(d)
        return d

这使用您在某个链接问题中指定的优先级队列。我不知道这是不是你想要的，但是以这种方式将一个集合添加到任何类型的队列都相当容易。

Answer 2

这是一种方法。我基本上从他们如何在Queue.py中定义PriorityQueue开始，并在其中添加了一个集合以跟踪唯一键：

from Queue import PriorityQueue
import heapq

class UniquePriorityQueue(PriorityQueue):
    def _init(self, maxsize):
#        print 'init'
        PriorityQueue._init(self, maxsize)
        self.values = set()

    def _put(self, item, heappush=heapq.heappush):
#        print 'put',item
        if item[1] not in self.values:
            print 'uniq',item[1]
            self.values.add(item[1])
            PriorityQueue._put(self, item, heappush)
        else:
            print 'dupe',item[1]

    def _get(self, heappop=heapq.heappop):
#        print 'get'
        item = PriorityQueue._get(self, heappop)
#        print 'got',item
        self.values.remove(item[1])
        return item

if __name__=='__main__':
    u = UniquePriorityQueue()

    u.put((0.2, 'foo'))
    u.put((0.3, 'bar'))
    u.put((0.1, 'baz'))
    u.put((0.4, 'foo'))

    while not u.empty():
        item = u.get_nowait()
        print item

Boaz Yaniv在几分钟内击败了我，但我想我也发布了它，因为它支持PriorityQueue的完整界面。我留下了一些没有注释的打印语句，但在调试它时我注释了那些。 ;）

Answer 3

如果您想稍后确定任务的优先顺序。

u = UniquePriorityQueue()

u.put((0.2, 'foo'))
u.put((0.3, 'bar'))
u.put((0.1, 'baz'))
u.put((0.4, 'foo'))
# Now `foo`'s priority is increased.
u.put((0.05, 'foo'))

以下是官方指南的另一个实现：

import heapq
import Queue

class UniquePriorityQueue(Queue.Queue):
    """
    - https://github.com/python/cpython/blob/2.7/Lib/Queue.py
    - https://docs.python.org/3/library/heapq.html
    """

    def _init(self, maxsize):
        self.queue = []
        self.REMOVED = object()
        self.entry_finder = {}

    def _put(self, item, heappush=heapq.heappush):
        item = list(item)
        priority, task = item
        if task in self.entry_finder:
            previous_item = self.entry_finder[task]
            previous_priority, _ = previous_item
            if priority < previous_priority:
                # Remove previous item.
                previous_item[-1] = self.REMOVED
                self.entry_finder[task] = item
                heappush(self.queue, item)
            else:
                # Do not add new item.
                pass
        else:
            self.entry_finder[task] = item
            heappush(self.queue, item)

    def _qsize(self, len=len):
        return len(self.entry_finder)

    def _get(self, heappop=heapq.heappop):
        """
        The base makes sure this shouldn't be called if `_qsize` is 0.
        """
        while self.queue:
            item = heappop(self.queue)
            _, task = item
            if task is not self.REMOVED:
                del self.entry_finder[task]
                return item
        raise KeyError('It should never happen: pop from an empty priority queue')

Answer 4

我喜欢@Jonny Gaines Jr. 的回答，但我认为它可以简化。 PriorityQueue 在底层使用一个列表，所以你可以定义：

class PrioritySetQueue(PriorityQueue):
    def _put(self, item):
        if item not in self.queue:
            super(PrioritySetQueue, self)._put(item)

如何在Python中创建唯一的值优先级队列？

4 个答案: