`asyncio` — планировщик асинхронного ввода-вывода#

Этот модуль предоставляет планировщик кооперативной многозадачности для корутин async/await, а также примитивы для синхронизации (блокировки, события) и неблокирующей сетевой работы по TCP через потоковые объекты чтения и записи. Задачи выполняются конкурентно в одном цикле событий; текущая выполняемая задача возвращает управление циклу с помощью await.

Пример:

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)))

Основные функции#

asyncio.create_task(coro: Coroutine) → Task#

Создаёт новую задачу из заданной корутины и планирует её выполнение.

Возвращает соответствующий объект Task.

asyncio.current_task() → Task#: Возвращает объект Task, связанный с текущей выполняемой задачей.

asyncio.run(coro: Coroutine) → Any#

Создаёт новую задачу из заданной корутины и выполняет её до завершения.

Возвращает значение, возвращённое coro.

asyncio.sleep(t: float) → None#

Приостанавливает выполнение на t секунд (может быть числом с плавающей точкой).

Это корутина.

asyncio.sleep_ms(t: int) → None#

Приостанавливает выполнение на t миллисекунд.

Это корутина и расширение MicroPython.

Дополнительные функции#

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

Ожидает завершения awaitable, но отменяет его, если оно занимает больше timeout секунд. Если awaitable не является задачей, то из него будет создана задача.

Если истекает время ожидания, задача отменяется и возбуждается asyncio.TimeoutError: это исключение должно быть перехвачено вызывающим кодом. Задача получает asyncio.CancelledError, которое можно проигнорировать или перехватить с помощью try...except или try...finally для выполнения кода очистки.

Возвращает возвращаемое значение awaitable.

Это корутина.

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

Аналогично wait_for(), но timeout задаётся целым числом в миллисекундах.

Это корутина и расширение MicroPython.

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

Выполняет все awaitables конкурентно. Любые awaitables, не являющиеся задачами, преобразуются в задачи.

Возвращает список возвращаемых значений всех awaitables.

Это корутина.

class Task#

class asyncio.Task#

Этот объект оборачивает корутину в выполняемую задачу. Задачи можно ожидать с помощью await task, что приведёт к ожиданию завершения задачи и возврату её возвращаемого значения.

Задачи не следует создавать напрямую, вместо этого используйте create_task() для их создания.

cancel() → None#: Отменяет задачу, внедряя в неё asyncio.CancelledError. Задача может проигнорировать это исключение. Код очистки можно выполнить, перехватив его, или с помощью try ... finally.

class Event#

class asyncio.Event#

Создаёт новое событие, которое можно использовать для синхронизации задач. События начинаются в сброшенном состоянии.

is_set() → bool#: Возвращает True, если событие установлено, и False в противном случае.

set() → None#

Устанавливает событие. Все задачи, ожидающие это событие, будут запланированы на выполнение.

Примечание: это должно вызываться внутри задачи. Небезопасно вызывать это из IRQ, функции обратного вызова планировщика или другого потока. См. ThreadSafeFlag.

clear() → None#: Сбрасывает событие.

wait() → None#

Ожидает установки события. Если событие уже установлено, возвращает управление немедленно.

Это корутина.

class ThreadSafeFlag#

class asyncio.ThreadSafeFlag#

Создаёт новый флаг, который можно использовать для синхронизации задачи с кодом, выполняемым вне цикла asyncio, например другими потоками, IRQ или функциями обратного вызова планировщика. Флаги начинаются в сброшенном состоянии.

set() → None#: Устанавливает флаг. Если есть задача, ожидающая этот флаг, она будет запланирована на выполнение.

clear() → None#: Сбрасывает флаг. Это может использоваться для гарантии того, что ранее, возможно, установленный флаг сброшен перед ожиданием его установки.

wait() → None#

Ожидает установки флага. Если флаг уже установлен, возвращает управление немедленно. Флаг автоматически сбрасывается при возврате из wait.

Флаг может ожидаться только одной задачей одновременно.

Это корутина.

class Lock#

class asyncio.Lock#

Создаёт новую блокировку, которую можно использовать для координации задач. Блокировки начинаются в разблокированном состоянии.

Помимо методов, перечисленных ниже, блокировки можно использовать в инструкции async with.

locked() → bool#: Возвращает True, если блокировка заблокирована, и False в противном случае.

acquire() → bool#

Ожидает, пока блокировка не перейдёт в разблокированное состояние, а затем атомарно блокирует её. Только одна задача может захватить блокировку в любой момент времени.

Это корутина.

release() → None#: Освобождает блокировку. Если какие-либо задачи ожидают блокировку, то следующая в очереди планируется на выполнение, а блокировка остаётся заблокированной. В противном случае, если задач не ожидает, блокировка становится разблокированной.

Потоковые TCP-соединения#

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

Открывает TCP-соединение с заданным host и port. Адрес host будет разрешён с помощью socket.getaddrinfo(), который в настоящее время является блокирующим вызовом. Если ssl является объектом ssl.SSLContext, этот контекст используется для создания транспорта; если ssl равно True, используется контекст по умолчанию.

Возвращает пару потоков: поток для чтения и поток для записи. Возбудит специфичное для сокета исключение OSError, если хост не удалось разрешить или если соединение не удалось установить.

Это корутина.

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

Запускает TCP-сервер на заданных host и port. callback будет вызываться для входящих принятых соединений, и ему будут переданы 2 аргумента: потоки для чтения и записи данного соединения.

Если ssl является объектом ssl.SSLContext, этот контекст используется для создания транспорта.

Возвращает объект Server.

Это корутина.

class asyncio.Stream#

Это представляет потоковое TCP-соединение. Чтобы минимизировать код, этот класс реализует как объект чтения, так и объект записи, и оба имени StreamReader и StreamWriter являются псевдонимами этого класса.

get_extra_info(v: str) → Any#: Получает дополнительную информацию о потоке, заданную значением v. Допустимые значения для v: peername.

close() → None#: Закрывает поток.

wait_closed() → None#

Ожидает закрытия потока.

Это корутина.

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

Читает до n байт и возвращает их. Если n не указано или равно -1, читает все байты до EOF. Возвращаемое значение будет пустым объектом bytes, если EOF встречается до того, как будут прочитаны какие-либо байты.

Это корутина.

readinto(buf: bytearray | memoryview) → int#

Читает до n байт в buf, где n равно длине buf.

Возвращает количество байт, прочитанных в buf.

Это корутина и расширение MicroPython.

readexactly(n: int) → bytes#

Читает ровно n байт и возвращает их в виде объекта bytes.

Возбуждает исключение EOFError, если поток заканчивается до прочтения n байт.

Это корутина.

readline() → bytes#

Читает строку и возвращает её.

Это корутина.

write(buf: bytes) → None#: Накапливает buf в выходном буфере. Данные сбрасываются только при вызове Stream.drain(). Рекомендуется вызывать Stream.drain() сразу после вызова этой функции.

drain() → None#

Сбрасывает (записывает) все буферизованные выходные данные в поток.

Это корутина.

class asyncio.Server#

Это представляет класс сервера, возвращаемый функцией start_server(). Его можно использовать в инструкции async with для закрытия сервера при выходе.

close() → None#: Закрывает сервер.

wait_closed() → None#

Ожидает закрытия сервера.

Это корутина.

Цикл событий#

asyncio.get_event_loop() → Loop#: Возвращает цикл событий, используемый для планирования и выполнения задач. См. Loop.

asyncio.new_event_loop() → Loop#

Сбрасывает цикл событий и возвращает его.

Примечание: поскольку MicroPython имеет только один цикл событий, эта функция просто сбрасывает состояние цикла, она не создаёт новый.

class asyncio.Loop#

Это представляет объект, который планирует и выполняет задачи. Его нельзя создать, вместо этого используйте get_event_loop().

create_task(coro: Coroutine) → Task#: Создаёт задачу из заданного coro и возвращает новый объект Task.

run_forever() → None#: Выполняет цикл событий до вызова stop().

run_until_complete(awaitable: Awaitable) → Any#: Выполняет заданное awaitable до его завершения. Если awaitable не является задачей, то оно будет преобразовано в задачу.

stop() → None#: Останавливает цикл событий.

close() → None#: Закрывает цикл событий.

set_exception_handler(handler: Callable) → None#: Устанавливает обработчик исключений, вызываемый, когда задача возбуждает неперехваченное исключение. handler должен принимать два аргумента: (loop, context).

get_exception_handler() → Callable | None#: Получает текущий обработчик исключений. Возвращает обработчик или None, если пользовательский обработчик не установлен.

default_exception_handler(context: dict) → None#: Обработчик исключений по умолчанию, который вызывается.

call_exception_handler(context: dict) → None#: Вызывает текущий обработчик исключений. Аргумент context передаётся напрямую и является словарём, содержащим ключи: 'message', 'exception', 'future'.

asyncio — планировщик асинхронного ввода-вывода#

Основные функции#

Дополнительные функции#

class Task#

class Event#

class ThreadSafeFlag#

class Lock#

Потоковые TCP-соединения#

Цикл событий#

`asyncio` — планировщик асинхронного ввода-вывода#