Python 3.7

Futures




python

Futures

भविष्य की वस्तुओं का उपयोग निम्न-स्तरीय कॉलबैक-आधारित कोड को उच्च-स्तरीय async / प्रतीक्षा कोड के साथ करने के लिए किया जाता है।

भविष्य के कार्य

asyncio.isfuture(obj)

True अगर obj या तो वापस लौटें:

  • asyncio.Future का एक उदाहरण,
  • asyncio.Task का एक उदाहरण,
  • _asyncio_future_blocking विशेषता के साथ भविष्य जैसी वस्तु।

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

asyncio.ensure_future(obj, *, loop=None)

वापसी:

  • obj तर्क जैसा है, यदि obj एक asyncio.Future , एक asyncio.Task , या एक isfuture() जैसा ऑब्जेक्ट ( isfuture() परीक्षण के लिए उपयोग किया जाता है।)
  • एक asyncio.Task ऑब्जेक्ट iscoroutine() है, अगर iscoroutine() एक iscoroutine() परीक्षण के लिए उपयोग किया जाता है।)
  • asyncio.Task ऑब्जेक्ट जो obj पर प्रतीक्षा करता है, यदि obj एक inspect.isawaitable() परीक्षण के लिए उपयोग किया जाता है।)

यदि obj एक से अधिक नहीं है तो TypeError उठाया जाता है।

जरूरी

create_task() फ़ंक्शन भी देखें जो नए कार्य बनाने के लिए पसंदीदा तरीका है।

संस्करण 3.5.1 में परिवर्तित: फ़ंक्शन किसी भी awaitable वस्तु को स्वीकार करता है।

asyncio.wrap_future(future, *, loop=None)

एक concurrent.futures.Future लपेटें। एक asyncio.Future वस्तु में asyncio.Future वस्तु।

भविष्य की वस्तु

class asyncio.Future(*, loop=None)

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

भविष्य एक awaitable वस्तु है। Coroutines भविष्य की वस्तुओं का तब तक इंतजार कर सकते हैं जब तक कि उनके पास परिणाम या अपवाद सेट न हो, या जब तक वे रद्द न हो जाएं।

आमतौर पर फ्यूचर्स का उपयोग निम्न-स्तरीय कॉलबैक-आधारित कोड को सक्षम करने के लिए किया जाता है (जैसे कि एसिंको transports का उपयोग करके कार्यान्वित प्रोटोकॉल) में उच्च-स्तरीय एसिंक्स / वेट कोड के साथ इंटरऑपरेट करना।

अंगूठे का नियम उपयोगकर्ता-फेसिंग एपीआई में भविष्य की वस्तुओं को कभी उजागर नहीं करना है, और फ्यूचर ऑब्जेक्ट बनाने के लिए अनुशंसित तरीका loop.create_future() को कॉल loop.create_future() । इस तरह से वैकल्पिक ईवेंट लूप कार्यान्वयन एक भविष्य की वस्तु के अपने स्वयं के अनुकूलित कार्यान्वयन को इंजेक्ट कर सकते हैं।

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

result()

भविष्य का परिणाम लौटाएं।

यदि Future हो चुका है और set_result() विधि द्वारा सेट किया गया है, तो परिणाम मान वापस आ गया है।

यदि Future हो गया है और set_exception() विधि द्वारा सेट किया गया अपवाद है, तो यह विधि अपवाद को उठाती है।

यदि भविष्य रद्द कर दिया गया है , तो यह विधि एक CancelledError अपवाद छोड़ देती है।

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

set_result(result)

भविष्य को चिह्नित करें और उसका परिणाम निर्धारित करें।

यदि भविष्य में पहले से ही एक InvalidStateError त्रुटि उठाता है

set_exception(exception)

भविष्य को चिह्नित करें और एक अपवाद सेट करें।

यदि भविष्य में पहले से ही एक InvalidStateError त्रुटि उठाता है

done()

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

यदि यह रद्द कर दिया गया था या इसके परिणाम या set_result() या set_exception() कॉल के साथ अपवाद है, तो एक भविष्य किया जाता है

cancelled()

अगर भविष्य रद्द कर दिया गया था तो वापस लौटें।

विधि का उपयोग आमतौर पर यह जांचने के लिए किया जाता है कि कोई परिणाम निर्धारित करने से पहले रद्द नहीं किया जाता है या इसके लिए कोई अपवाद नहीं है:

if not fut.cancelled():
    fut.set_result(42)
add_done_callback(callback, *, context=None)

फ्यूचर हो जाने पर चलाने के लिए कॉलबैक जोड़ें।

कॉलबैक को फ्यूचर ऑब्जेक्ट के साथ एकमात्र तर्क के रूप में कहा जाता है।

यदि यह विधि कहा जाता है, तो Future पहले से ही है , कॉलबैक loop.call_soon() साथ निर्धारित है।

एक वैकल्पिक कीवर्ड-केवल संदर्भ तर्क एक कस्टम संदर्भ को निर्दिष्ट करने की अनुमति देता है। कॉलबैक को चलाने के लिए contextvars.Context । वर्तमान संदर्भ का उपयोग तब किया जाता है जब कोई संदर्भ प्रदान नहीं किया जाता है।

functools.partial() का उपयोग कॉलबैक में मापदंडों को पारित करने के लिए किया जा सकता है, उदाहरण के लिए:

# Call 'print("Future:", fut)' when "fut" is done.
fut.add_done_callback(
    functools.partial(print, "Future:"))

संस्करण 3.7 में परिवर्तित: संदर्भ कीवर्ड-केवल पैरामीटर जोड़ा गया था। अधिक विवरण के लिए पीईपी 567 देखें।

remove_done_callback(callback)

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

हटाए गए कॉलबैक की संख्या लौटाता है, जो आम तौर पर 1 होता है, जब तक कि कॉलबैक को एक से अधिक बार नहीं जोड़ा जाता।

cancel()

भविष्य रद्द करें और कॉलबैक शेड्यूल करें।

यदि फ्यूचर पहले से ही हो गया है या रद्द हो गया है , तो False लौटें। अन्यथा, भविष्य की स्थिति को रद्द करने , कॉलबैक को शेड्यूल करने और True वापस करने के लिए True

exception()

इस Future पर सेट किया गया अपवाद वापस करें।

अपवाद (या यदि कोई अपवाद सेट नहीं किया गया था) केवल तभी लौटाया जाता है जब भविष्य किया जाता है

यदि भविष्य रद्द कर दिया गया है , तो यह विधि एक CancelledError अपवाद छोड़ देती है।

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

get_loop()

ईवेंट लूप लौटाएं भविष्य की वस्तु के लिए बाध्य है।

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

यह उदाहरण एक फ्यूचर ऑब्जेक्ट बनाता है, भविष्य के लिए परिणाम सेट करने के लिए एक अतुल्यकालिक टास्क बनाता है और शेड्यूल करता है, और तब तक इंतजार करता है जब तक कि भविष्य का परिणाम न हो:

async def set_after(fut, delay, value):
    # Sleep for *delay* seconds.
    await asyncio.sleep(delay)

    # Set *value* as a result of *fut* Future.
    fut.set_result(value)

async def main():
    # Get the current event loop.
    loop = asyncio.get_running_loop()

    # Create a new Future object.
    fut = loop.create_future()

    # Run "set_after()" coroutine in a parallel Task.
    # We are using the low-level "loop.create_task()" API here because
    # we already have a reference to the event loop at hand.
    # Otherwise we could have just used "asyncio.create_task()".
    loop.create_task(
        set_after(fut, 1, '... world'))

    print('hello ...')

    # Wait until *fut* has a result (1 second) and print it.
    print(await fut)

asyncio.run(main())

जरूरी

फ्यूचर ऑब्जेक्ट को concurrent.futures.Future m.futures के लिए डिज़ाइन किया गया था। concurrent.futures.Future । मुख्य अंतर में शामिल हैं: