Future object

Future Is a special low-level waiting object (Task yes Future Subclasses of ), Represents the end result of an asynchronous operation
When one Future The object is waiting , This means that the process will remain waiting until Future Object has been operated elsewhere

async def main():
    #  Get the current event loop 
    loop = asyncio.get_running_loop()
    #  Create a task (Future object ),  No behavior is bound by default ,  Then the task will never end 
    fut = loop.create_futute()
    #  Wait until the final result of the task (Future object ),  If there is no result, you will wait all the time 
    await fut

import asyncio

async def set_after(fut):
    await asyncio.sleep(2)
    fut.set_result('666')

async def main():
    loop = asyncio.get_running_loop()
    fut = loop.create_future()

    #  Create a task ,  The binding  set_after  function ,  The function is inside  2s  after ,  Will give  fut  assignment 
    #  Manual settings  future The end result of the mission ,  that  fut  And that's it 
    await loop.create_task(set_after(fut))
    data = await fut
    print(data)

asyncio.run(main())

Future The object itself has no function binding , Want to loop events to get Future Result , You need to set it manually
Task Object inheritance Future Object and extended , It can be implemented after the execution of the corresponding bound function , Automatic execution set_result, In order to achieve automatic end

concurrent.futures

stay python Of concurrent.futures There is also one in the module Future object , This object is used to implement asynchronous operation based on thread pool or process pool

import time
from concurrent.futures import Future
from concurrent.futures.thread import ThreadPoolExecutor

def func(value):
    time.sleep(1)
    print(value)

pool = ThreadPoolExecutor(max_workers=5)

for i in range(1):
    fut = pool.submit(func, i)
    print(fut)

Example : async + requests

(1) Use it directly , The actual form is synchronous request

import asyncio
import requests

async def send_req(url):
    print(f' To request  {
      url}')
    res = requests.get(url).text
    print(res)
    print(f' End of request  {
      url}')
    return res

async def main():
    tasks = [
        asyncio.create_task(send_req('http://httpbin.org/ip')),
        asyncio.create_task(send_req('http://httpbin.org/headers')),
    ]

    await asyncio.wait(tasks)

asyncio.run(main())

(2) run_in_executor Asynchronous requests

import asyncio
import requests
import concurrent.futures


def send_req(url):
    print(f' To request  {
      url}')
    res = requests.get(url).text
    print(res)
    print(f' End of request  {
      url}')
    return res


async def main():
    loop = asyncio.get_running_loop()

    # None,  By default  ThreadPoolExecutor  Thread pool 
    #  First step ： Internal will call first  ThreadPoolExecutor  Of  submit  Method to apply for a thread to execute in the thread pool  send_req  function , And return a concurrent.futures.Future object 
    #  The second step ： call  asyncio.wrap_future  take  concurrent.futures.Future  The object is packaged as  asycio.Future  object 
    tasks = [
        loop.run_in_executor(None, send_req, 'http://httpbin.org/ip'),
        loop.run_in_executor(None, send_req, 'http://httpbin.org/headers')
    ]
    
    await asyncio.wait(tasks)


# concurrent.futures  asynchronous 
async def main():
    loop = asyncio.get_running_loop()

    with concurrent.futures.ThreadPoolExecutor() as pool:
        tasks = [
            loop.run_in_executor(pool, send_req, 'http://httpbin.org/ip'),
            loop.run_in_executor(pool, send_req, 'http://httpbin.org/user-agent'),
        ] 

        await asyncio.wait(tasks)

asyncio.run(main())

When a project is developed with asynchronous programming of a co program , If you want to use a third-party module , When the third-party module does not support asynchronous programming in CO programming mode , You can use this function