🐍 Python · 20 вопросов · ~55 мин · ⏱ Таймер 55:00 · Сложный · 👥 2 прошли

Асинхронное программирование

Разбирает coroutine, await, event loop, конкурентные задачи и отмену. Задания связывают корутины с темами «Цикл событий», «Конкурентный запуск» и «Отмена и ошибки»: придётся читать код, искать причину сбоя и выбирать решение по его поведению. Все задания рассчитаны на CPython 3.12; отличия других реализаций или версий учитываются только там, где это прямо оговорено.

Отвечено: 0 из 20

⏱ --:--

💡 Инструкция: Версия: CPython 3.12. Выберите один ответ из четырёх. На 20 вопросов отведено не меньше 40 минут; код лучше читать построчно. После завершения вы увидите общий процент, четыре тематические шкалы и объяснение каждого ответа.

Вопрос 1 из 20

Что произойдёт после вызова асинхронной функции без await?

async def load():
    print("start")
    return 5

coro = load()
print(type(coro).__name__)

Функция автоматически станет задачей в текущем цикле событий Создастся объект корутины; тело `load` пока не запустится Вызов вернёт 5, но появится предупреждение об отсутствии `await` Сразу выполнятся `print` и `return`, затем создастся корутина

Вопрос 2 из 20

Почему две задачи, созданные до ожидания результата, могут продвигаться конкурентно?

Первый `await` полностью завершает задачу `a` до запуска `b` Обе задачи запущены до ожидания и уступают управление в `await` `create_task` переносит корутины в разные потоки `gather` сортирует вызовы по длительности ожидания

Вопрос 3 из 20

Что не так с этим кодом внутри async-функции?

Проблема возникает только при задержке больше одной секунды `time.sleep` можно вызвать без `await`, и он уступит управление `time.sleep` блокирует поток цикла событий Внутри `async def` нельзя вызывать обычные функции

Вопрос 4 из 20

Задачу отменяют во время работы с ресурсом. Какое исправление позволит выполнить очистку и при этом не скрыть отмену?

Вызвать `close()` после бесконечного цикла Освободить ресурс в `__del__`, когда объект соберёт GC Перехватить `CancelledError` и вернуть значение без очистки Закрывать ресурс в `finally`, не подавляя отмену

Вопрос 5 из 20

В каком порядке asyncio.gather вернёт результаты?

import asyncio

async def load(name, delay):
    await asyncio.sleep(delay)
    return name

async def main():
    result = await asyncio.gather(
        load("slow", 0.03),
        load("fast", 0.01),
        load("mid", 0.02),
    )
    print(result)

asyncio.run(main())

В порядке завершения: `fast`, `mid`, `slow` В порядке, который выберет цикл событий Только значение первой завершившейся задачи В порядке аргументов: `slow`, `fast`, `mid`

Вопрос 6 из 20

Что произойдёт в TaskGroup, если одна дочерняя задача завершится необработанной ошибкой?

import asyncio

async def first():
    await asyncio.sleep(0)
    raise ValueError("boom")

async def second():
    try:
        await asyncio.sleep(1)
    finally:
        print("second cancelled")

async def main():
    try:
        async with asyncio.TaskGroup() as tg:
            tg.create_task(first())
            tg.create_task(second())
    except* ValueError as group:
        print(type(group).__name__, len(group.exceptions))

asyncio.run(main())

Остальные задачи продолжатся, а ошибка станет значением `TaskGroup` автоматически перезапустит упавшую задачу Отменит соседние задачи и поднимет группу ошибок Ошибка сохранится только в задаче и не повлияет на группу

Вопрос 7 из 20

Почему цикл с `await fetch(item)` внутри каждой итерации выполняет запросы последовательно?

Добавление результата в список блокирует цикл событий `await` создаёт новый поток и сразу ждёт его завершения Каждый `await fetch` завершается до следующей итерации `fetch` вызывается как обычная функция, а не корутина

Вопрос 8 из 20

Операция не успевает завершиться до границы `asyncio.timeout`. Что произойдёт при выходе из контекста?

Учитывается только процессорное время текущей корутины По тайм-ауту остановится весь цикл событий Блок завершится, но операция обязательно продолжится в фоне Отменяет просроченный блок и снаружи даёт `TimeoutError`

Вопрос 9 из 20

Почему `async with` уместен для ресурса, вход и освобождение которого требуют ожидания?

Блок автоматически выполняется в отдельном системном потоке Обычный контекстный менеджер нельзя применять внутри `async def` Все полученные части ответа накапливаются до выхода из блока Вход и освобождение ресурса требуют асинхронного ожидания

Вопрос 10 из 20

Что требуется от объекта в `async for`?

`__aiter__`, `__anext__` и завершение через `StopAsyncIteration` Достаточно обычных `__iter__` и `__next__`, если они возвращают корутины Нужен метод `run`, который после ожидания возвращает готовый список Подойдёт обычный генератор, если его элементы являются awaitable-объектами

Вопрос 11 из 20

В асинхронный сервис нужно встроить старую блокирующую функцию ввода-вывода, которую пока нельзя переписать. Какое проектное решение наименее разрушительно?

После вызова добавить `await asyncio.sleep(0)` Передать обычную функцию прямо в `create_task` Вызвать напрямую: ожидание ввода-вывода само уступит цикл Вынести вызов в `asyncio.to_thread`

Вопрос 12 из 20

Что ограничивает `asyncio.Semaphore(10)` вокруг защищённой части?

Не более десяти задач будет создано за весь запуск Семафор ограничит общее число URL до десяти Будет создано ровно десять рабочих потоков Не больше десяти корутин одновременно выполняют защищённую часть

Вопрос 13 из 20

Почему одна async-задача может надолго заморозить все остальные?

`await` передаёт управление задаче с самым долгим временем ожидания Цикл событий переключает корутины через равные интервалы времени Она долго не достигает `await` и не возвращает управление Тело `async def` выполняется в рабочем потоке, пока не встретит `await`

Вопрос 14 из 20

Почему созданную задачу важно дождаться или явно собрать её ошибку?

Получение результата нужно только для сохранения порядка Задача не начнёт работу, пока на неё не сделают `await` После завершения задача сама считает исключение обработанным Иначе её исключение и завершение останутся без контроля

Вопрос 15 из 20

Что гарантирует shield, если внешний код отменяет ожидание?

Отменится ожидание, но не защищённая задача Внешняя корутина перестаёт реагировать на отмену до конца задачи Для защищённой задачи автоматически устанавливается тайм-аут Отмена преобразуется в `TimeoutError` внутри защищённой задачи

Вопрос 16 из 20

Как очередь создаёт обратное давление?

`maxsize` задаёт число рабочих потоков При заполнении новые элементы вытесняют старые `put` блокирует весь процесс, а не только producer Заполненная очередь приостанавливает producer на `put`

Вопрос 17 из 20

Почему `asyncio.run()` нельзя бездумно вызывать из уже работающего асинхронного обработчика?

Он пытается запустить второй цикл событий в том же потоке Вложенный запуск допустим, если корутина ещё не ожидалась Каждый вызов `run` создаёт отдельный процесс `asyncio.run` принимает только обычные функции

Вопрос 18 из 20

Что обычно делает `wait_for` при истечении времени, если ожидаемая операция не подавляет полученную отмену?

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

Вопрос 19 из 20

Как не потерять CancelledError в широком обработчике ошибок?

Перехватить `BaseException` и вернуть значение по умолчанию Не подавлять отмену; обрабатывать только ожидаемые сбои Поймать отмену вместе с обычными ошибками и не поднимать снова Убрать `finally`, чтобы отмена проходила быстрее

Вопрос 20 из 20

Как дождаться завершения потребления всех элементов очереди?

`join()` ждёт `task_done()` для каждого элемента `join` ждёт первого чтения из пустой очереди Достаточно дождаться завершения producer Проверять `queue.empty()` в цикле до пустого значения

Ответьте на все 20 вопросов, чтобы получить результат

🔗 Встроить тест на свой сайт (iframe) ▼

Скопируйте код и вставьте в любое место на вашем сайте:

Также доступна прямая ссылка на embed-страницу