Python 3.7 - Coroutines and Tasks

Coroutines और कार्य




python

Coroutines और कार्य

यह खंड कोरटाइन्स और टास्क के साथ काम करने के लिए उच्च-स्तरीय एसिंको एपीआई की रूपरेखा तैयार करता है।

Coroutines

एसिंक्श / वेट सिंटैक्स के साथ घोषित किए गए कोरीटीन, एसिंको एप्लीकेशन लिखने का पसंदीदा तरीका है। उदाहरण के लिए, कोड का निम्नलिखित स्निपेट (पायथन 3.7+ की आवश्यकता है) प्रिंट करता है "हैलो", 1 सेकंड इंतजार करता है, और फिर "दुनिया" प्रिंट करता है:

>>> import asyncio

>>> async def main():
...     print('hello')
...     await asyncio.sleep(1)
...     print('world')

>>> asyncio.run(main())
hello
world

ध्यान दें कि केवल एक coroutine को कॉल करने से इसे निष्पादित नहीं किया जाएगा:

>>> main()
<coroutine object main at 0x1053bb7c8>

वास्तव में एक coroutine asyncio चलाने के लिए तीन मुख्य तंत्र प्रदान करता है:

  • शीर्ष-स्तरीय प्रविष्टि बिंदु "मुख्य ()" फ़ंक्शन को चलाने के लिए asyncio.run() फ़ंक्शन (उपरोक्त उदाहरण देखें)।
  • एक coroutine पर प्रतीक्षा कर रहा है। कोड का निम्नलिखित स्निपेट 1 सेकंड के इंतजार के बाद "हैलो" प्रिंट करेगा, और फिर एक और 2 मिनट के इंतजार के बाद "दुनिया" प्रिंट करेगा:

    import asyncio
    import time
    
    async def say_after(delay, what):
        await asyncio.sleep(delay)
        print(what)
    
    async def main():
        print('started at', time.strftime('%X'))
    
        await say_after(1, 'hello')
        await say_after(2, 'world')
    
        print('finished at', time.strftime('%X'))
    
    asyncio.run(main())
    

    अपेक्षित उत्पादन:

    started at 17:13:52
    hello
    world
    finished at 17:13:55
    
  • asyncio.create_task() फ़ंक्शन को समवर्ती रूप से एसिनसियो Tasks रूप में चलाने के लिए।

    आइए उपरोक्त उदाहरण को संशोधित करें और दो say_after :

    async def main():
        task1 = asyncio.create_task(
            say_after(1, 'hello'))
    
        task2 = asyncio.create_task(
            say_after(2, 'world'))
    
        print('started at', time.strftime('%X'))
    
        # Wait until both tasks are completed (should take
        # around 2 seconds.)
        await task1
        await task2
    
        print('finished at', time.strftime('%X'))
    

    ध्यान दें कि अपेक्षित आउटपुट अब दिखाता है कि स्निपेट पहले की तुलना में 1 सेकंड तेज चलता है:

    started at 17:14:32
    hello
    world
    finished at 17:14:34
    

Awaitables

हम कहते हैं कि एक वस्तु एक await वस्तु है अगर इसे await अभिव्यक्ति में इस्तेमाल किया जा सकता है। कई asyncio API को वेटेबले स्वीकार करने के लिए डिज़ाइन किया गया है।

तीन मुख्य प्रकार की प्रतीक्षा करने योग्य वस्तुएं हैं: कोरटाइन , टास्क और फ्यूचर्स

Coroutines

पायथन कोरआउट्स प्रतीक्षा योग्य हैं और इसलिए अन्य कोरआउट्स से इंतजार किया जा सकता है:

import asyncio

async def nested():
    return 42

async def main():
    # Nothing happens if we just call "nested()".
    # A coroutine object is created but not awaited,
    # so it *won't run at all*.
    nested()

    # Let's do it differently now and await it:
    print(await nested())  # will print "42".

asyncio.run(main())

जरूरी

इस दस्तावेज़ में "कॉरआउट" शब्द का उपयोग दो निकट से संबंधित अवधारणाओं के लिए किया जा सकता है:

  • एक coroutine फ़ंक्शन : एक async def फ़ंक्शन;
  • एक coroutine ऑब्जेक्ट : एक coroutine फ़ंक्शन को कॉल करके लौटी हुई कोई वस्तु।

asyncio विरासत generator-based कोरआउट्स का भी समर्थन करता है।

कार्य

कोरटाइन्स को समवर्ती रूप से शेड्यूल करने के लिए कार्य का उपयोग किया जाता है।

जब एक coroutine asyncio.create_task() जैसे कार्यों के साथ एक टास्क में लपेटा जाता है, तो coroutine स्वचालित रूप से जल्द ही चलने वाला है:

import asyncio

async def nested():
    return 42

async def main():
    # Schedule nested() to run soon concurrently
    # with "main()".
    task = asyncio.create_task(nested())

    # "task" can now be used to cancel "nested()", or
    # can simply be awaited to wait until it is complete:
    await task

asyncio.run(main())

फ्यूचर्स

एक Future एक विशेष निम्न-स्तरीय प्रतीक्षा योग्य वस्तु है जो एक अतुल्यकालिक ऑपरेशन के अंतिम परिणाम का प्रतिनिधित्व करता है।

जब किसी Future Object का इंतजार किया जाता है तो इसका मतलब है कि Coroutine तब तक इंतजार करेगा जब तक कि Future किसी अन्य जगह पर हल नहीं हो जाता।

Asyncio में भविष्य की वस्तुओं को कॉल करने के लिए कोड को async / प्रतीक्षा के साथ उपयोग करने की अनुमति देने की आवश्यकता होती है।

आम तौर पर आवेदन स्तर कोड पर भविष्य की वस्तुओं को बनाने की कोई आवश्यकता नहीं है

भविष्य की वस्तुएं, कभी-कभी पुस्तकालयों और कुछ एसिंसियो एपीआई द्वारा उजागर की जा सकती हैं:

async def main():
    await function_that_returns_a_future_object()

    # this is also valid:
    await asyncio.gather(
        function_that_returns_a_future_object(),
        some_python_coroutine()
    )

एक लो-लेवल फंक्शन का एक अच्छा उदाहरण जो फ्यूचर ऑब्जेक्ट लौटाता है। loop.run_in_executor()

एक एसिंसीओ कार्यक्रम चलाना

asyncio.run(coro, *, debug=False)

यह फ़ंक्शन असिनसियो इवेंट लूप के प्रबंधन और अतुल्यकालिक जनरेटर को अंतिम रूप देने का ख्याल रखते हुए, पारित कोरआउट करता है।

इस फ़ंक्शन को तब नहीं बुलाया जा सकता है जब एक और एसिंसीओ इवेंट लूप एक ही थ्रेड में चल रहा हो।

यदि डीबग True , तो ईवेंट लूप को डीबग मोड में चलाया जाएगा।

यह फ़ंक्शन हमेशा एक नया ईवेंट लूप बनाता है और इसे अंत में बंद कर देता है। यह asyncio कार्यक्रमों के लिए एक मुख्य प्रवेश बिंदु के रूप में इस्तेमाल किया जाना चाहिए, और आदर्श रूप से केवल एक बार बुलाया जाना चाहिए।

संस्करण 3.7 में नया: महत्वपूर्ण: इस फ़ंक्शन को अनंतिम आधार पर पायथन 3.7 में एसिंको से जोड़ा गया है।

कार्य बनाना

asyncio.create_task(coro)

कोरो coroutine को Tasks में लपेटें और इसके निष्पादन को शेड्यूल करें। टास्क ऑब्जेक्ट वापस करें।

कार्य को get_running_loop() द्वारा लौटाए गए लूप में निष्पादित किया जाता है, यदि वर्तमान थ्रेड में कोई रनिंग लूप नहीं है, तो get_running_loop() को उठाया जाता है।

पायथन 3.7 में इस फ़ंक्शन को जोड़ा गया है। पायथन 3.7 से पहले, निम्न-स्तरीय asyncio.ensure_future() फ़ंक्शन का उपयोग इसके बजाय किया जा सकता है:

async def coro():
    ...

# In Python 3.7+
task = asyncio.create_task(coro())
...

# This works in all Python versions but is less readable
task = asyncio.ensure_future(coro())
...

संस्करण 3.7 में नया।

सोया हुआ

coroutine asyncio.sleep(delay, result=None, *, loop=None)

विलंब सेकंड के लिए ब्लॉक करें

यदि परिणाम प्रदान किया जाता है, तो कॉलआउट पूरा होने पर इसे कॉलर को लौटा दिया जाता है।

sleep() हमेशा वर्तमान कार्य को निलंबित करती है, जिससे अन्य कार्यों को चलाने की अनुमति मिलती है।

लूप तर्क को हटा दिया गया है और पाइथन 3.10 में हटाने के लिए निर्धारित है।

5 सेकंड के लिए हर सेकंड वर्तमान तिथि प्रदर्शित करने वाले कोरआउट का उदाहरण:

import asyncio
import datetime

async def display_date():
    loop = asyncio.get_running_loop()
    end_time = loop.time() + 5.0
    while True:
        print(datetime.datetime.now())
        if (loop.time() + 1.0) >= end_time:
            break
        await asyncio.sleep(1)

asyncio.run(display_date())

रनिंग टास्क समवर्ती

awaitable asyncio.gather(*aws, loop=None, return_exceptions=False)

अवाक्स सीक्वेंस में वेटेबल ऑब्जेक्ट्स को समवर्ती रूप से चलाएं।

यदि किसी भी प्रतीक्षारत खिलाड़ी को एक कोरटाइन है, तो यह स्वचालित रूप से टास्क के रूप में निर्धारित किया जाता है।

यदि सभी प्रतीक्षा-योग्यताओं को सफलतापूर्वक पूरा कर लिया गया है, तो परिणाम लौटे हुए मूल्यों की कुल सूची है। परिणाम मानों का क्रम अवाइस में प्रतीक्षा- योग्यताओं के क्रम से मेल खाता है।

यदि return_exception False (डिफ़ॉल्ट), पहले उठाया अपवाद तुरंत उस कार्य के लिए प्रचारित किया जाता है जो gather() पर प्रतीक्षा करता है gather() । अन्य अनुक्रम अनुक्रम में प्रतीक्षा नहीं रद्द किया जाएगा और चलाने के लिए जारी रहेगा।

यदि return_exception True , तो अपवाद को सफल परिणाम के समान माना जाता है, और परिणाम सूची में एकत्र किया जाता है।

यदि gather() रद्द हो गया है , तो सभी सबमिट किए गए प्रतीक्षा-पत्र (जो अभी तक पूरे नहीं हुए हैं) भी रद्द कर दिए गए हैं

यदि किसी भी टास्क या फ्यूचर को aws अनुक्रम से रद्द किया जाता है, तो यह माना जाता है कि यदि उसने CancelledError उठाया - तो इस मामले में कॉल gather() कॉल रद्द नहीं किया गया है। यह एक टास्क / फ्यूचर को रद्द करने से रोकने के लिए है ताकि अन्य टास्क / फ्यूचर्स को रद्द किया जा सके।

उदाहरण:

import asyncio

async def factorial(name, number):
    f = 1
    for i in range(2, number + 1):
        print(f"Task {name}: Compute factorial({i})...")
        await asyncio.sleep(1)
        f *= i
    print(f"Task {name}: factorial({number}) = {f}")

async def main():
    # Schedule three calls *concurrently*:
    await asyncio.gather(
        factorial("A", 2),
        factorial("B", 3),
        factorial("C", 4),
    )

asyncio.run(main())

# Expected output:
#
#     Task A: Compute factorial(2)...
#     Task B: Compute factorial(2)...
#     Task C: Compute factorial(2)...
#     Task A: factorial(2) = 2
#     Task B: Compute factorial(3)...
#     Task C: Compute factorial(3)...
#     Task B: factorial(3) = 6
#     Task C: Compute factorial(4)...
#     Task C: factorial(4) = 24

संस्करण 3.7 में परिवर्तित किया गया: यदि इकट्ठा ही रद्द हो जाता है, तो वापसी रिटर्न की परवाह किए बिना रद्द कर दिया जाता है।

रद्द करने से बचना

awaitable asyncio.shield(aw, *, loop=None)

किसी प्रतीक्षित वस्तु को cancelled होने से बचाएं।

अगर aw एक coroutine है, तो यह स्वतः ही टास्क के रूप में शेड्यूल किया जाता है।

बयान:

res = await shield(something())

के बराबर है:

res = await something()

सिवाय इसके कि यदि कोरटाइन युक्त इसे रद्द कर दिया जाता है, तो something() में चल रहा टास्क रद्द नहीं होता है। something() के दृष्टिकोण से something() , रद्दीकरण नहीं हुआ। हालांकि इसके कॉलर को अभी भी रद्द कर दिया गया है, इसलिए "प्रतीक्षित" अभिव्यक्ति अभी भी एक CancelledError जन्म देती है।

यदि something() अन्य माध्यमों से (यानी अपने भीतर से) रद्द हो जाती है, तो वह भी रद्द कर देगा।

यदि यह रद्द करने (अनुशंसित नहीं) को पूरी तरह से अनदेखा करने के लिए वांछित है, तो shield() फ़ंक्शन को एक प्रयास के साथ जोड़ा जाना चाहिए / खंड को छोड़कर, जैसे:

try:
    res = await shield(something())
except CancelledError:
    res = None

समय समाप्ति

coroutine asyncio.wait_for(aw, timeout, *, loop=None)

टाइम आउट के साथ पूरी होने वाली प्रतीक्षा के लिए प्रतीक्षा करें।

अगर aw एक coroutine है, तो यह स्वतः ही टास्क के रूप में शेड्यूल किया जाता है।

टाइमआउट या तो None हो सकता है या एक फ्लोट या सेकंड की संख्या की प्रतीक्षा कर सकता है। यदि टाइमआउट None , तो भविष्य पूरा होने तक ब्लॉक करें।

यदि कोई समय समाप्त होता है, तो यह कार्य को रद्द करता है और asyncio.TimeoutError

कार्य cancelled करने से बचने के लिए, इसे shield() में लपेटें shield()

फ़ंक्शन प्रतीक्षा करेगा जब तक कि भविष्य वास्तव में रद्द न हो जाए, इसलिए कुल प्रतीक्षा समय मध्यांतर से अधिक हो सकता है।

यदि प्रतीक्षा रद्द हो जाती है, तो भविष्य की aw भी रद्द हो जाती है।

लूप तर्क को हटा दिया गया है और पाइथन 3.10 में हटाने के लिए निर्धारित है।

उदाहरण:

async def eternity():
    # Sleep for one hour
    await asyncio.sleep(3600)
    print('yay!')

async def main():
    # Wait for at most 1 second
    try:
        await asyncio.wait_for(eternity(), timeout=1.0)
    except asyncio.TimeoutError:
        print('timeout!')

asyncio.run(main())

# Expected output:
#
#     timeout!

संस्करण 3.7 में परिवर्तित: जब टाइमआउट के कारण aw को रद्द कर दिया जाता है, तो wait_for को रद्द करने के लिए इंतजार करना पड़ता है। इससे पहले, यह तुरंत asyncio.TimeoutError बढ़ा।

प्रतीक्षारत आदिम

coroutine asyncio.wait(aws, *, loop=None, timeout=None, return_when=ALL_COMPLETED)

अवर्णनीय वस्तुओं को चलाएं aws में समवर्ती रूप से सेट करें और जब तक रिटर्न return_when द्वारा निर्दिष्ट स्थिति तक ब्लॉक न हो जाए

यदि किसी भी प्रतीक्षारत खिलाड़ी को एक कोरटाइन है, तो यह स्वचालित रूप से टास्क के रूप में निर्धारित किया जाता है। कोरटाइन्स ऑब्जेक्ट्स को wait() करने के लिए पास wait() सीधे पदावनत है क्योंकि यह भ्रामक व्यवहार की ओर जाता है।

कार्य / वायदा के दो सेट लौटाता है: (done, pending)

उपयोग:

done, pending = await asyncio.wait(aws)

लूप तर्क को हटा दिया गया है और पाइथन 3.10 में हटाने के लिए निर्धारित है।

समयबाह्य (एक फ्लोट या इंट), यदि निर्दिष्ट किया जाता है, तो लौटने से पहले प्रतीक्षा करने के लिए अधिकतम सेकंड नियंत्रित करने के लिए उपयोग किया जा सकता है।

ध्यान दें कि यह फ़ंक्शन asyncio.TimeoutError नहीं asyncio.TimeoutError । वायदा या कार्य जो टाइमआउट होने पर नहीं किए जाते हैं, बस दूसरे सेट में वापस आ जाते हैं।

return_when इंगित करता है कि यह फ़ंक्शन कब लौटना चाहिए। यह निम्नलिखित में से एक होना चाहिए:

स्थिर विवरण
FIRST_COMPLETED जब कोई भविष्य खत्म या रद्द हो जाएगा तो फ़ंक्शन वापस आ जाएगा।
FIRST_EXCEPTION जब कोई अपवाद समाप्त करके भविष्य समाप्त हो जाता है, तो फ़ंक्शन वापस आ जाएगा। यदि कोई भविष्य अपवाद नहीं उठाता है, तो यह ALL_COMPLETED बराबर है।
ALL_COMPLETED फ़ंक्शन तब वापस आएगा जब सभी वायदा समाप्त हो जाएंगे या रद्द कर दिए जाएंगे।

wait_for() विपरीत, wait() टाइमआउट होने पर वायदा रद्द नहीं करता है।

ध्यान दें

wait() रूप में स्वतः टास्क के रूप में कोरट्यूट शेड्यूल करता है और बाद में उन अंतर्निहित वस्तुओं को टास्क ऑब्जेक्ट (done, pending) सेट में वापस करता है। इसलिए निम्न कोड अपेक्षित रूप से काम नहीं करेगा:

async def foo():
    return 42

coro = foo()
done, pending = await asyncio.wait({coro})

if coro in done:
    # This branch will never be run!

यहाँ बताया गया है कि उपरोक्त स्निपेट कैसे तय किया जा सकता है:

async def foo():
    return 42

task = asyncio.create_task(foo())
done, pending = await asyncio.wait({task})

if task in done:
    # Everything will work as expected now.

wait() करने के लिए कोराउटीन ऑब्जेक्ट्स को पास wait() सीधे पदावनत है।

asyncio.as_completed(aws, *, loop=None, timeout=None)

अवर्णनीय रूप से सेट की गई अवर्णनीय वस्तुओं को चलाएं। Future वस्तुओं का एक पुनरावृत्त लौटें। लौटाया गया प्रत्येक फ्यूचर ऑब्जेक्ट शेष प्रतीक्षा सूची के सेट से सबसे पहले परिणाम का प्रतिनिधित्व करता है।

यदि सभी वायदा करने से पहले टाइमआउट होता है, तो asyncio.TimeoutError उठाता है।

उदाहरण:

for f in as_completed(aws):
    earliest_result = await f
    # ...

अन्य थ्रेड्स से निर्धारण

asyncio.run_coroutine_threadsafe(coro, loop)

दिए गए ईवेंट लूप में एक कोऑउटिन सबमिट करें। सुरक्षित धागा।

किसी अन्य OS थ्रेड से परिणाम के लिए प्रतीक्षा करने के लिए एक concurrent.futures.Future

यह फ़ंक्शन एक अलग ओएस थ्रेड से बुलाया जाना है, जहां ईवेंट लूप चल रहा है। उदाहरण:

# Create a coroutine
coro = asyncio.sleep(1, result=3)

# Submit the coroutine to a given loop
future = asyncio.run_coroutine_threadsafe(coro, loop)

# Wait for the result with an optional timeout argument
assert future.result(timeout) == 3

यदि कोर्आउट में एक अपवाद उठाया जाता है, तो लौटा हुआ भविष्य अधिसूचित किया जाएगा। ईवेंट लूप में कार्य को रद्द करने के लिए भी इसका उपयोग किया जा सकता है:

try:
    result = future.result(timeout)
except asyncio.TimeoutError:
    print('The coroutine took too long, cancelling the task...')
    future.cancel()
except Exception as exc:
    print('The coroutine raised an exception: {!r}'.format(exc))
else:
    print('The coroutine returned: {!r}'.format(result))

प्रलेखन की संक्षिप्तता और बहुस्तरीय अनुभाग देखें।

अन्य asyncio फ़ंक्शन के विपरीत, इस फ़ंक्शन को लूप तर्क को स्पष्ट रूप से पारित करने की आवश्यकता होती है।

संस्करण 3.5.1 में नया।

आत्मनिरीक्षण

asyncio.current_task(loop=None)

वर्तमान में चल रहे Tasks इंस्टेंस पर लौटें, या None भी कार्य नहीं चल रहा है।

यदि लूप None है तो वर्तमान लूप प्राप्त करने के लिए get_running_loop() का उपयोग किया जाता है।

संस्करण 3.7 में नया।

asyncio.all_tasks(loop=None)

लूप द्वारा चलाई गई Tasks ऑब्जेक्ट को अभी तक समाप्त नहीं करने का एक सेट लौटाएं।

यदि लूप None , तो get_running_loop() का उपयोग वर्तमान लूप प्राप्त करने के लिए किया जाता है।

संस्करण 3.7 में नया।

कार्य वस्तु

class asyncio.Task(coro, *, loop=None)

एक Future वस्तु जो पायथन coroutine चलाता है। धागा-सुरक्षित नहीं।

इवेंट लूप में कोरटाइन को चलाने के लिए कार्य का उपयोग किया जाता है। यदि कोई कॉरआउट भविष्य में प्रतीक्षा करता है, तो टास्क कोरटाइन के निष्पादन को निलंबित कर देता है और भविष्य के पूरा होने की प्रतीक्षा करता है। जब फ्यूचर हो जाता है , तो लिपटे हुए कोरटाइन का निष्पादन फिर से शुरू हो जाता है।

इवेंट लूप्स सहकारी शेड्यूलिंग का उपयोग करते हैं: एक इवेंट लूप एक बार में एक टास्क चलाता है। जबकि एक टास्क भविष्य के पूरा होने का इंतजार करता है, इवेंट लूप अन्य कार्य, कॉलबैक चलाता है, या IO संचालन करता है।

कार्य बनाने के लिए उच्च-स्तर के asyncio.create_task() फ़ंक्शन का उपयोग करें, या निम्न-स्तरीय loop.create_task() या asyncio.ensure_future() फ़ंक्शन। कार्य के मैनुअल तात्कालिकता को हतोत्साहित किया जाता है।

किसी रनिंग कार्य को cancelled लिए cancelled विधि का उपयोग करें। इसे कॉल करने से टास्क लिपटे हुए कोरआउट में एक CancelledError अपवाद को फेंकने का कारण होगा। यदि कोई धनवापसी रद्द होने के दौरान भविष्य की वस्तु की प्रतीक्षा कर रहा है, तो भविष्य की वस्तु रद्द कर दी जाएगी।

cancelled() का उपयोग यह जांचने के लिए किया जा सकता है कि क्या टास्क रद्द कर दिया गया था। विधि True यदि लिपटे हुए कॉरटाइन ने CancelledError अपवाद को दबाया नहीं था और वास्तव में रद्द कर दिया गया था।

Tasks Future.set_result() और Future.set_exception() को छोड़कर इसके सभी API के Future से विरासत में मिला है।

कार्य contextvars मॉड्यूल का समर्थन करते हैं। जब एक टास्क बनाया जाता है तो यह वर्तमान संदर्भ की प्रतिलिपि बनाता है और बाद में कॉपी किए गए संदर्भ में अपना कोरआउट चलाता है।

संस्करण 3.7 में परिवर्तित: contextvars मॉड्यूल के लिए जोड़ा गया समर्थन।

cancel()

टास्क को रद्द करने का अनुरोध करें।

यह इवेंट लूप के अगले चक्र पर लिपटे कॉरआउट में फेंकने के लिए एक CancelledError अपवाद की व्यवस्था करता है।

उसके बाद कोरटाइन को एक try साथ अपवाद को दबाकर सफाई करने या यहां तक ​​कि अनुरोध को अस्वीकार करने का मौका मिला है ... finally except CancelledError ... ब्लॉक करें। इसलिए, Future.cancel() विपरीत, cancelled यह गारंटी नहीं देता है कि कार्य रद्द कर दिया जाएगा, हालांकि रद्द करने को पूरी तरह से दबा देना आम नहीं है और सक्रिय रूप से हतोत्साहित किया जाता है।

निम्न उदाहरण दिखाता है कि कैसे धनिये रद्द करने के अनुरोध को रोक सकते हैं:

async def cancel_me():
    print('cancel_me(): before sleep')

    try:
        # Wait for 1 hour
        await asyncio.sleep(3600)
    except asyncio.CancelledError:
        print('cancel_me(): cancel sleep')
        raise
    finally:
        print('cancel_me(): after sleep')

async def main():
    # Create a "cancel_me" Task
    task = asyncio.create_task(cancel_me())

    # Wait for 1 second
    await asyncio.sleep(1)

    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        print("main(): cancel_me is cancelled now")

asyncio.run(main())

# Expected output:
#
#     cancel_me(): before sleep
#     cancel_me(): cancel sleep
#     cancel_me(): after sleep
#     main(): cancel_me is cancelled now
cancelled()

यदि कार्य रद्द हो जाता है तो True लौटें।

जब रद्द करने का अनुरोध किया गया था तब टास्क रद्द कर दिया गया था cancelled और लिपटे हुए कोरटाइन ने cancelled गए CancelledError अपवाद को इसमें फेंक दिया था।

done()

अगर कार्य किया जाता है तो True लौटें।

टास्क तब किया जाता है जब लिपटे हुए कोरटाइन ने या तो मान लौटाया, एक अपवाद उठाया या टास्क रद्द कर दिया गया।

result()

टास्क का परिणाम लौटाएं।

यदि कार्य किया जाता है , तो लिपटे कॉरआउट का परिणाम वापस आ जाता है (या यदि कॉरटाइन ने एक अपवाद उठाया, तो वह अपवाद फिर से उठाया जाता है।)

यदि कार्य को रद्द कर दिया गया है , तो यह विधि एक CancelledError अपवाद को उठाती है।

यदि कार्य का परिणाम अभी तक उपलब्ध नहीं है, तो यह विधि एक InvalidStateError अपवाद उठाती है।

exception()

टास्क के अपवाद को वापस करें।

यदि लिपटे हुए कोरटाइन ने एक अपवाद उठाया कि अपवाद वापस आ गया है। यदि लिपटे हुए कोरआउट सामान्य रूप से लौटते हैं, तो यह विधि None लौटाती है।

यदि कार्य को रद्द कर दिया गया है , तो यह विधि एक CancelledError अपवाद को उठाती है।

यदि कार्य अभी तक नहीं किया गया है, तो यह विधि एक InvalidStateError अपवाद उठाती है।

add_done_callback(callback, *, context=None)

टास्क पूरा होने पर कॉलबैक जोड़ें।

इस पद्धति का उपयोग केवल निम्न-स्तरीय कॉलबैक-आधारित कोड में किया जाना चाहिए।

अधिक विवरण के लिए Future.add_done_callback() का प्रलेखन देखें।

remove_done_callback(callback)

कॉलबैक सूची से कॉलबैक निकालें।

इस पद्धति का उपयोग केवल निम्न-स्तरीय कॉलबैक-आधारित कोड में किया जाना चाहिए।

अधिक विवरण के लिए Future.remove_done_callback() का प्रलेखन देखें।

get_stack(*, limit=None)

इस कार्य के लिए स्टैक फ़्रेमों की सूची लौटाएँ।

यदि लिपटे कॉरआउट नहीं किया जाता है, तो यह स्टैक वापस करता है जहां इसे निलंबित कर दिया गया है। यदि कोरआउट सफलतापूर्वक पूरा हो गया है या रद्द कर दिया गया है, तो यह एक खाली सूची देता है। यदि कोरआउट एक अपवाद द्वारा समाप्त किया गया था, तो यह ट्रेसबैक फ़्रेम की सूची लौटाता है।

तख्ते हमेशा सबसे पुराने से नवीनतम करने के लिए आदेश दिया है।

निलंबित कोरआउट के लिए केवल एक स्टैक फ्रेम वापस किया जाता है।

वैकल्पिक सीमा तर्क अधिकतम फ्रेम की संख्या को वापस सेट करता है; डिफ़ॉल्ट रूप से सभी उपलब्ध फ़्रेम वापस आ जाते हैं। लौटी हुई सूची का क्रम इस बात पर निर्भर करता है कि स्टैक या ट्रेसबैक लौटाया गया है: स्टैक के सबसे नए फ्रेम वापस आ जाते हैं, लेकिन ट्रेसबैक के सबसे पुराने फ्रेम वापस आ जाते हैं। (यह ट्रेसबैक मॉड्यूल के व्यवहार से मेल खाता है।)

print_stack(*, limit=None, file=None)

इस टास्क के लिए स्टैक या ट्रेसबैक प्रिंट करें।

यह get_stack() द्वारा पुनर्प्राप्त फ़्रेम के लिए ट्रेसबैक मॉड्यूल के समान आउटपुट उत्पन्न करता है।

सीमा तर्क get_stack() सीधे पारित किया जाता है।

फ़ाइल तर्क एक I / O स्ट्रीम है जिस पर आउटपुट लिखा जाता है; डिफ़ॉल्ट आउटपुट द्वारा sys.stderr को लिखा जाता है।

classmethod all_tasks(loop=None)

इवेंट लूप के लिए सभी कार्यों का एक सेट लौटें।

डिफ़ॉल्ट रूप से वर्तमान ईवेंट लूप के सभी कार्य वापस कर दिए जाते हैं। यदि लूप None , तो get_event_loop() फ़ंक्शन का उपयोग वर्तमान लूप प्राप्त करने के लिए किया जाता है।

यह विधि पदावनत है और इसे पायथन 3.9 में हटा दिया जाएगा। इसके बजाय asyncio.all_tasks() फ़ंक्शन का उपयोग करें।

classmethod current_task(loop=None)

वर्तमान में चल रहे कार्य को लौटाएं या None

यदि लूप None , तो get_event_loop() फ़ंक्शन का उपयोग वर्तमान लूप प्राप्त करने के लिए किया जाता है।

यह विधि पदावनत है और इसे पायथन 3.9 में हटा दिया जाएगा। इसके बजाय asyncio.current_task() फ़ंक्शन का उपयोग करें।

जनरेटर-आधारित Coroutines

ध्यान दें

जनरेटर-आधारित कोराउटाइन के लिए समर्थन को पदावनत किया गया है और इसे पायथन 3.10 में हटाने के लिए निर्धारित किया गया है।

जेनरेटर-आधारित कोरटाइन्स, एसिंक्स / प्रतीक्षित वाक्यविन्यास की भविष्यवाणी करते हैं। वे पाइथन जेनरेटर हैं जो फ़्यूचर्स और अन्य कोराउटीन पर प्रतीक्षा करने के लिए अभिव्यक्ति yield from उपयोग करते हैं।

जेनरेटर आधारित @asyncio.coroutine को @asyncio.coroutine सजाया जाना चाहिए, हालांकि यह लागू नहीं है।

@asyncio.coroutine

जनरेटर-आधारित कोराउटाइन को चिह्नित करने के लिए डेकोरेटर।

यह डेकोरेटर विरासत जनरेटर आधारित कोरटाइन को एसिंक्स / वेट कोड के साथ संगत करने में सक्षम बनाता है:

@asyncio.coroutine
def old_style_coroutine():
    yield from asyncio.sleep(1)

async def main():
    await old_style_coroutine()

यह डेकोरेटर पदावनत है और अजगर 3.10 में हटाने के लिए निर्धारित है।

इस डेकोरेटर को async def कॉरआउट्स के लिए इस्तेमाल नहीं किया जाना चाहिए।

asyncio.iscoroutine(obj)

True अगर obj एक coroutine है तो लौटें।

यह विधि inspect.iscoroutine() से अलग है। inspect.iscoroutine() क्योंकि यह जनरेटर-आधारित inspect.iscoroutine() लिए True

asyncio.iscoroutinefunction(func)

True अगर फंक एक coroutine

यह विधि inspect.iscoroutinefunction() से अलग है, क्योंकि यह @asyncio.coroutine सजाए गए जनरेटर-आधारित @asyncio.coroutine कार्यों के लिए @asyncio.coroutine