python event loop что такое

03.08.202303.07.2023 admin 0 Comments

Реализация асинхронности в Python с модулем asyncio

Асинхронное программирование — это особенность современных языков программирования, которая позволяет выполнять операции, не дожидаясь их завершения. Асинхронность — одна из важных причин популярности Node.js.

Представьте приложение для поиска по сети, которое открывает тысячу соединений. Можно открывать соединение, получать результат и переходить к следующему, двигаясь по очереди. Однако это значительно увеличивает задержку в работе программы. Ведь открытие соединение — операция, которая занимает время. И все это время последующие операции находятся в процессе ожидания.

А вот асинхронность предоставляет способ открытия тысячи соединений одновременно и переключения между ними. По сути, появляется возможность открыть соединение и переходить к следующему, ожидая ответа от первого. Так продолжается до тех пор, пока все не вернут результат.

На графике видно, что синхронный подход займет 45 секунд, в то время как при использовании асинхронности время выполнения можно сократить до 20 секунд.

Где асинхронность применяется в реальном мире?

Асинхронность больше всего подходит для таких сценариев:

Разница в понятиях параллелизма, concurrency, поточности и асинхронности

Параллелизм — это выполнение нескольких операций за раз. Многопроцессорность — один из примеров. Отлично подходит для задач, нагружающих CPU.

Concurrency — более широкое понятие, которое описывает несколько задач, выполняющихся с перекрытием друг друга.

Поточность — поток — это отдельный поток выполнения. Один процесс может содержать несколько потоков, где каждый будет работать независимо. Отлично подходит для IO-операций.

Асинхронность — однопоточный, однопроцессорный дизайн, использующий многозадачность. Другими словами, асинхронность создает впечатление параллелизма, используя один поток в одном процессе.

Составляющие асинхронного программирования

Разберем различные составляющие асинхронного программирования подробно. Также используем код для наглядности.

Сопрограммы

Сопрограммы (coroutine) — это обобщенные формы подпрограмм. Они используются для кооперативных задач и ведут себя как генераторы Python.

Пример сопрограммы

Источник

Функции создания и получения текущего цикла событий.

Функции получения, установки и создания цикла событий.

Следующие низкоуровневые функции могут использоваться для получения, установки или создания цикла событий:

asyncio.get_running_loop() :

Функция asyncio.get_running_loop() возвращает запущенный цикл событий в текущем потоке ОС.

asyncio.get_event_loop() :

Функция asyncio.get_event_loop() получает текущий цикл событий.

Если в текущем потоке ОС не установлен текущий цикл событий, то поток ОС считается основным и функция asyncio.set_event_loop() еще не была вызвана. При этом модуль asyncio автоматически создаст новый цикл событий и установит его как текущий.

Так как функция asyncio.get_event_loop() имеет довольно сложное поведение, особенно при использовании настраиваемых политик цикла событий, то использование функции asyncio.get_running_loop() предпочтительнее, чем asyncio.get_event_loop() в сопрограммах и обратных вызовах.

Лучше всего рассмотреть возможность использования функции asyncio.run() вместо использования функций нижнего уровня для создания и закрытия цикла событий вручную.

asyncio.set_event_loop(loop) :

Функция asyncio.set_event_loop() устанавливает цикл loop как текущий цикл событий для текущего потока ОС.

asyncio.new_event_loop() :

Возможности низкоуровнего API цикла событий:

Реализации цикла событий.

Asyncio поставляется с двумя разными реализациями цикла событий: SelectorEventLoop и ProactorEventLoop.

По умолчанию asyncio настроен на использование SelectorEventLoop в Unix и ProactorEventLoop в Windows.

asyncio.SelectorEventLoop :

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

Доступность: Unix, Windows.

asyncio.ProactorEventLoop :

Класс asyncio.ProactorEventLoop представляет собой цикл событий для Windows, использующий порты завершения ввода/вывода IOCP.

Более подробно смотрите документацию MSDN по портам завершения ввода/вывода.

Источник

H Как же, черт побери, работает async/await в Python 3.5 в черновиках

От переводчика: Это перевод статьи
https://snarky.ca/how-the-heck-does-async-await-work-in-python-3-5/.
Оригинальная статья показалась мне очень полезной и, как мне кажется, определенно заслуживает внимания, если вы до сих пор плохо представляете, как работает асинхронное программирование в Python.
Все ссылки на сторонние ресурсы, встречающиеся в оригинальном тексте, сохранены как есть. Очень советую прочитать информацию по этим ссылка, в особенности различные PEP, тогда многое встанет на свои места.
Перевод в некоторых местах является достаточно вольным, многие выражения переведены не дословно, но с сохранением основного смысла. Все же русский и английский — разные языки и дословный перевод не всегда лучше и понятнее.
Некоторые термины имеют оригинальное написание рядом в скобках. Это сделано с целью сохранения изначального смысла и для возможности сопоставления с оригинальными техническими терминами в документации на английском языке.
У меня получилось перевести не все термины, некоторые можно перевести по-разному. Если вы знаете, как точно переводится тот или иной термин, прошу указывать это в комментариях. Если такой перевод сделает смысл более понятным, я с удовольствием его добавлю.
Если после прочтения у вас останутся вопросы или вы заметили неточность, обязательно напишите об этом в комментариях.
Приятного чтения!

Являясь разработчиком ядра Python мне всегда хотелось понять, как на самом деле функционирует этот язык. Я понимаю, что всегда найдутся такие закоулки, где я не буду знать всех тонкостей, но, чтобы иметь возможность помогать с решением вопросов и с дизайном языка Python в целом, мне кажется, я должен понимать его базовые семантики и как это все работает «под капотом».

в целом эквивалентен конструкции

Я также знал, что asyncio — это event loop фреймворк, который используется для асинхронного программирования, и что в реальности означают эти слова. Но, никогда особо не погружаясь в синтаксис async / await для понимания, как это все работает вместе, я чувствовал, что не понимаю, как устроено асинхронное программирование в Python, и это меня беспокоило. Поэтому я решил все же найти время и разобраться, как же, черт побери, это все устроено. И, поскольку я слышал от различных людей, что они тоже не понимают, как этот новый мир асинхронного программирования функционирует, я решил написать это эссе (да, этот пост занял так много времени и содержит так много слов, что моя жена в итоге окрестила его эссе).

Но, поскольку я хотел иметь наиболее полное понимание, как работает этот новый синтаксис, это эссе содержит некоторые низкоуровневые технические детали, связанные с работой CPython. Не переживайте, если подробностей больше, чем вам необходимо, или есть вещи, которые вы не полностью понимаете, поскольку я не планирую объяснять все нюансы реализации CPython, чтобы не допустить превращения этого эссе в целую книгу (к примеру, если вы не знаете, что объекты, представляющие собой код, имеют флаги, не заморачивайтесь насчет этого, ничего страшного, вам необязательно это знать, чтобы получить необходимую информацию из этого эссе). Также я попытался написать наиболее обобщенное резюме в конце каждого раздела, поэтому, если сам раздел покажется вам слишком избыточным, вы можете перейти сразу к резюме.

Исторический урок о сопрограммах в Python

Согласно Википедии, «Сопрограммы (coroutines) (прим. переводчика: вот ссылка на определение этого термина в русской версии Википедии, далее идет выжимка именно оттуда) — методика связи программных модулей друг с другом по принципу кооперативной многозадачности: модуль приостанавливается в определённой точке, сохраняя полное состояние (включая стек вызовов и счётчик команд), и передаёт управление другому. Тот, в свою очередь, выполняет задачу и передаёт управление обратно, сохраняя свои стек и счётчик». Это упрощенно можно перефразировать так «сопрограммы — это функции, выполнение которых вы можете приостанавливать». И если вы скажете «дак это то, как работают генераторы», вы будете абсолютно правы.

Проблема в том, что несмотря на все же реализованную последовательность целых чисел от 0 до 1,000,000, вам пришлось создать в памяти очень большой список из 1,000,000 чисел. Но после того, как в язык были добавлены генераторы, у вас появилась возможность с минимальными затратами создать итератор, которому не нужно генерировать всю последовательность за раз. Вместо этого достаточно иметь память для хранения только одного числа в каждый момент времени.

Возможность останавливать выполнение функции в любой момент времени, когда в коде встречается выражение yield (до версии Python 2.5 эта конструкция была оператором), и позже возобновлять выполнение функции с этого места оказалась очень полезной в контексте более эффективного использования памяти, позволяя реализовать концепцию бесконечных последовательностей и другие похожие вещи.

Сделав рефакторинг более простым, yield from также позволил создавать цепочку из генераторов таким образом, что значения могли всплывать и опускаться обратно по стэку вызовов без использования всякого дополнительного кода.

Резюме

Генераторы, добавленные в Python 2.2, позволили останавливать выполнение кода. С появлением функционала отправки значения обратно в остановленный генератор, который внедрили в Python 2.5, в нем появилась возможность реализации идеи сопрограмм. А добавление yield from в Python 3.3 не только упростило рефакторинг генераторов, но и позволило выстраивать их в цепочки.

Что такое event loop?

Обращаясь к Википедии, event loop — это «программная конструкция, которая ожидает и генерирует события или сообщения в программе». По сути event loop позволяет реализовать логику «когда случилось A, выполнить В». Возможно, наиболее простым примером этой идеи является event loop в JavaScript, который присутствует в любом браузере. В момент, когда вы нажали что-то на странице («когда случилось А»), событие нажатия попадает в event loop, который в свою очередь проверяет, была ли ранее зарегистрирована функция обратного вызова (callback) на событие onclick для того, чтобы обработать это нажатие («выполнить В»). Если какой-либо обработчик был зарегистрирован для этого события, он вызывается и получает объект с информацией о событии. Event loop (прим. переводчика: этот термин можно дословно перевести, как «петля событий») называется так, потому что он постоянно собирает события и, перебирая их, пытается выяснить, как обработать каждое из этих событий.

В случае с Python, asyncio был добавлен в стандартную библиотеку языка, чтобы обеспечить как раз реализацию идеи event loop. В asyncio основной фокус сделан на сеть, что в случае с event loop подразумевает, что частным случаем «когда случилось А» может являться событие готовности сокета к чтению и/или записи (I/O) (посредством модуля selectors ). Помимо графического интерфейса пользователя (GUI) и сетевого ввода/вывода (I/O), event loop также часто используется для организации исполнения кода в отдельном потоке или дочернем процессе и выступает в качестве планировщика (кооперативная многозадачность). Если вы понимаете, как работает GIL в Python, event loop’ы могут быть очень кстати в ситуациях, когда отключение GIL в принципе возможно и это будет даже эффективно.

Резюме

Event loop позволяет организовать логику «когда произошло А, сделай В». Проше говоря, event loop наблюдает за тем, не произошло ли «что-то», за что он отвечает, и если это «что-то» случилось, он вызывает код, который должен обработать это событие. Python включил event loop в стандартную библиотеку в виде asyncio начиная с версии Python 3.4.

Как работают async и await

Как это было реализовано в Python 3.4

С нововведениями в работе генераторов, добавленных в Python 3.3, и появлением event loop в виде asyncio Python 3.4 уже имел достаточно для поддержки асинхронного программирования в форме concurrent программирования (прим. переводчика. Термин «concurrent» условно можно перевести как «одновременный». Но «одновременное программирование» звучит странно и имеет совершенно другой смысл. Если кто-то подскажет, как лучше это перевести, буду очень признателен). Асинхронное программирование — это такое программирование, когда порядок выполнения неизвестен заранее (поскольку выполнение асинхронно, а не синхронно). Concurrent программирование — это написание такого кода, который может выполняться независимо от других частей, даже если они все выполняются в одном потоке (одновременное выполнение — это не параллелизм). К примеру, следующий код на Python 3.4 реализует таймер обратного отсчета с помощью двух асинхронных, одновременных вызовов одной и той же функции.

В Python 3.4 декоратор asyncio.coroutine использовался для того, чтобы пометить функцию, которая является сопрограммой, и написана для использования с пакетом asyncio и его реализацией event loop. Это обозначило первое определение сопрограмм в Python: это такой объект, который реализует методы, добавленные генераторам в рамках PEP 342, и предоставляемые абстрактным базовым классом collections.abc.Coroutine. А это в свою очередь означало, что все генераторы внезапно получили интерфейс сопрограмм, даже несмотря на то, что изначально их даже не планировалось использовать в таком ключе. Чтобы это исправить, asyncio потребовал, чтобы все генераторы, являющиеся сопрограммами, были обернуты в декоратор asyncio.coroutine.

Переход от yield from к await в Python 3.5

Функция, которая помечалась как сопрограмма для использования в асинхронном программировании, в Python 3.4 выглядела так:

По сути async и types.coroutine сужают определение того, что считается сопрограммой. Это меняет определение сопрограмм от «просто интерфейс генератора», сделав различие между любым генератором и генератором, используемым как сопрограмма, намного более строгим (даже функция inspect.iscoroutine() теперь выполняет более строгую проверку, сообщая, что для сопрограммы необходимо использовать async ).

Как же в итоге обыгрывается различие между yield from и await на более низком уровне (то есть, разница между генератором с декоратором types.coroutine и определенным с помощью выражения async def )? Чтобы это выяснить, давайте взглянем на байткод двух примеров, представленных выше. Байткод для функции py34_coro() выглядит так:

А байткод для функции py35_coro() такой:

Резюме

Думайте об async / await как о программном интерфейсе для асинхронного программирования

Пример реализации

После всего прочтенного ваша голова наверняка слегка переполнена новыми терминами и понятиями, затрудняя охват всех нюансов реализации асинхронного программирования. Чтобы помочь вам расставить точки над i, далее приведен всеобъемлющий (хотя и надуманный) пример реализации асинхронного программирования, начиная от event loop и заканчивая функциями, относящимися к пользовательскому коду. Пример содержит сопрограммы, представляющие собой отдельные таймеры обратного отсчета, но выполняющиеся совместно. Это и есть асинхронное программирование через одновременное выполнение, по сути 3 отдельных сопрограммы будут запущены независимо друг от друга и все это будет выполняться в одном единственном потоке.

Мои надежды и мечты относительно будущего

Лично я надеюсь, что такие проекты как hyper будут иметь успех, чтобы мы смогли получить четкое разделение логики получения бинарных данных из канала ввода/вывода и логики интерпретации этих самых данных. Такая абстракция очень важна, поскольку в большинстве библиотек ввода/вывода в Python присутствует достаточно сильная связность между реализацией канала ввода/вывода и обработкой данных, которые пришли из этого канала. Это основная проблема пакета http стандартной библиотеки Python, поскольку в нем отсутствует отдельный HTTP-анализатор, а объект соединения выполняет всю работу по вводу/выводу и обработке. И если вы надеялись, что requests получит поддержку асинхронного программирования, вашим надеждам не суждено сбыться, поскольку синхронный ввод/вывод является неотделимой частью общей архитектуры. Этот сдвиг и появление возможности использовать асинхронное программирование в Python предоставляет шанс сообществу Python исправить ситуацию с отсутствием необходимых абстракций на разных уровнях сетевого стэка. И теперь у нас есть преимущество в виде возможности написания асинхронного кода так, как будто это синхронный код, поэтому инструменты, заполняющие пустоту в области асинхронного программирования, могут использоваться в обоих мирах.

Заключение

По сути async и await являются модными генераторами, которые мы называем сопрограммами, вдобавок имеется дополнительная поддержка для вещей, называемых awaitable-объектами, и функционал для преобразования простых генераторов в сопрограммы. Все это вместе призвано обеспечить одновременное выполнение, чтобы мы имели наиболее полную поддержку асинхронного программирования в Python. Сопрограммы круче и намного проще в использовании, чем такие сравнимые по функционалу решения, как потоки (я ранее написал пример с использованием асинхронного программирования менее чем из 100 строк с учетом комментариев), в то же время это решение является достаточно гибким и быстрым с точки зрения производительности ( FAQ проекта curio содержит информацию, что curio быстрее, чем twisted на 30-40%, но медленнее gevent всего на 10-15%, и это с учетом того, что он полностью написан на чистом Python, а учитывая тот факт, что Python 2 + Twisted может использовать меньше памяти и проще в отладке чем Go, только представьте, что вы можете сделать с его помощью!). Я очень рад, что это прижилось в Python 3 и я с радостью наблюдаю, как сообщество принимает это и начинает помогать с поддержкой в библиотеках и фреймворках, чтобы мы все в итоге только выиграли от появления более широкой поддержки асинхронного программирования в Python.

Источник

Цикл событийный¶

Цикл событий — это ядро любого asyncio приложения. Циклы событий запускают асинхронные задачи и обратные вызовы, выполняют сетевые операции ввода-вывода и запускают подпроцессы.

Получение цикла событий

Следующие ниже низкоуровневые функции могут использоваться для получения, установки или создания цикла событий:

Вернуть запущенный цикл событий в текущем потоке ОС.

Добавлено в версии 3.7.

Получить текущий цикл событий.

Если в текущем потоке ОС не установлен текущий цикл событий, поток ОС является основным, а set_event_loop() ещё не был вызван, asyncio создаст новый цикл событий и установит его как текущий.

Поскольку у этой функции довольно сложное поведение (особенно при использовании настраиваемых политик цикла событий), использование функции get_running_loop() предпочтительнее, чем get_event_loop() в корутинах и обратных вызовах.

Также рассмотрите возможность использования функции asyncio.run() вместо использования функций нижнего уровня для создания и закрытия цикла событий вручную.

asyncio. set_event_loop ( loop ) ¶

Установить loop как текущий цикл событий для текущего потока ОС.

Создать новый объект цикла событий.

Данная страница документации содержит следующие разделы:

Методы цикла событий¶

У циклов событий есть низкоуровневое API для следующих целей:

Запуск и остановка цикла¶

Работать, пока не завершится future (экземпляр Future ).

Вернуть результат Future или вызвать его исключение.

Остановить цикл событий.

Закрыть цикл событий.

При вызове этой функции цикл не должен выполняться. Все ожидающие обратные вызовы будут отброшены.

Метод очищает все очереди и завершает работу исполнителя, но не дожидается завершения работы исполнителя.

Метод идемпотентен и необратим. Никакие другие методы не должны вызываться после закрытия цикла событий.

coroutine loop. shutdown_asyncgens ( ) ¶

Обратите внимание, что при использовании asyncio.run() нет необходимости вызывать эту функцию.

Добавлено в версии 3.6.

Планирование обратных вызовов¶

Обратные вызовы (Callbacks) вызываются в том порядке, в котором они зарегистрированы. Каждый обратный вызов будет вызываться ровно один раз.

Необязательный ключевой аргумент context, позволяет указать пользовательский contextvars.Context для выполнения callback. Используется текущий контекст, когда context не предоставлен.

Метод не является потокобезопасным.

loop. call_soon_threadsafe ( callback, *args, context=None ) ¶

Изменено в версии 3.7: Был добавлен параметр context только для ключевых параметров. См. PEP 567 для получения более подробной информации.

Большинство функций планирования asyncio не позволяют передавать ключевые аргументы. Для этого используйте functools.partial() :

Использование частичных объектов обычно более удобно, чем использование лямбда-выражений, поскольку asyncio может лучше отображать частичные объекты в сообщениях об отладке и ошибках.

Планирование отложенных обратных вызовов¶

Цикл событий предоставляет механизмы для планирования функций обратного вызова, которые будут вызываться в какой-то момент в будущем. Цикл событий использует монотонные часы для отслеживания времени.

loop. call_later ( delay, callback, *args, context=None ) ¶

Запланировать callback, который будет вызываться после заданного количества секунд delay (может быть либо int, либо float).

callback будет вызван ровно один раз. Если два обратных вызова запланированы на одно и то же время, порядок, в котором они вызываются, не определён.

Изменено в версии 3.7: Был добавлен только ключевой параметр context. См. PEP 567 для получения более подробной информации.

Изменено в версии 3.8: В Python 3.7 и более ранних версиях с реализацией цикла событий по умолчанию delay не могла превышать одного дня. Это было исправлено в Python 3.8.

Изменено в версии 3.8: В Python 3.7 и ранее с реализацией цикла событий по умолчанию разница между when и текущим временем не могла превышать одного дня. Это было исправлено в Python 3.8.

Возвращает текущее время в виде значения float в соответствии с внутренними монотонными часами цикла событий.

Изменено в версии 3.8: В Python 3.7 и более ранних версиях таймауты (относительная delay или абсолютная when) не должны превышать одного дня. Это было исправлено в Python 3.8.

Создание Футур и Задач¶

Это предпочтительный способ создания Футур (Futures) в asyncio. Он позволяет сторонним циклам событий предоставлять альтернативные реализации объекта Футуры (с лучшей производительностью или инструментарием).

Добавлено в версии 3.5.2.

Открытие сетевых подключёний¶

Открыть соединение потокового транспорта с заданным адресом, указанным host и port.

Семейство сокетов может быть AF_INET или AF_INET6 в зависимости от host (или аргумента family, если он указан).

Хронологический синопсис основной операции выглядит следующим образом:

Созданный транспорт является зависящим от реализации двунаправленным потоком.

happy_eyeballs_delay, если задан, включает Happy Eyeballs для этого соединения. Это должно быть число с плавающей запятой, представляющее количество времени в секундах для ожидания завершения попытки подключения перед запуском следующей попытки параллельно. Это «Задержка попытки подключения», как определено в RFC 8305. Разумное значение по умолчанию, рекомендованное RFC — 0.25 (250 миллисекунд).

ssl_handshake_timeout — (для TLS-соединения) время в секундах, в течение которого нужно дождаться завершения подтверждения TLS, прежде чем разорвать соединение. 60.0 секунда, если None (по умолчанию).

Добавлено в версии 3.8: Добавлены параметры happy_eyeballs_delay и interleave.

Алгоритм Happy Eyeballs: успех с хостами двойного стека. Когда путь и протокол IPv4 сервера работают, но путь и протокол IPv6 сервера не работают, клиентское приложение с двойным стеком испытывает значительную задержку соединения по сравнению с клиентом, работающим только с IPv4. Это нежелательно, потому что из-за этого клиент с двойным стеком будет хуже работать с пользователем. Документ определяет требования к алгоритмам, которые уменьшают эту видимую для пользователя задержку, и предоставляет алгоритм.

Для получения дополнительной информации rfc6555

Добавлено в версии 3.7: Параметр ssl_handshake_timeout.

Изменено в версии 3.6: Параметр сокета TCP_NODELAY установлен по умолчанию для всех TCP-соединений.

Параметр reuse_address больше не поддерживается, поскольку использование SO_REUSEADDR представляет серьёзную проблему безопасности для UDP. Явная передача reuse_address=True вызовет исключение.

Создать дейтаграммное соединение.

Изменено в версии 3.4.4: Были добавлены параметры family, proto, flags, reuse_address, reuse_port, allow_broadcast и sock.

Изменено в версии 3.8.1: Параметр reuse_address больше не поддерживается из соображений безопасности.

Изменено в версии 3.8: Добавлена поддержка Windows.

Создать соединение Unix.

См. документацию метода loop.create_connection() для получения информации об аргументах этого метода.

Добавлено в версии 3.7: Параметр ssl_handshake_timeout.

Создание сетевых серверов¶

Создать TCP-сервер (тип сокета SOCK_STREAM ), прослушивающий port адреса host.

Добавлено в версии 3.7: Добавлены параметры ssl_handshake_timeout и start_serving.

Изменено в версии 3.6: Параметр сокета TCP_NODELAY установлен по умолчанию для всех TCP-соединений.

Изменено в версии 3.5.1: Параметр host может быть последовательностью строк.

См. документацию метода loop.create_server() для получения информации об аргументах этого метода.

Добавлено в версии 3.7: Параметры ssl_handshake_timeout и start_serving.

Обернуть уже принятое соединение в пару транспорт/протокол.

Метод может использоваться серверами, которые принимают соединения вне asyncio, но используют asyncio для их обработки.

Добавлено в версии 3.7: Параметр ssl_handshake_timeout.

Добавлено в версии 3.5.3.

Передача файлов¶

Отправить file через transport. Возвращает общее количество отправленных байтов.

file должен быть обычным файловым объектом, открытым в двоичном режиме.

offset указывает, с чего начать чтение файла. Если указано, count — это общее количество байтов для передачи в отличие от отправки файла до достижения EOF. Положение файла всегда обновляется, даже если данный метод вызывает ошибку, и file.tell() можно использовать для получения фактического количества отправленных байтов.

Добавлено в версии 3.7.

Обновление TLS¶

Обновить существующее транспортное соединение до TLS.

Вернуть новый транспортный экземпляр, который protocol должен сразу начать использовать после ожидания (await). Экземпляр transport, переданный методу start_tls. Повторно никогда не должен использоваться.

Добавлено в версии 3.7.

Наблюдение за файловыми дескрипторами¶

Начать мониторинг дескриптора файла fd на предмет доступности для чтения и вызвать callback с указанными аргументами, как только fd станет доступным для чтения.

loop. remove_reader ( fd ) ¶

Прекратить отслеживать дескриптор файла fd на предмет доступности для чтения.

Начать мониторинг дескриптора файла fd на предмет доступности записи и вызвать callback с указанными аргументами, как только fd станет доступным для записи.

loop. remove_writer ( fd ) ¶

Прекратить отслеживать дескриптор файла fd на предмет доступности записи.

См. также раздел Поддержка платформы для ознакомления с некоторыми ограничениями этих методов.