如何在python中颠倒PriorityQueue的顺序？

Question

I have created a simple priority queue in python that orders items by their value:

import Queue
q = Queue.PriorityQueue()
for it in items:
    q.put((it.value, it))

but when i print the queue using:

while not q.empty()
    print q.get()

it will always print the lowest value first. is there a way of getting the last item in a queue without changing the last two lines in the top bit of code to:

for it in items:
    q.put((-1*it.value, it))

because that seems a bit messy and creates problems if i want to use that information for something else (i would have to multiply it by -1 again)

Answer 1

You could just make your own class that inherits from PriorityQueue and does the messy -1 multiplication under the hood for you:

class ReversePriorityQueue(PriorityQueue):

def put(self, tup):
    newtup = tup[0] * -1, tup[1]
    PriorityQueue.put(self, newtup)

def get(self):
    tup = PriorityQueue.get(self)
    newtup = tup[0] * -1, tup[1]
    return newtup

This appears to work with tuples, at least:

Q = ReversePriorityQueue()

In [94]: Q.put((1,1))

In [95]: Q.get()
Out[95]: (1, 1)

In [96]: Q.put((1,1))

In [97]: Q.put((5,5))

In [98]: Q.put((9,9))

In [99]: Q.get()
Out[99]: (9, 9)

In [100]: Q.get()
Out[100]: (5, 5)

In [101]: Q.get()
Out[101]: (1, 1)

I'm sure you could generalize the code to work with more than just tuples from here.

Answer 2

You can make the transformation transparent.

What you want is to have a new q.get and a new q.put that transparently modifies data in and out of queue to reverse order:

# new reversed priority put method
q.oldput = q.put
q.put = lambda p, i: q.oldput((p * -1, i))

# new reversed priority get method
q.oldget = q.get
# create get closure for queue
def newget(q):
    def g():
        item = q.oldget()
        # reverse first element
        return item[0] * -1, item[1]
    # return get method for given queue
    return g
# bind to queue
q.get = newget(q)

# test
items = range(10)
for it in items:
    q.put(*(it, it))

while not q.empty():
    print q.get()

If this is to be made to a more robust code I strongly recommend using a class and not just re-bind the methods.

Answer 3

You can use a customized Class instead of a tuple. Then you can do whatever you like in the cmp.

Answer 4

If you'd like to avoid multiplying by -1 when putting to the priority queue. You can do something like this.

Make a wrapper class

class Wrapper:
    def __init__(self, value):
        self.value = value
    
    def __lt__(self, next):
        return self.value[0] > next.value[0]

Notice that I've modified the __lt__ function, I've used > instead of < deliberately.

Now for putting an element to the Priority Queue do

from queue import PriorityQueue
pq = PriorityQueue()
pq.put(Wrapper((priority, 'extra data')))

Now while getting the element make sure to use the value attribute instead

t = pq.get().value

Answer 5

By definition you can only retrieve items from the front of a queue. To reverse the order, you could push everything onto a stack, and then pop items off the stack. Since a stack both adds and retrieves items from its back, this has the same effect as reversing the queue.

Answer 6

In the case of Queue.PriorityQueue

The lowest valued entries are retrieved first (the lowest valued entry is the one returned by sorted(list(entries))[0]).

So can you try queue.LifoQueue .It is of LIFO mechanism.

Answer 7

According to the spec (assuming python 2.7):

The lowest valued entries are retrieved first

So that would mean, no, you can't.