पायथन में प्रायोरिटी क्यू कैसे इम्प्लीमेंट करें

परिचय

queue मॉड्यूल फर्स्ट-इन, फर्स्ट-आउट (FIFO), लास्ट-इन, फर्स्ट-आउट (LIFO) डेटा संरचना प्रदान करता है जो मल्टी-थ्रेडेड प्रोग्रामिंग के लिए उपयुक्त है। क्यू का उपयोग क्रिएटर और कंज्यूमर थ्रेड्स के बीच डेटा या सूचनाओं की विस्तृत श्रृंखला (जैसे सेशन डिटेल्स, पाथ्स, वेरिएबल्स) को सुरक्षित रूप से पास करने के लिए किया जा सकता है। लॉकिंग आमतौर पर कॉलर के लिए हैंडल की जाती है।

1. बेसिक FIFO क्यू इम्प्लीमेंट करें

import queue

fifo = queue.Queue()
# क्यू में नंबर डालें
for i in range(5):
    fifo.put(i)

# अगर खाली नहीं है तो क्यू से नंबर प्राप्त करें
print("Output")
while not fifo.empty():
    print(f" {fifo.get()} ")

आउटपुट: 0 1 2 3 4

2. बेसिक LIFO क्यू इम्प्लीमेंट करें

import queue

lifo = queue.LifoQueue()
for i in range(5):
    lifo.put(i)

print("Output")
while not lifo.empty():
    print(f" {lifo.get()} ")

आउटपुट: 4 3 2 1 0

3. प्रायोरिटी क्यू इम्प्लीमेंट करें

कभी-कभी क्यू में आइटम्स के प्रोसेसिंग ऑर्डर को उन आइटम्स की प्राथमिकता के आधार पर तय करने की आवश्यकता होती है, न कि केवल उस ऑर्डर के आधार पर जिसमें वे बनाए गए या क्यू में जोड़े गए। उदाहरण के लिए, प्रोडक्शन में चल रहा एक बिजनेस-क्रिटिकल जॉब को एक डेवलपर के प्रिंट जॉब पर हाईएस्ट CPU और प्रीसिडेंस की आवश्यकता होती है। PriorityQueue क्यू की सामग्री के सॉर्ट ऑर्डर का उपयोग करके तय करता है कि कौन सा आइटम प्राप्त करना है।

import queue
import threading

# प्राथमिकता और विवरण प्राप्त करने और प्राथमिकता को वैलिडेट करने के लिए क्लास
class Job:
    def __init__(self, priority, description):
        self.priority = priority
        self.description = description
        print('New job:', description)
        return

    def __eq__(self, other):
        try:
            return self.priority == other.priority
        except AttributeError:
            return NotImplemented

    def __lt__(self, other):
        try:
            return self.priority < other.priority
        except AttributeError:
            return NotImplemented

# प्रायोरिटी क्यू बनाएं और प्राथमिकता परिभाषित करें
q = queue.PriorityQueue()
q.put(Job(90, 'Developer-Print job'))
q.put(Job(2, 'Business-Report job'))
q.put(Job(1, 'Business-Critical Job'))

# जॉब प्रोसेस करें
def process_job(q):
    while True:
        next_job = q.get()
        print(f" *** Now, Processing the job - {next_job.description}")
        q.task_done()

# थ्रेड्स परिभाषित करें
workers = [
    threading.Thread(target=process_job, args=(q,)),
    threading.Thread(target=process_job, args=(q,)),
]

# थ्रेड्स कॉल करें और उन्हें जॉइन करें
for w in workers:
    w.setDaemon(True)
    w.start()

q.join()

आउटपुट:

New job: Developer-Print job
New job: Business-Report job
New job: Business-Critical Job
*** Now, Processing the job - Business-Critical Job
*** Now, Processing the job - Business-Report job
*** Now, Processing the job - Developer-Print job

इस उदाहरण में कई थ्रेड्स जॉब्स का उपभोग कर रहे हैं, जिन्हें क्यू में आइटम्स की प्राथमिकता के आधार पर प्रोसेस किया जाता है जब get() कॉल किया गया था। प्रोसेसिंग का ऑर्डर बिजनेस क्रिटिकैलिटी पर आधारित है, इस बात की परवाह किए बिना कि उन्हें किस क्रम में जोड़ा गया है।