`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` — планировщик асинхронного ввода-вывода¶