`asyncio` — asynkron I/O-schemaläggare¶

Denna modul tillhandahåller en schemaläggare för kooperativ multikörning av async/await-koroutiner, tillsammans med primitiver för synkronisering (lås, händelser) och icke-blockerande TCP-nätverk via strömläsare och strömskrivare. Uppgifter körs samtidigt på en enda händelseslinga; den uppgift som körs just nu lämnar tillbaka kontrollen till slingan med await.

Exempel:

import asyncio

async def blink(led, period_ms):
    while True:
        led.on()
        await asyncio.sleep_ms(5)
        led.off()
        await asyncio.sleep_ms(period_ms)

async def main(led1, led2):
    asyncio.create_task(blink(led1, 700))
    asyncio.create_task(blink(led2, 400))
    await asyncio.sleep_ms(10_000)

# Running on an OpenMV Cam
from machine import LED
asyncio.run(main(LED(1), LED(2)))

Kärnfunktioner¶

asyncio.create_task(coro: Coroutine) → Task¶

Skapa en ny uppgift från den angivna koroutinen och schemalägg den för körning.

Returnerar motsvarande Task-objekt.

asyncio.current_task() → Task¶: Returnerar det Task-objekt som hör till den uppgift som körs just nu.

asyncio.run(coro: Coroutine) → Any¶

Skapa en ny uppgift från den angivna koroutinen och kör den tills den är klar.

Returnerar värdet som returneras av coro.

asyncio.sleep(t: float) → None¶

Sov i t sekunder (kan vara ett flyttal).

Detta är en koroutin.

asyncio.sleep_ms(t: int) → None¶

Sov i t millisekunder.

Detta är en koroutin och en MicroPython-utökning.

Ytterligare funktioner¶

asyncio.wait_for(awaitable: Awaitable, timeout: float) → Any¶

Vänta på att awaitable ska bli klar, men avbryt den om den tar längre tid än timeout sekunder. Om awaitable inte är en uppgift kommer en uppgift att skapas från den.

Om en tidsgräns överskrids avbryts uppgiften och asyncio.TimeoutError utlöses: detta bör fångas av anroparen. Uppgiften tar emot asyncio.CancelledError som kan ignoreras eller fångas med try...except eller try...finally för att köra uppstädningskod.

Returnerar returvärdet för awaitable.

Detta är en koroutin.

asyncio.wait_for_ms(awaitable: Awaitable, timeout: int) → Any¶

Liknar wait_for() men timeout är ett heltal i millisekunder.

Detta är en koroutin och en MicroPython-utökning.

asyncio.gather(*awaitables, return_exceptions: bool = False) → List¶

Kör alla awaitables samtidigt. Alla awaitables som inte är uppgifter befordras till uppgifter.

Returnerar en lista med returvärden för alla awaitables.

Detta är en koroutin.

class Task¶

class asyncio.Task¶

Detta objekt kapslar in en koroutin i en körande uppgift. Uppgifter kan väntas på med await task, vilket väntar på att uppgiften ska bli klar och returnerar uppgiftens returvärde.

Uppgifter bör inte skapas direkt, använd istället create_task() för att skapa dem.

cancel() → None¶: Avbryt uppgiften genom att injicera asyncio.CancelledError i den. Uppgiften kan ignorera detta undantag. Uppstädningskod kan köras genom att fånga det, eller via try ... finally.

class Event¶

class asyncio.Event¶

Skapa en ny händelse som kan användas för att synkronisera uppgifter. Händelser startar i det rensade tillståndet.

is_set() → bool¶: Returnerar True om händelsen är satt, annars False.

set() → None¶

Sätt händelsen. Alla uppgifter som väntar på händelsen schemaläggs för körning.

Obs: Detta måste anropas inifrån en uppgift. Det är inte säkert att anropa detta från ett IRQ, ett schemaläggar-återanrop eller en annan tråd. Se ThreadSafeFlag.

clear() → None¶: Rensa händelsen.

wait() → None¶

Vänta på att händelsen ska sättas. Om händelsen redan är satt returnerar den omedelbart.

Detta är en koroutin.

class ThreadSafeFlag¶

class asyncio.ThreadSafeFlag¶

Skapa en ny flagga som kan användas för att synkronisera en uppgift med kod som körs utanför asyncio-slingan, såsom andra trådar, IRQ:er eller schemaläggar-återanrop. Flaggor startar i det rensade tillståndet.

set() → None¶: Sätt flaggan. Om det finns en uppgift som väntar på flaggan schemaläggs den för körning.

clear() → None¶: Rensa flaggan. Detta kan användas för att säkerställa att en eventuellt tidigare satt flagga är rensad innan man väntar på den.

wait() → None¶

Vänta på att flaggan ska sättas. Om flaggan redan är satt returnerar den omedelbart. Flaggan återställs automatiskt vid återkomst från wait.

En flagga kan endast väntas på av en enda uppgift åt gången.

Detta är en koroutin.

class Lock¶

class asyncio.Lock¶

Skapa ett nytt lås som kan användas för att koordinera uppgifter. Lås startar i det olåsta tillståndet.

Förutom metoderna nedan kan lås användas i en async with-sats.

locked() → bool¶: Returnerar True om låset är låst, annars False.

acquire() → bool¶

Vänta på att låset ska vara i det olåsta tillståndet och lås det sedan på ett atomärt sätt. Endast en uppgift kan ta låset åt gången.

Detta är en koroutin.

release() → None¶: Släpp låset. Om några uppgifter väntar på låset schemaläggs nästa i kön för körning och låset förblir låst. Annars väntar inga uppgifter och låset blir olåst.

TCP-strömanslutningar¶

asyncio.open_connection(host: str, port: int, ssl: ssl.SSLContext | bool | None = None) → Tuple[Stream, Stream]¶

Öppna en TCP-anslutning till den angivna host och port. Adressen host kommer att slås upp med socket.getaddrinfo(), vilket för närvarande är ett blockerande anrop. Om ssl är ett ssl.SSLContext-objekt används denna kontext för att skapa transporten; om ssl är True används en standardkontext.

Returnerar ett par strömmar: en läsarström och en skrivarström. Utlöser ett socket-specifikt OSError om värden inte kunde slås upp eller om anslutningen inte kunde upprättas.

Detta är en koroutin.

asyncio.start_server(callback: Callable, host: str, port: int, backlog: int = 5, ssl: ssl.SSLContext | None = None) → Server¶

Starta en TCP-server på den angivna host och port. callback kommer att anropas med inkommande, accepterade anslutningar och tar emot 2 argument: läsar- och skrivarströmmar för anslutningen.

Om ssl är ett ssl.SSLContext-objekt används denna kontext för att skapa transporten.

Returnerar ett Server-objekt.

Detta är en koroutin.

class asyncio.Stream¶

Detta representerar en TCP-strömanslutning. För att minimera kod implementerar denna klass både en läsare och en skrivare, och både StreamReader och StreamWriter är alias för denna klass.

get_extra_info(v: str) → Any¶: Hämta extra information om strömmen, given av v. De giltiga värdena för v är: peername.

close() → None¶: Stäng strömmen.

wait_closed() → None¶

Vänta på att strömmen ska stängas.

Detta är en koroutin.

read(n: int = -1) → bytes¶

Läs upp till n byte och returnera dem. Om n inte anges eller är -1 läses alla byte fram till EOF. Det returnerade värdet blir ett tomt bytes-objekt om EOF påträffas innan några byte har lästs.

Detta är en koroutin.

readinto(buf: bytearray | memoryview) → int¶

Läs upp till n byte in i buf där n är lika med längden på buf.

Returnerar antalet byte som lästs in i buf.

Detta är en koroutin och en MicroPython-utökning.

readexactly(n: int) → bytes¶

Läs exakt n byte och returnera dem som ett bytes-objekt.

Utlöser ett EOFError-undantag om strömmen tar slut innan n byte har lästs.

Detta är en koroutin.

readline() → bytes¶

Läs en rad och returnera den.

Detta är en koroutin.

write(buf: bytes) → None¶: Lägg till buf i utgångsbufferten. Datan töms först när Stream.drain() anropas. Det rekommenderas att anropa Stream.drain() omedelbart efter anrop av denna funktion.

drain() → None¶

Töm (skriv ut) all buffrad utdata till strömmen.

Detta är en koroutin.

class asyncio.Server¶

Detta representerar serverklassen som returneras från start_server(). Den kan användas i en async with-sats för att stänga servern vid utgång.

close() → None¶: Stäng servern.

wait_closed() → None¶

Vänta på att servern ska stängas.

Detta är en koroutin.

Händelseslinga¶

asyncio.get_event_loop() → Loop¶: Returnerar händelseslingan som används för att schemalägga och köra uppgifter. Se Loop.

asyncio.new_event_loop() → Loop¶

Återställ händelseslingan och returnera den.

Obs: eftersom MicroPython endast har en enda händelseslinga återställer denna funktion bara slingans tillstånd, den skapar inte en ny.

class asyncio.Loop¶

Detta representerar objektet som schemalägger och kör uppgifter. Det kan inte skapas, använd get_event_loop() istället.

create_task(coro: Coroutine) → Task¶: Skapa en uppgift från den angivna coro och returnera det nya Task-objektet.

run_forever() → None¶: Kör händelseslingan tills stop() anropas.

run_until_complete(awaitable: Awaitable) → Any¶: Kör den angivna awaitable tills den är klar. Om awaitable inte är en uppgift kommer den att befordras till en.

stop() → None¶: Stoppa händelseslingan.

close() → None¶: Stäng händelseslingan.

set_exception_handler(handler: Callable) → None¶: Ange undantagshanteraren som ska anropas när en Task utlöser ett undantag som inte fångas. handler bör ta emot två argument: (loop, context).

get_exception_handler() → Callable | None¶: Hämta den aktuella undantagshanteraren. Returnerar hanteraren, eller None om ingen anpassad hanterare är angiven.

default_exception_handler(context: dict) → None¶: Standardundantagshanteraren som anropas.

call_exception_handler(context: dict) → None¶: Anropa den aktuella undantagshanteraren. Argumentet context skickas vidare och är en ordbok som innehåller nycklarna: 'message', 'exception', 'future'.

asyncio — asynkron I/O-schemaläggare¶

Kärnfunktioner¶

Ytterligare funktioner¶

class Task¶

class Event¶

class ThreadSafeFlag¶

class Lock¶

TCP-strömanslutningar¶

Händelseslinga¶

`asyncio` — asynkron I/O-schemaläggare¶