Асинхронность и aiohttp

Представьте официанта в кафе. Он принял заказ за первым столиком и передал его на кухню. Пока блюдо готовится, официант не стоит у плиты и не ждёт — он идёт принимать заказ за вторым столиком, потом за третьим, разносит напитки, убирает посуду. Когда блюдо готово — кухня зовёт его, и он его забирает. Один официант обслуживает сразу много столиков, потому что не тратит время на ожидание, а переключается между делами.

Именно так работает асинхронный код в Python. Раньше в курсе вы писали программы, где каждая строка выполняется только после того, как закончилась предыдущая. Если строка «ждёт» — например, ответа от сервера в интернете — вся программа стоит и ничего больше не делает. Для одной задачи это нормально. Но если задач много и каждая содержит ожидание, время складывается, и программа работает медленно без всякой причины: процессор всё это время простаивает, а не считает.

В этом уроке разберём инструменты, которые позволяют не ждать впустую — async, await, модуль asyncio — а затем применим их на практике с библиотекой aiohttp, которая умеет забирать данные сразу из нескольких источников в интернете, а не по одному.

Синхронный и асинхронный код — в чём разница

Весь код, который вы писали до сих пор в этом курсе, — синхронный: строки выполняются строго по очереди, и следующая строка не начнётся, пока не закончится предыдущая. Если где-то есть ожидание (ответа сервера, файла, таймера) — программа замирает на этом месте.

Асинхронный код устроен иначе: когда одна задача говорит «я жду», программа не замирает, а переключается на другую задачу, которая тоже готова работать. Как только ожидание первой задачи закончилось — программа вернётся к ней. Всё это происходит в одном потоке, без создания параллельных процессов: просто умное чередование задач в моменты ожидания.

Event loop — кто переключает задачи

У официанта в аналогии есть план в голове: кого обслужить следующим. В Python эту роль играет объект, который называется event loop («цикл событий»). Это диспетчер, который следит за всеми задачами программы и решает, какая из них готова поработать прямо сейчас.

Event loop работает по кругу: смотрит на список задач, запускает готовую, и как только она сообщает «я жду» — забирает у неё управление и передаёт следующей готовой задаче. Когда ожидание какой-то задачи заканчивается, event loop возвращается и продолжает её с того же места.

async def — функция, которую можно приостановить

Обычная функция, объявленная через def, начинает работать сразу при вызове и не может остановиться на середине. Чтобы функция умела «ждать» и в этот момент отдавать управление event loop, её объявляют через async def. Такая функция называется корутиной (coroutine, «сопрограмма»).

async def say_hello():
    print("Привет!")

result = say_hello()
print(type(result))

Разберём построчно:

• async def say_hello(): — объявляет корутину с именем say_hello. Слово async перед def — единственное отличие от обычной функции в объявлении.
• result = say_hello() — вызов корутины, как обычной функции. Но код внутри неё не выполняется: вызов только создаёт специальный объект-корутину, который ещё предстоит запустить.
• print(type(result)) — выведет <class 'coroutine'>. Слово «Привет!» так и не напечаталось.

await — дождаться результата, не блокируя остальных

Слово await ставится перед вызовом корутины и означает: «запусти эту корутину, дождись её результата, а пока ждёшь — отдай управление event loop, пусть поработает кто-то другой».

import asyncio

async def greet(name):
    print(f"Привет, {name}!")
    await asyncio.sleep(1)
    print(f"Пока, {name}!")

• import asyncio — стандартный модуль Python для асинхронного кода, ничего устанавливать не нужно.
• async def greet(name): — корутина с одним параметром name, объявляется как обычная функция, только с async.
• print(f"Привет, {name}!") — обычная строка, выполняется сразу, ничего асинхронного тут нет.
• await asyncio.sleep(1) — asyncio.sleep(1) это тоже корутина, которая «спит» секунду. await перед ней запускает эту паузу и, пока она идёт, отдаёт event loop другим задачам — сама функция greet в это время приостановлена на этой строке.
• print(f"Пока, {name}!") — выполнится только после того, как секунда прошла и await вернул управление обратно в greet.

asyncio.run() — вход в асинхронный мир

Весь код программы, который выполняется, когда вы просто запускаете файл, — синхронный: у него ещё нет event loop, который бы управлял корутинами. Значит, откуда-то нужно этот event loop создать и запустить в нём первую корутину. Для этого есть функция asyncio.run().

import asyncio

async def main():
    print("Начало")
    await asyncio.sleep(2)
    print("Конец (прошло 2 секунды)")

asyncio.run(main())

• async def main(): — по договорённости корутину верхнего уровня часто называют main, это просто имя, не ключевое слово.
• asyncio.run(main()) — создаёт новый event loop, запускает в нём корутину main(), дожидается её полного завершения и закрывает event loop. Это единственная строка во всём файле, которая не находится внутри async def.

Ловушка: asyncio.sleep() и time.sleep() — не одно и то же

Вы уже могли встречать модуль time и его функцию time.sleep(секунды) — она тоже делает паузу. Но внутри корутины использовать её нельзя.

import time

async def bad():
    print("Жду...")
    time.sleep(2)
    print("Дождался")

time.sleep(2) — это обычная функция, не корутина, перед ней не ставят await. Она буквально останавливает весь поток на 2 секунды, и event loop не может в это время переключиться ни на одну другую задачу — программа зависает целиком, хотя формально написана как асинхронная.

asyncio.sleep(2), в отличие от неё, — корутина. Вызванная через await, она приостанавливает именно ту функцию, где стоит, и отдаёт event loop свободное время для других задач.

asyncio.gather() — запустить несколько корутин одновременно

Пока мы делали только одно ожидание за раз. Настоящая польза асинхронности видна, когда независимых ожиданий несколько. asyncio.gather() запускает переданные ей корутины все сразу и возвращает список их результатов, когда завершится последняя.

import asyncio

async def fetch(name, delay):
    await asyncio.sleep(delay)
    return f"данные от {name}"

async def main():
    results = await asyncio.gather(
        fetch("API 1", 2),
        fetch("API 2", 3),
        fetch("API 3", 1),
    )
    print(results)

asyncio.run(main())

• fetch(name, delay) — корутина, которая ждёт delay секунд и возвращает строку с именем. Имитирует запрос, который отвечает не мгновенно.
• asyncio.gather(fetch("API 1", 2), fetch("API 2", 3), fetch("API 3", 1)) — каждый вызов fetch(...) создаёт корутину, все три передаются в gather как отдельные аргументы. gather запускает их одновременно.
• await перед gather — ждём, пока завершится самая долгая из трёх корутин: 3 секунды, а не 2 + 3 + 1 = 6 секунд, как было бы при обычном вызове одной за другой.
• results — список из трёх строк, в том же порядке, что и в вызове gather, независимо от того, какая корутина закончилась раньше остальных.

aiohttp — зачем нужна асинхронность на практике

Самое частое реальное применение асинхронности — запросы в интернет: к сайтам, к API, к внешним сервисам. Каждый такой запрос — классическая I/O-bound операция: программа отправляет вопрос и ждёт ответа сервера, при этом процессор простаивает.

Библиотека aiohttp — асинхронная версия работы с HTTP. Она не входит в стандартную библиотеку Python, её устанавливают отдельно (pip install aiohttp, вы уже видели pip раньше в курсе). Смысл aiohttp — если нужно получить данные с нескольких адресов, она отправляет запросы все сразу, а не один за другим, и суммарное время ожидания получается не суммой, а максимумом — ровно как в примере с gather выше.

ClientSession и запрос GET

Все запросы в aiohttp делаются через объект ClientSession — он хранит настройки соединения и переиспользует их для всех запросов внутри него, вместо того чтобы каждый раз соединяться заново. Открывают сессию через async with — конструкцию, которую вы уже разбирали для файлов; она сама закроет соединение, когда работа завершится.

import aiohttp
import asyncio

async def main():
    url = "https://jsonplaceholder.typicode.com/posts/1"
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            print(response.status)
            data = await response.json()
            print(data["title"])

asyncio.run(main())

• async with aiohttp.ClientSession() as session: — открывает сессию с именем session, автоматически закроет её на выходе из блока.
• async with session.get(url) as response: — отправляет GET-запрос («дай мне данные») по адресу url и открывает ответ как response, тоже через async with, потому что получение ответа — тоже операция ожидания.
• response.status — код ответа сервера: 200 означает «всё хорошо», 404 — «не найдено».
• await response.json() — забирает тело ответа и сразу превращает его из JSON-текста в обычный Python-словарь. Раз это операция ожидания (данные ещё нужно получить и разобрать) — перед ней тоже await.

Несколько запросов одновременно

Вот ради чего всё это затевалось. Соединим ClientSession и уже знакомый asyncio.gather(), чтобы забрать данные сразу с нескольких адресов:

import aiohttp
import asyncio

async def fetch_user(session, user_id):
    url = f"https://jsonplaceholder.typicode.com/users/{user_id}"
    async with session.get(url) as response:
        data = await response.json()
        return data["name"]

async def main():
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_user(session, i) for i in range(1, 4)]
        names = await asyncio.gather(*tasks)
    print(names)

asyncio.run(main())

• fetch_user(session, user_id) — отдельная корутина на один запрос; сессию передаём как параметр, чтобы не открывать новую на каждый запрос.
• tasks = [fetch_user(session, i) for i in range(1, 4)] — список генератором создаёт три корутины (для id 1, 2 и 3), но пока ни одна из них не запущена.
• await asyncio.gather(*tasks) — звёздочка * распаковывает список в три отдельных аргумента, как и при вызове функции с несколькими параметрами. gather запускает все три запроса сразу и ждёт их вместе.
• names — список из трёх имён, в том же порядке, в котором стояли задачи в tasks.

Частые ошибки

async def main():
    greet("Аня")   # без await — код внутри greet не выполнится

asyncio.run(main())

def main():          # обычная функция, без async
    await asyncio.sleep(1)   # SyntaxError