# Can I get an item from a PriorityQueue without removing it yet?

9.8k Views

I want to get the next item in queue but I don't want to dequeue it. Is it possible in Python's `queue.PriorityQueue`? From the docs, I don't see how can it be done

If a is a PriorityQueue object, You can use a.queue[0] to get the next item:

``````from Queue import PriorityQueue

a = PriorityQueue()

a.put((10, "a"))
a.put((4, "b"))
a.put((3,"c"))

print a.queue
print a.get()
print a.queue
print a.get()
print a.queue
``````

output is :

``````[(3, 'c'), (10, 'a'), (4, 'b')]
(3, 'c')
[(4, 'b'), (10, 'a')]
(4, 'b')
[(10, 'a')]
``````

but be careful about multi thread access.

• 1
• And note that get() is blocking by default which indexing would not do.
• In the case of multi threading, we could lock the q.mutex, and release the lock after reading q.queue[0].
• It appears that while `q.queue[0]` returns the highest priority item in the queue, `q.queue[1]` does not necessarily return the 2nd highest priority item
• @Woofas What you say is totally true and from my point of view, it's an unexpected behavior... Do you know why it happens?
• 1
• @Woofas you will find that the 2nd highest priority is either `q.queue[1]` or `q.queue[2]`. That is because according to the theory of Priority Queues, the parent (`q.queue[0]` in this case) must have a higher priority that either of its two children (`q.queue[1]` and `q.queue[2]`), but the specific order of these two children is not important. This means that the whole q.queue is not absolutely sorted, only "heap" sorted (i.e every level has a higher priority than the level below it)

If you want next element in the PriorityQueue, in the order of the insertion of the elements, use:

``````for i in range(len(queue)):
print queue.queue[i]
``````

this will not pop anything out.

If you want it in the priority order, use:

``````for i in range(len(queue)):
temp = queue.get()
queue.put(temp)
print temp
``````

If you are using a tuple, instead of a single variable, replace temp by:

``````((temp1,temp2))
``````
• 2
• This solution isn't limited to just PriorityQueue objects. It also works for Queue objects. Seems like the most elegant solution to me. No offense intended, but I don't see how the other answers come close to this one (imho).
• 1
• The first part does not give you the elements in the inserted order, but the first element will be the one with lowest value.

Assuming your items stored in the PriorityQueue is a tuple (key, value),

``````def peak(pq):
return pq.queue[0][1]
``````

Indexing the first element of the queue should work. If you're using the `heapq` library, the document mentions:

The interesting property of a heap is that its smallest element is always the root, `heap[0]`.

• If you can check the code hg.python.org/cpython/file/2.7/Lib/Queue.py then they use list for storing the data. So you can play with the list as you want which is `self.queue` in the example. Also u can check the `_get` method of PriorityQueue so if you want to change that functionality then also override that function.