import asyncio
import time

#定义第1个协程，协程就是将要具体完成的任务，该任务耗时3秒，完成后显示任务完成
async def to_do_something(i):
    print('第{}个任务：任务启动...'.format(i))
    #遇到耗时的操作，await就会使任务挂起，继续去完成下一个任务
    await asyncio.sleep(i)
    print('第{}个任务：任务完成！'.format(i))
#定义第2个协程，用于通知任务进行状态
async def mission_running():
    print('任务正在执行...')

start = time.time()
#创建一个循环
loop = asyncio.get_event_loop()
#创建一个任务盒子tasks，包含了3个需要完成的任务
tasks = [asyncio.ensure_future(to_do_something(1)),
         asyncio.ensure_future(to_do_something(2)),
         asyncio.ensure_future(mission_running())]
#tasks接入loop中开始运行
loop.run_until_complete(asyncio.wait(tasks))
end = time.time()
print(end-start)

import asyncio

async def do_some_work(x):  # 使用async关键字定义协程
    print('Waiting: ', x)

coroutine = do_some_work(2)  # 创建协程对象
loop = asyncio.get_event_loop()  # 创建一个事件循环（池）
loop.run_until_complete(coroutine)  # 将协程对象包装并注册协程对象

import time, asyncio

_now = lambda: time.time()

async def work(x):  # 使用async关键字定义协程
    print('Waiting: ', x)

cor = work('hi')
start = _now()
loop = asyncio.get_event_loop()
task = loop.create_task(cor)  # 方法1
# task = asyncio.ensure_future(cor)  # 方法2
loop.run_until_complete(task)
print(_now()-start)

import asyncio

async def work(x):  # 使用async关键字定义协程
    return x+3

def callback(y):
    print(y.result())

cor = work(5)
loop = asyncio.get_event_loop()
task = loop.create_task(cor)  # 方法1
# task = asyncio.ensure_future(cor)  # 方法2
task.add_done_callback(callback)  # 绑定回调函数
loop.run_until_complete(task)  # 运行

import asyncio
import time

async def test():
    # time.sleep(1)  # 传统顺序执行
    await asyncio.sleep(1)  # 开启异步执行
    print(time.time())

tasks = [asyncio.ensure_future(test()) for _ in range(3)]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

import aiohttp, asyncio, time

async def get(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            print(response)

async def request():
    url = 'http://www.baidu.com'
    resulit = await get(url)

_now = lambda : time.time()
start = _now()
tasks = [asyncio.ensure_future(request()) for _ in range(100)]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
print(_now()-start)

import asyncio
from aiohttp import request
from aiomultiprocess import Process

async def put(url, params):
    async with request("PUT", url, params=params) as response:
        pass

async def main():
    p = Process(target=put, args=("https://jreese.sh", ))
    await p

asyncio.run(main())
If you want to get results back from that coroutine, Worker makes that available:

import asyncio
from aiohttp import request
from aiomultiprocess import Worker

async def get(url):
    async with request("GET", url) as response:
        return await response.text("utf-8")

async def main():
    p = Worker(target=get, args=("https://jreese.sh", ))
    response = await p

asyncio.run(main())
If you want a managed pool of worker processes, then use Pool:

import asyncio
from aiohttp import request
from aiomultiprocess import Pool

async def get(url):
    async with request("GET", url) as response:
        return await response.text("utf-8")

async def main():
    urls = ["https://jreese.sh", ...]
    async with Pool() as pool:
        result = await pool.map(get, urls)

asyncio.run(main())