{"id":4158,"date":"2022-07-19T02:53:39","date_gmt":"2022-07-19T02:53:39","guid":{"rendered":"https:\/\/www.pythontutorial.net\/?page_id=4158"},"modified":"2023-06-03T07:23:49","modified_gmt":"2023-06-03T07:23:49","slug":"python-asyncio-future","status":"publish","type":"page","link":"https:\/\/www.pythontutorial.net\/python-concurrency\/python-asyncio-future\/","title":{"rendered":"Python asyncio Future"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about Python asyncio<\/code> future objects and understand how they work.<\/p>\n\n\n\n

Introduction to the Python asyncio future #<\/a><\/h2>\n\n\n\n

A future is an object that returns a value later in the future but not now. Typically, a future object is the result of an asynchronous operation. <\/p>\n\n\n\n

For example, you may call an API from a remote server and expect to receive the result later. The API call may return a future object so that you can await it.<\/p>\n\n\n\n

To create a future object, you use the Future<\/code> class from the asyncio<\/code> package. Consider the following example:<\/p>\n\n\n

import<\/span> asyncio\nfrom<\/span> asyncio import<\/span> Future\n\n\nasync<\/span> def<\/span> main<\/span>()<\/span>:<\/span>\n    my_future = Future()\n    print(my_future.done())  # False<\/span>\n\n    my_future.set_result('Bright'<\/span>)\n\n    print(my_future.done())  # True<\/span>\n\n    print(my_future.result())\n\n\nasyncio.run(main())<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, import Future<\/code> class from the asyncio<\/code> library:<\/p>\n\n\n
from<\/span> asyncio import<\/span> Future<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Next, create a new Future<\/code> object in the main()<\/code> coroutine:<\/p>\n\n\n
my_future = Future()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
A newly created future doesn’t have any value because it doesn’t exist yet. In this state, the future is considered incomplete, unresolved, or not done. <\/p>\n\n\n\n
Then, call the done()<\/code> method to check the status of the future object:<\/p>\n\n\n
print(my_future.done())  # False<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
It returns False<\/code>.<\/p>\n\n\n\n
After that, set a value for the future object by calling the set_result()<\/code> method:<\/p>\n\n\n
my_future.set_result('Bright'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Once you set the value, the future is done. Calling the done()<\/code> method of the future object in this stage returns True<\/code>:<\/p>\n\n\n
print(my_future.done())  # True<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Finally, get the result from the future object by calling its result()<\/code> method:<\/p>\n\n\n
print(my_future.result())<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Using Python asyncio future with await #<\/a><\/h2>\n\n\n\n
When you use the await<\/code> keyword with a future, you pause the future until it returns a value. The following example shows how to use the future with await<\/code> keyword:<\/p>\n\n\n
from<\/span> asyncio import<\/span> Future\nimport<\/span> asyncio\n\n\nasync<\/span> def<\/span> plan<\/span>(my_future)<\/span>:<\/span>\n    print('Planning my future...'<\/span>)\n    await<\/span> asyncio.sleep(1<\/span>)\n    my_future.set_result('Bright'<\/span>)\n\n\ndef<\/span> create<\/span>()<\/span> -> Future:<\/span>\n    my_future = Future()\n    asyncio.create_task(plan(my_future))\n    return<\/span> my_future\n\n\nasync<\/span> def<\/span> main<\/span>()<\/span>:<\/span>\n    my_future = create()\n    result = await<\/span> my_future\n\n    print(result)\n\n\nasyncio.run(main())<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Planning my future...\nBright<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, define a coroutine that accepts a future and sets its value after 1 second:<\/p>\n\n\n
async<\/span> def<\/span> plan<\/span>(my_future: Future)<\/span>:<\/span>\n    print('Planning my future...'<\/span>)\n    await<\/span> asyncio.sleep(1<\/span>)\n    my_future.set_result('Bright'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Second, define a create()<\/code> function that schedules the plan()<\/code> coroutine as a task and returns a future object:<\/p>\n\n\n
def<\/span> create<\/span>()<\/span> -> Future:<\/span>\n    my_future = Future()\n    asyncio.create_task(plan(my_future))\n    return<\/span> my_future<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Third, call the create()<\/code> function that returns a future, use the await keyword to wait for the future to return a result, and display it:<\/p>\n\n\n
async<\/span> def<\/span> main<\/span>()<\/span>:<\/span>\n    my_future = create()\n    result = await<\/span> my_future\n\n    print(result)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In practice, you’ll rarely need to create Future<\/code> objects directly. However, you’ll use the Future<\/code> objects returned from API. Therefore, it’s important to understand how the Future<\/code> works.<\/p>\n\n\n\n
Futures, Tasks, and Coroutines #<\/a><\/h2>\n\n\n\n
The following class hierarchy shows the relationships between Coroutine<\/a>, Future, and Task<\/a>:<\/p>\n\n\n
\n
\"\"<\/figure>\n<\/div>\n\n\n
In this class hierarchy, Courtine, Future, and Task are subclasses of the Awaitable abstract class.<\/p>\n\n\n\n
The Awaitable<\/code> class has an abstract method __await__()<\/code><\/code>. Any class that has the implementation of the __await__()<\/code><\/code> method can be used with the await keyword. And the objects of classes that can be used with the await<\/code> keyword are called awaitables<\/em>.<\/p>\n\n\n\n
Summary #<\/a><\/h2>\n\n\n\n
    \n
  • A future is an object that returns a value in the future, not now.<\/li>\n\n\n\n
  • Future<\/code>, Coroutine<\/code>, and Task<\/code> are awaitable and their objects can be used with the await<\/code> keyword.<\/li>\n<\/ul>\n
    \n\t
    \n\t\t
    Was this tutorial helpful ?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t