How to Implement Priority Queue in Python?

A priority queue is a data structure where elements are processed based on their priority rather than insertion order. Python's queue module provides PriorityQueue for thread-safe priority-based processing.

Basic FIFO Queue

First, let's understand a regular FIFO (First In, First Out) queue where elements are processed in insertion order ?

import queue

fifo = queue.Queue()

# Put numbers into queue
for i in range(5):
    fifo.put(i)

# Get numbers from queue
print("FIFO Output:")
while not fifo.empty():
    print(fifo.get())

FIFO Output:
0
1
2
3
4

Basic LIFO Queue

A LIFO (Last In, First Out) queue processes the most recently added element first ?

import queue

lifo = queue.LifoQueue()

# Put numbers into queue
for i in range(5):
    lifo.put(i)

# Get numbers from queue
print("LIFO Output:")
while not lifo.empty():
    print(lifo.get())

LIFO Output:
4
3
2
1
0

Priority Queue Implementation

A priority queue processes elements based on their priority value. Lower numbers typically indicate higher priority ?

import queue

# Simple priority queue with tuples (priority, data)
pq = queue.PriorityQueue()

# Add items with priorities
pq.put((3, "Low priority task"))
pq.put((1, "High priority task"))
pq.put((2, "Medium priority task"))

# Process items by priority
print("Priority Queue Output:")
while not pq.empty():
    priority, task = pq.get()
    print(f"Priority {priority}: {task}")

Priority Queue Output:
Priority 1: High priority task
Priority 2: Medium priority task
Priority 3: Low priority task

Priority Queue with Custom Objects

For complex scenarios, create a custom class with comparison methods ?

import queue
import threading

class Job:
    def __init__(self, priority, description):
        self.priority = priority
        self.description = description
        print(f'New job: {description}')
    
    def __lt__(self, other):
        return self.priority < other.priority
    
    def __eq__(self, other):
        return self.priority == other.priority

# Create priority queue
q = queue.PriorityQueue()
q.put(Job(90, 'Developer-Print job'))
q.put(Job(2, 'Business-Report job'))  
q.put(Job(1, 'Business-Critical Job'))

# Process jobs in priority order
def process_job(q):
    while True:
        next_job = q.get()
        print(f"Processing: {next_job.description}")
        q.task_done()

# Create worker threads
workers = [
    threading.Thread(target=process_job, args=(q,), daemon=True),
    threading.Thread(target=process_job, args=(q,), daemon=True)
]

# Start threads
for worker in workers:
    worker.start()

q.join()

Key Features

• Thread-safe: Multiple threads can safely access PriorityQueue
• Automatic sorting: Items are automatically ordered by priority
• Blocking operations: get() blocks if queue is empty
• Custom priorities: Use tuples or custom objects with comparison methods

Common Use Cases

• Task scheduling in operating systems
• Job processing in server applications
• Event handling with different urgency levels
• Dijkstra's algorithm for shortest path finding

Conclusion

Priority queues in Python are implemented using queue.PriorityQueue for thread-safe operations. Use tuples for simple priorities or custom classes with comparison methods for complex scenarios. They're essential for any application requiring priority-based processing.