Bagaimana untuk menggunakan modul async Python

Coroutine, juga dikenali sebagai benang mikro, ialah teknologi untuk penukaran konteks dalam mod pengguna. Ringkasnya, ia sebenarnya adalah urutan untuk melaksanakan blok kod untuk bertukar antara pelaksanaan

Sokongan Python untuk coroutine dilaksanakan melalui penjana.

Dalam penjana, kita bukan sahaja boleh melelaran melalui gelung for, tetapi juga terus memanggil fungsi next() untuk mendapatkan nilai seterusnya yang dikembalikan oleh pernyataan hasil. Hasil Python bukan sahaja boleh digunakan untuk mengembalikan nilai, tetapi juga boleh menerima parameter yang diluluskan oleh pemanggil.

1. Apakah itu penjana

Mekanisme yang dipanggil penjana dalam Python dikira semasa menggelung. Dengan memberikan algoritma dan kemudian mengira nilai sebenar semasa panggilan.

Apabila anda perlu mendapatkan nilai daripada penjana, anda boleh menggunakan next(), tetapi secara amnya gunakan gelung for untuk mendapatkannya.

penjana kaedah pelaksanaan penjana, gunakan () untuk mewakili

seperti: [1, 2, 3, 4, 5], kaedah penjana:

data = [1, 2, 3, 4, 5]
(x * x for x in len(data))

definisi fungsi Dalam sesetengah senario dengan logik yang kompleks, ia tidak sesuai untuk menggunakan kaedah pertama, jadi terdapat cara untuk menentukan fungsi jenis, seperti:

def num(x):
    while (x < 10):
        print(x * x)
        x += 1
g = num(1)
for item in g:
    print(item)

Apabila hasil muncul dalam fungsi, ia menjadi penjana

def num(x):
    while (x < 10):
        yield x * x  # 返回结果，下次从这个地方继续？
        x += 1
g = num(1)  # 返回的是generator对象
for item in g:
    print(item)

menjadi fungsi penjana, yang dilaksanakan setiap kali next() dipanggil. Ia kembali apabila menemui pernyataan hasil Apabila dilaksanakan semula, pelaksanaan diteruskan daripada pernyataan hasil yang dikembalikan pada kali terakhir.

2. Gunakan asyncio untuk melaksanakan io asynchronous

io asynchronous dilaksanakan melalui fungsi gelung acara dan coroutine

Gelung acara sentiasa memantau tugasan dalaman dan melaksanakannya jika wujud; tugas Dibahagikan kepada boleh laku dan laksanakan gelung acara menentukan tugasan pemprosesan Jika senarai tugasan kosong, acara ditamatkan.

import asyncio
# 生成或获取事件循环对象loop;类比Java的Netty，我理解为开启一个selector
loop = asyncio.get_event_loop()  
# 将协程函数（任务）提交到事件循环的任务列表中，协程函数执行完成之后终止。
# run_until_complete 会检查协程函数的运行状态,并执行协程函数
loop.run_until_complete( func() )

demo ujian

import asyncio
import time
async def test():
    print("io等待")
    await asyncio.sleep(1)
    return 'hello'
async def hello():
    print("Hello world")
    r = await test()
    print("hello again")
loop = asyncio.get_event_loop()
tasks = [hello(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

Fungsi Coroutine: fungsi yang diubah suai oleh async def; berbanding dengan def biasa, seperti def func(), anda boleh The nilai yang dikembalikan oleh fungsi diterima secara langsung tetapi untuk fungsi coroutine, objek coroutine dikembalikan.

Untuk menjalankan fungsi coroutine, anda perlu menyerahkan objek ini ke gelung acara untuk diproses.

# 测试协程
import asyncio
import time, datetime
# 异步函数不同于普通函数，调用普通函数会得到返回值
# 而调用异步函数会得到一个协程对象。我们需要将协程对象放到一个事件循环中才能达到与其他协程对象协作的效果
# 因为事件循环会负责处理子程 序切换的操作。
async def Print():
    return "hello"
loop = asyncio.get_event_loop()
loop.run_until_complete(Print)

menunggu:

Penggunaan: respons = menunggu + objek yang boleh ditunggu

Objek yang boleh ditunggu: objek coroutine, Masa Depan, Objek tugas boleh difahami Menunggu IO

tindak balas: Keputusan menunggu akan menggantung coroutine semasa (tugas) apabila menghadapi operasi IO Apabila coroutine semasa digantung, gelung acara boleh melaksanakan coroutine lain (tugasan). objek ialah objek coroutine, ia menjadi bersiri Jika ia adalah objek Tugas, objek Tugasan berjalan serentak boleh ditambah ke senarai gelung acara. Anda boleh menggunakan `asyncio.create_task()` untuk mencipta objek `Task` dan parameter yang diluluskan ialah objek coroutine

import asyncio
import time, datetime
async def display(num):
    pass
tasks = []
for num in range(10):
    tasks.append(display(num))  # 生成任务列表
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

asnyc dan tunggu ialah sintaks baharu, versi lama ialah: @asyncio.coroutine dan hasil daripada

3. aiohttp

asyncio boleh melaksanakan operasi IO serentak berbenang tunggal. Jika ia hanya digunakan pada sisi pelanggan, ia tidak akan menjadi sangat berkuasa. Jika asyncio digunakan pada bahagian pelayan, seperti pelayan web, memandangkan sambungan HTTP adalah operasi IO, benang tunggal + coroutine boleh digunakan untuk mencapai sokongan serentak tinggi untuk berbilang pengguna.

aiohttp ialah rangka kerja HTTP berdasarkan asyncio.

Anda boleh menghantar mendapatkan permintaan seperti permintaan

Anda boleh menentukan parameter yang akan dihantar melalui parameter params

async def fetch(session):
    async with session.get("http://localhost:10056/test/") as response:
        data = json.loads(await response.text())
        print(data["data"])

Permintaan pos

• Laksanakan dua tugas secara tak segerak

• Dalam permintaan rangkaian, permintaan ialah sesi dan aiohttp menggunakan ClientSession untuk mengurus sesi

• Gunakan session.method untuk menghantar permintaan

• Untuk respons maklumat respons, gunakan status untuk mendapatkan kod status respons, dan teks() untuk mendapatkan kandungan respons anda boleh menentukan format pengekodan dalam teks(). Sebelum menunggu keputusan respons, anda perlu menambah kata kunci await

Atas ialah kandungan terperinci Bagaimana untuk menggunakan modul async Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!