] उन्होंने क्रांति ला दी है कि हम समवर्ती संचालन को कैसे संभालते हैं, जिससे स्केलेबल और कुशल अनुप्रयोगों का निर्माण करना आसान हो जाता है। मैंने Coroutines के साथ काम करने में बहुत समय बिताया है, और मैं कस्टम एसिंक्रोनस प्राइमिटिव्स बनाने पर कुछ अंतर्दृष्टि साझा करने के लिए उत्साहित हूं।

चलो मूल बातें के साथ शुरू करते हैं। Coroutines विशेष कार्य हैं जिन्हें रोका जा सकता है और फिर से शुरू किया जा सकता है, जिससे सहकारी मल्टीटास्किंग की अनुमति मिलती है। वे पायथन के async/प्रतीक्षा वाक्यविन्यास की नींव हैं। जब आप एक कोरूटीन को परिभाषित करते हैं, तो आप अनिवार्य रूप से एक फ़ंक्शन बना रहे हैं जो ईवेंट लूप पर वापस नियंत्रण प्राप्त कर सकता है, जिससे अन्य कार्यों को चलाने की अनुमति मिलती है।

] इस विधि को एक पुनरावृत्ति वापस करनी चाहिए। यहाँ एक सरल उदाहरण है:

वर्ग CustomAwaitable: def __init __ (स्व, मूल्य): self.value = मूल्य def __await __ (स्व): उपज स्वयं लौटें async def use_custom_awaitable (): परिणाम = कस्टमॉविटेबल का इंतजार (42) प्रिंट (परिणाम) # आउटपुट: 42

] जब इंतजार किया जाता है, तो यह एक बार नियंत्रण प्राप्त करता है, फिर अपना मान लौटाता है।

लेकिन क्या होगा अगर हम अधिक जटिल अतुल्यकालिक आदिम बनाना चाहते हैं? आइए एक कस्टम सेमाफोर को लागू करने पर ध्यान दें। सेमाफोर का उपयोग कई कोरूटीन्स द्वारा एक साझा संसाधन तक पहुंच को नियंत्रित करने के लिए किया जाता है:

आयात asyncio क्लास कस्टम्समैफोर: def __init __ (स्व, मूल्य = 1): self._value = मान self._waiters = [] Async def अधिग्रहण (स्व): जबकि self._value class CustomAwaitable: def __init__(self, value): self.value = value def __await__(self): yield return self.value async def use_custom_awaitable(): result = await CustomAwaitable(42) print(result) # Output: 42

अब, आइए कुशल ईवेंट लूप बनाने के बारे में बात करते हैं। जबकि पायथन का Asyncio एक मजबूत इवेंट लूप कार्यान्वयन प्रदान करता है, ऐसे मामले हो सकते हैं जहां आपको एक कस्टम की आवश्यकता होती है। यहाँ एक कस्टम इवेंट लूप का एक मूल उदाहरण है:

आयात समय संग्रह आयात डिक से क्लास customeventloop: def __init __ (स्व): self._readry = deque () self._stopping = गलत def call_soon (स्व, कॉलबैक, *args): self._ready.append ((कॉलबैक, args)) def run_forever (स्व): जबकि स्व नहीं है ।_Stopping: self._run_once () def _run_once (स्व): ntodo = len (self._ready) के लिए _ रेंज (ntodo) में: कॉलबैक, args = self._ready.popleft () कॉलबैक (*args) def STOP (स्व): self._stopping = true def run_until_complete (स्व, कोरो): def _done_callback (fut): self.stop () कार्य = self.create_task (कोरो) task.add_done_callback (_done_callback) self.run_forever () वापसी कार्य। result () def create_task (स्व, कोरो): कार्य = कार्य (कोरो, स्व) self.call_soon (task._step) वापसी कार्य क्लास टास्क: def __init __ (स्व, कोरो, लूप): self._coro = कोरो self._loop = लूप self._done = गलत self._result = कोई नहीं self._callbacks = [] def _step (स्व): कोशिश करना: यदि self._done: वापस करना परिणाम = self._coro.send (कोई नहीं) यदि isinstance (परिणाम, नींद के लिए): result._task = स्व self._loop.call_soon (result._wake_up) अन्य: self._loop.call_soon (self._step) ई के रूप में Stopiteration को छोड़कर: self.set_result (e.value) def set_result (स्व, परिणाम): self._result = परिणाम self._done = सत्य Self._callbacks में कॉलबैक के लिए: self._loop.call_soon (कॉलबैक, स्व) def add_done_callback (स्व, कॉलबैक): यदि self._done: self._loop.call_soon (कॉलबैक, स्व) अन्य: self._callbacks.append (कॉलबैक) DEF परिणाम (स्व): यदि स्व नहीं है ।_done: RuntimeError बढ़ाएँ ('कार्य नहीं किया जाता है') स्वयं लौटें क्लास स्लीपहैंडल: def __init __ (स्व, अवधि): self._duration = अवधि self._task = कोई नहीं self._start_time = time.time () def _wake_up (स्व): यदि समय। टाइम () - self._start_time> = self._duration: self._task._loop.call_soon (self._task._step) अन्य: self._task._loop.call_soon (self._wake_up) Async def नींद (अवधि): स्लीपहैंडल लौटें (अवधि) async def उदाहरण (): प्रिंट ("प्रारंभ") नींद की प्रतीक्षा (1) प्रिंट ("1 सेकंड के बाद") नींद की प्रतीक्षा (2) प्रिंट ("2 और सेकंड के बाद") लौटें "किया" लूप = customeventloop () परिणाम = loop.run_until_complete (उदाहरण ()) प्रिंट (परिणाम)

] यह पायथन के अंतर्निहित इवेंट लूप के रूप में फीचर-समृद्ध नहीं है, लेकिन यह मुख्य अवधारणाओं को प्रदर्शित करता है।

import asyncio

class CustomSemaphore:
    def __init__(self, value=1):
        self._value = value
        self._waiters = []

    async def acquire(self):
        while self._value  अतुल्यकालिक कोड लिखने में चुनौतियों में से एक कार्य प्राथमिकताओं का प्रबंधन कर रहा है। जबकि पायथन का Asyncio कार्यों के लिए अंतर्निहित प्राथमिकता कतारों प्रदान नहीं करता है, हम अपने स्वयं के लागू कर सकते हैं: 



 आयात asyncio
आयात हीप

वर्ग प्राथमिकतावेंटलूप (asyncio.abstracteventloop):
    def __init __ (स्व):
        self._ready = []
        self._stopping = गलत
        self._clock = 0

    def call_at (स्व, जब, कॉलबैक, *args, संदर्भ = कोई नहीं):
        हैंडल = asyncio.handle (कॉलबैक, args, स्व, संदर्भ)
        heapq.heappush (self._ready, (जब, संभाल))
        वापसी संभाल

    def call_later (स्व, देरी, कॉलबैक, *args, संदर्भ = कोई नहीं):
        लौटाएं।

    def call_soon (स्व, कॉलबैक, *args, संदर्भ = कोई नहीं):
        लौटाएं।

    def time (स्व):
        स्वयं लौटें

    def STOP (स्व):
        self._stopping = true

    def is_running (स्व):
        स्व नहीं है ।_स्टॉपिंग

    def run_forever (स्व):
        जबकि स्व।
            self._run_once ()

    def _run_once (स्व):
        यदि स्व नहीं है ।_Ready:
            वापस करना
        जब, हैंडल = heapq.heappop (self._ready)
        self._clock = जब
        हैंडल ._run ()

    def create_task (स्व, कोरो):
        Asyncio.task लौटें (कोरो, लूप = स्व)

    def run_until_complete (स्व, भविष्य):
        asyncio.futures._chain_future (भविष्य, self.create_future ())
        self.run_forever ()
        यदि भविष्य नहीं है।
            RuntimeError बढ़ाएँ ('इवेंट लूप फ्यूचर पूरा होने से पहले बंद हो गया।')
        Future.Result ()

    def create_future (स्व):
        Asyncio.future (लूप = स्व) लौटें

async def low_priority_task ():
    प्रिंट ("कम प्राथमिकता कार्य शुरू")
    Asyncio.sleep (2) का इंतजार
    प्रिंट ("कम प्राथमिकता कार्य समाप्त")

async def high_priority_task ():
    प्रिंट ("उच्च प्राथमिकता कार्य शुरू")
    Asyncio.sleep (1) का इंतजार
    प्रिंट ("उच्च प्राथमिकता कार्य समाप्त")

async def main ():
    लूप = asyncio.get_event_loop ()
    loop.call_later (0.1, loop.create_task, low_priority_task ())
    loop.call_later (0, loop.create_task, high_priority_task ())
    Asyncio.sleep (3) का इंतजार

asyncio.run (मुख्य ())




] आप अलग -अलग देरी के साथ कार्यों को शेड्यूल करके प्राथमिकताएं प्रदान कर सकते हैं। 

] यहां एक उदाहरण है कि कैसे रद्द करने योग्य कार्यों को लागू किया जाए: 



 आयात asyncio

async def cancellable_operation ():
    कोशिश करना:
        प्रिंट ("ऑपरेशन शुरू")
        Asyncio.sleep (5) का इंतजार
        प्रिंट ("ऑपरेशन पूरा हुआ")
    सिवाय asyncio.cancellederror:
        प्रिंट ("ऑपरेशन रद्द कर दिया गया था")
        # कोई भी आवश्यक सफाई करें
        # रद्द करें Cancellederror

async def main ():
    कार्य = asyncio.create_task (cancellable_operation ())
    Asyncio.sleep (2) का इंतजार
    task.cancel ()
    कोशिश करना:
        काम का इंतजार करना
    सिवाय asyncio.cancellederror:
        प्रिंट ("मुख्य: कार्य रद्द कर दिया गया था")

asyncio.run (मुख्य ())




] यह रद्द करने की स्थिति का प्रचार करते हुए रद्द करने की सुंदर हैंडलिंग के लिए अनुमति देता है। 
import time
from collections import deque

class CustomEventLoop:
    def __init__(self):
        self._ready = deque()
        self._stopping = False

    def call_soon(self, callback, *args):
        self._ready.append((callback, args))

    def run_forever(self):
        while not self._stopping:
            self._run_once()

    def _run_once(self):
        ntodo = len(self._ready)
        for _ in range(ntodo):
            callback, args = self._ready.popleft()
            callback(*args)

    def stop(self):
        self._stopping = True

    def run_until_complete(self, coro):
        def _done_callback(fut):
            self.stop()

        task = self.create_task(coro)
        task.add_done_callback(_done_callback)
        self.run_forever()
        return task.result()

    def create_task(self, coro):
        task = Task(coro, self)
        self.call_soon(task._step)
        return task

class Task:
    def __init__(self, coro, loop):
        self._coro = coro
        self._loop = loop
        self._done = False
        self._result = None
        self._callbacks = []

    def _step(self):
        try:
            if self._done:
                return
            result = self._coro.send(None)
            if isinstance(result, SleepHandle):
                result._task = self
                self._loop.call_soon(result._wake_up)
            else:
                self._loop.call_soon(self._step)
        except StopIteration as e:
            self.set_result(e.value)

    def set_result(self, result):
        self._result = result
        self._done = True
        for callback in self._callbacks:
            self._loop.call_soon(callback, self)

    def add_done_callback(self, callback):
        if self._done:
            self._loop.call_soon(callback, self)
        else:
            self._callbacks.append(callback)

    def result(self):
        if not self._done:
            raise RuntimeError('Task is not done')
        return self._result

class SleepHandle:
    def __init__(self, duration):
        self._duration = duration
        self._task = None
        self._start_time = time.time()

    def _wake_up(self):
        if time.time() - self._start_time >= self._duration:
            self._task._loop.call_soon(self._task._step)
        else:
            self._task._loop.call_soon(self._wake_up)

async def sleep(duration):
    return SleepHandle(duration)

async def example():
    print("Start")
    await sleep(1)
    print("After 1 second")
    await sleep(2)
    print("After 2 more seconds")
    return "Done"

loop = CustomEventLoop()
result = loop.run_until_complete(example())
print(result)



 वर्ग asyncrange:
    def __init __ (स्व, प्रारंभ, रोक, चरण = 1):
        self.start = प्रारंभ करें
        self.stop = स्टॉप
        self.step = STEP

    def __aiter __ (स्व):
        स्व -वापसी

    async def __anext __ (स्व):
        यदि self.start> = self.stop:
            STOPASynciteration बढ़ाएं
        मान = self.start
        self.start = self.step
        Asyncio.sleep (0.1) का इंतजार करें # कुछ async काम का अनुकरण करें
        वापसी मूल्य

async def main ():
    async i में asyncrange (0, 5):
        प्रिंट (i)

asyncio.run (मुख्य ())




]


 अंत में, आइए कस्टम ASYNC संदर्भ प्रबंधकों को लागू करने पर ध्यान दें। ये उन संसाधनों के प्रबंधन के लिए उपयोगी हैं जिन्हें अधिग्रहित करने और अतुल्यकालिक रूप से जारी करने की आवश्यकता है: 
import asyncio

class CustomSemaphore:
    def __init__(self, value=1):
        self._value = value
        self._waiters = []

    async def acquire(self):
        while self._value  वर्ग asyncresource:
    async def __aenter __ (स्व):
        प्रिंट ("संसाधन प्राप्त करना")
        Asyncio.sleep (1) # Async अधिग्रहण का अनुकरण करें
        स्व -वापसी

    async def __aexit __ (स्व, exc_type, exc, tb):
        प्रिंट ("संसाधन जारी करना")
        Asyncio.sleep (1) # Async रिलीज का अनुकरण करें

async def main ():
    संसाधन के रूप में asyncresource () के साथ async:
        प्रिंट ("संसाधन का उपयोग")
        Asyncio.sleep (1) का इंतजार

asyncio.run (मुख्य ())




]

] अंतर्निहित तंत्र और प्रोटोकॉल को समझकर, आप विशिष्ट एसिंक्रोनस चुनौतियों के लिए अनुरूप समाधान बना सकते हैं, जटिल समवर्ती परिदृश्यों में प्रदर्शन का अनुकूलन कर सकते हैं, और पायथन की async क्षमताओं का विस्तार कर सकते हैं। याद रखें, जबकि ये कस्टम कार्यान्वयन सीखने और विशिष्ट उपयोग के मामलों के लिए महान हैं, पायथन का अंतर्निहित Asyncio लाइब्रेरी अत्यधिक अनुकूलित है और अधिकांश परिदृश्यों के लिए आपका गो-टू होना चाहिए। हैप्पी कोडिंग! 






  
  
  हमारी रचनाएँ


import asyncio

async def cancellable_operation():
    try:
        print("Operation started")
        await asyncio.sleep(5)
        print("Operation completed")
    except asyncio.CancelledError:
        print("Operation was cancelled")
        # Perform any necessary cleanup
        raise  # Re-raise the CancelledError

async def main():
    task = asyncio.create_task(cancellable_operation())
    await asyncio.sleep(2)
    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        print("Main: task was cancelled")

asyncio.run(main())


 
 निवेशक केंद्रीय 
 | 
 स्मार्ट लिविंग 
 | ] ] 
class AsyncRange:
    def __init__(self, start, stop, step=1):
        self.start = start
        self.stop = stop
        self.step = step

    def __aiter__(self):
        return self

    async def __anext__(self):
        if self.start >= self.stop:
            raise StopAsyncIteration
        value = self.start
        self.start  = self.step
        await asyncio.sleep(0.1)  # Simulate some async work
        return value

async def main():
    async for i in AsyncRange(0, 5):
        print(i)

asyncio.run(main())
 | 
 कुलीन देव 
 | 
 JS स्कूल 
 


import asyncio

class CustomSemaphore:
    def __init__(self, value=1):
        self._value = value
        self._waiters = []

    async def acquire(self):
        while self._value 
  
  
  हम माध्यम पर हैं


] ]  निवेशक केंद्रीय माध्यम  | ]  विज्ञान और युग माध्यम  | 
 आधुनिक हिंदुत्व