К содержимому
Войти

Python Road Map

🧩 Задачи с лайвкодинга

На лайвкодинге по конкурентности просят не теорию, а 15–30 строк рабочего кода: обойти список URL с лимитом, написать retry, разобрать, в каком порядке напечатаются строки. Здесь семь типовых задач для Python-бэкендера с решениями, которые запущены на Python 3.13, и разбором, на что смотрит интервьюер. Теория — на соседних страницах модуля, сюда приходи потренироваться

🎙️ Как проходит лайвкодинг

Обычно это общий редактор или IDE с демонстрацией экрана и 20–40 минут на задачу. Интервьюер оценивает не только итоговый код, но и то, как ты к нему пришёл. Думай вслух: скажи, что задача I/O-bound и поэтому подойдёт asyncio, назови, где будет точка ожидания и что случится при ошибке

Начни с простого решения, которое работает, и только потом улучшай. Последовательный цикл с await за две минуты лучше, чем недописанный идеальный вариант с пулом, очередью и метриками. Когда простое решение готово, сам назови граничные случаи: пустой список, все запросы упали, таймаут, отмена снаружи, что будет при 10 000 элементов. Часто именно на этом разговоре и решается грейд

Сеть в задачах ниже эмулирует asyncio.sleep: на собеседовании так тоже делают, чтобы не зависеть от интернета

🔀 Что выведет программа

Задача: не запуская код, скажи, в каком порядке напечатаются строки

import asyncio

async def worker(name):
    print(f"{name}: старт")
    await asyncio.sleep(0)
    print(f"{name}: после sleep(0)")
    return name

async def main():
    t1 = asyncio.create_task(worker("A"))
    t2 = asyncio.create_task(worker("B"))
    print("main: задачи созданы")
    await worker("C")
    print("main: C готова")
    print(await t1, await t2)

asyncio.run(main())

Решение

main: задачи созданы
C: старт
A: старт
B: старт
C: после sleep(0)
main: C готова
A: после sleep(0)
B: после sleep(0)
A B

Рассуждай по шагам. create_task только ставит A и B в очередь готовых, сам код не запускает, поэтому первой печатается строка из main. await worker("C") не создаёт задачу: корутина C выполняется прямо внутри main до первого await, отсюда «C: старт». На sleep(0) задача main отдаёт управление и встаёт в очередь после A и B. A и B печатают «старт» и тоже встают в конец, уже за main. Дальше main доделывает C, доходит до await t1, засыпает, и только тогда A и B печатают вторые строки

Интервьюер проверяет, что ты различаешь await coro() и create_task(coro()): первое выполняется сразу и последовательно, второе только запланировано. Частый промах — считать, что задача начинает работать в момент create_task, и поставить «A: старт» первой строкой. Как устроена очередь готовых задач, разобрано на странице про event loop

🌐 Обход URL с лимитом и общим таймаутом

Задача: дан список из сотни URL. Скачай все, но не больше 3 запросов одновременно, а на весь обход отведено 2 секунды. Ошибка одного URL не должна ронять остальные. Верни словарь «URL → результат или исключение»

Решение

import asyncio
import random

async def fetch(url: str) -> str:
    await asyncio.sleep(random.uniform(0.1, 0.5))  # здесь был бы await client.get(url)
    if url.endswith("/7"):
        raise ConnectionError(url)
    return f"ok {url}"

async def fetch_all(urls: list[str], limit: int = 3, total: float = 2.0) -> dict:
    sem = asyncio.Semaphore(limit)
    results: dict[str, str | Exception] = {}

    async def one(url: str) -> None:
        async with sem:
            try:
                results[url] = await fetch(url)
            except Exception as e:  # ошибка одного URL не отменяет остальные
                results[url] = e

    try:
        async with asyncio.timeout(total):
            async with asyncio.TaskGroup() as tg:
                for url in urls:
                    tg.create_task(one(url))
    except TimeoutError:
        pass  # что успели — уже в results, остальное TaskGroup отменила
    return results

На 10 URL с лимитом 3 обход занял около секунды и вернул 10 результатов, один из них ConnectionError. С total=0.6 вернулась примерно половина: остальные задачи отменились по таймауту

В реальном коде вместо asyncio.sleep стоит httpx.AsyncClient, и клиент создают один на весь обход, а не на каждый URL: так переиспользуется пул соединений. Интервьюер смотрит, где стоит try: если ловить исключение снаружи TaskGroup, первая же ошибка отменит все остальные запросы. Частый промах — asyncio.gather на сотню корутин без лимита: удалённый сервис получает сто соединений разом и отвечает 429. Почему TaskGroup отменяет соседей и как таймаут превращается в TimeoutError, разобрано на странице про TaskGroup и таймауты

🔁 Retry с экспоненциальной паузой и джиттером

Задача: напиши декоратор retry для async-функции. Повторять только сетевые ошибки, пауза растёт как base * 2 ** attempt со случайным разбросом, после последней попытки исключение пробрасывается наружу

Решение

import asyncio
import functools
import random

def retry(attempts=4, base=0.1, cap=2.0, retry_on=(ConnectionError, TimeoutError)):
    def deco(fn):
        @functools.wraps(fn)
        async def wrapper(*args, **kwargs):
            for attempt in range(attempts):
                try:
                    return await fn(*args, **kwargs)
                except retry_on:
                    if attempt == attempts - 1:
                        raise
                    # full jitter: пауза случайная, от 0 до потолка
                    await asyncio.sleep(random.uniform(0, min(cap, base * 2 ** attempt)))
        return wrapper
    return deco

@retry()
async def get_profile(user_id: int) -> dict:
    ...

В проверке функция, которая дважды падала с ConnectionError, вернула результат с третьего вызова. ValueError пробросился сразу, без повторов. А задача с retry(attempts=100), отменённая через task.cancel(), остановилась на первой же паузе: CancelledError наследует BaseException и в retry_on не попадает

Первое, о чём спросят: что ретраить. Сетевой обрыв, таймаут, ответы 502, 503 и 429 — да. Ошибку 400, ValueError и баг в коде — нет: повтор вернёт ту же ошибку, только позже. CancelledError не ретраят никогда: это просьба остановиться, а не сбой. Частый промах — except BaseException или голый except:, после которого отменённая задача продолжает долбить сервис, а TaskGroup и asyncio.timeout перестают работать. Второй — пауза без джиттера: тысяча клиентов, упавших одновременно, вернутся тоже одновременно и снова положат сервис

Ещё уточни вслух, что повторять безопасно только идемпотентные операции. Повторный POST /payments после таймаута может списать деньги дважды, если у запроса нет ключа идемпотентности. Как устроены сами декораторы и зачем wraps, разобрано на странице про декораторы

⏱️ Rate limiter: не больше N вызовов в секунду

Задача: внешний API разрешает 5 запросов в секунду. Напиши ограничитель, который можно вызывать из многих корутин одновременно

Решение

import asyncio
import time
from collections import deque

class RateLimiter:
    def __init__(self, rate: int, period: float = 1.0):
        self.rate, self.period = rate, period
        self.calls: deque[float] = deque()  # моменты последних вызовов
        self.lock = asyncio.Lock()

    async def acquire(self) -> None:
        async with self.lock:  # ждущие проходят по одному, в порядке очереди
            while True:
                now = time.monotonic()
                while self.calls and now - self.calls[0] >= self.period:
                    self.calls.popleft()
                if len(self.calls) < self.rate:
                    self.calls.append(now)
                    return
                await asyncio.sleep(self.period - (now - self.calls[0]))

limiter = RateLimiter(rate=5)

async def call_api(i: int) -> None:
    await limiter.acquire()
    ...  # сам запрос

12 одновременных вызовов прошли пачками: пять на 0,00 с, пять на 1,00 с, два на 2,00 с

Это скользящее окно: храним время последних N вызовов и ждём, пока самый старый выпадет из окна. Альтернатива, которую стоит назвать, — token bucket: жетоны копятся с постоянной скоростью, и он разрешает короткий всплеск. Частый промах — ответить Semaphore(5): семафор ограничивает число запросов одновременно, а не в секунду. Если API отвечает за 50 мс, через семафор на 5 пройдёт около сотни запросов в секунду. Время бери из time.monotonic(), а не time.time(): системные часы может перевести NTP

Граничный случай для разговора: лимитер живёт в одном процессе. Если сервис запущен в четырёх репликах, каждая пропустит по 5, и API увидит 20. Общий лимит делают через Redis

📬 Producer-consumer на asyncio.Queue

Задача: продюсер кладёт 20 задач в очередь, три воркера их обрабатывают. Очередь ограничена 5 элементами. Когда всё обработано, программа должна завершиться, а не повиснуть

Решение

import asyncio

async def worker(name: str, q: asyncio.Queue, results: list) -> None:
    while True:
        item = await q.get()
        try:
            await asyncio.sleep(0.01)  # обработка
            results.append((name, item * item))
        finally:
            q.task_done()  # даже при ошибке, иначе join() не дождётся

async def main():
    q: asyncio.Queue[int] = asyncio.Queue(maxsize=5)
    results: list = []
    workers = [asyncio.create_task(worker(f"w{i}", q, results)) for i in range(3)]
    for i in range(20):
        await q.put(i)  # на полной очереди продюсер ждёт
    await q.join()      # каждый элемент отмечен task_done
    for w in workers:
        w.cancel()      # воркеры висят на q.get(), сами не выйдут
    await asyncio.gather(*workers, return_exceptions=True)
    print(len(results))  # 20

asyncio.run(main())

С Python 3.13 есть способ чище: q.shutdown(). После него put бросает QueueShutDown, а get отдаёт оставшиеся элементы и бросает QueueShutDown, когда очередь опустела. Воркер просто выходит из цикла:

async def worker(q: asyncio.Queue, results: list) -> None:
    while True:
        try:
            item = await q.get()
        except asyncio.QueueShutDown:
            return
        results.append(item)
        q.task_done()

async def main():
    q, results = asyncio.Queue(maxsize=5), []
    async with asyncio.TaskGroup() as tg:
        for _ in range(3):
            tg.create_task(worker(q, results))
        for i in range(20):
            await q.put(i)
        q.shutdown()  # воркеры доберут остаток и завершатся
    print(len(results))  # 20

Интервьюер ждёт три вещи. maxsize даёт backpressure: быстрый продюсер не съест память, а подождёт воркеров. task_done стоит в finally, иначе одно исключение в обработке оставит join() висеть навсегда. И у остановки есть явный механизм: join с отменой воркеров, shutdown в 3.13+ или sentinel, по одному None на каждого воркера. Частый промах — await asyncio.gather(*workers) без отмены: воркеры ждут в q.get() вечно, и программа не завершается

🧵 Пул потоков с as_completed

Задача: есть синхронная библиотека без async-версии. Скачай 6 URL в 4 потока, собери результаты по мере готовности, ошибки сложи отдельно

Решение

import time
from concurrent.futures import ThreadPoolExecutor, as_completed

def download(url: str) -> int:
    time.sleep(0.2)  # блокирующий I/O: requests.get(url, timeout=5)
    if url.endswith("/3"):
        raise ValueError(f"битый ответ: {url}")
    return len(url)

urls = [f"https://example.com/{i}" for i in range(6)]
ok, failed = {}, {}
with ThreadPoolExecutor(max_workers=4) as pool:
    futures = {pool.submit(download, u): u for u in urls}
    for fut in as_completed(futures, timeout=10):
        url = futures[fut]
        try:
            ok[url] = fut.result()  # исключение из потока поднимается здесь
        except Exception as e:
            failed[url] = e
print(len(ok), "ок,", len(failed), "с ошибкой")

Вывод: 5 ок, 1 с ошибкой, за 0,4 с. Шесть задач по 0,2 с в четыре потока — два раунда

Словарь «future → URL» нужен, потому что as_completed отдаёт задачи в порядке готовности, а не в порядке списка. Исключение из потока не теряется: оно лежит внутри future и поднимается на fut.result(). Частый промах — не вызвать result() совсем, и тогда ошибка молча пропадает. Второй — забыть, что timeout в as_completed считается от вызова функции, а не на каждую задачу, и по истечении бросает TimeoutError. Если max_workers не задан, с 3.13 пул берёт min(32, os.process_cpu_count() + 4) потоков. Когда выбирать потоки, а когда asyncio, разобрано на странице про потоки, процессы и корутины

🐞 Найди баг: корутина без await и потерянная задача

Задача: обработчик возвращает «200 OK», но событие в базу не сохраняется. Найди две ошибки

import asyncio

async def save_event(event: str):
    await asyncio.sleep(0.1)
    print("сохранено:", event)

async def handle(request: str):
    save_event(request)
    asyncio.create_task(save_event(request + "-audit"))
    return "200 OK"

async def main():
    print(await handle("login"))

asyncio.run(main())

Решение

Запуск печатает только предупреждение и «200 OK»:

handler.py:8: RuntimeWarning: coroutine 'save_event' was never awaited
  save_event(request)
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
200 OK

Первый баг: save_event(request) без await только создаёт объект корутины, тело не выполняется. Python предупреждает об этом, когда объект собирают, но в логах сервиса такое предупреждение легко пропустить. Второй баг: задачу аудита никто не ждёт и на неё нет ссылки. Цикл держит задачи только по слабым ссылкам, так что её может собрать сборщик мусора до завершения. Здесь она не успела ещё проще: main закончилась, и asyncio.run отменил висящую задачу

background: set[asyncio.Task] = set()

async def handle(request: str):
    await save_event(request)
    task = asyncio.create_task(save_event(request + "-audit"))
    background.add(task)                       # сильная ссылка
    task.add_done_callback(background.discard)  # убираем, когда закончилась
    return "200 OK"

При остановке сервиса оставшиеся задачи из background дожидаются через gather. После исправления печатается «сохранено: login», «200 OK» и «сохранено: login-audit»

Хороший ответ называет обе ошибки и добавляет, как ловить их до прода. Первую превращает в падение теста флаг -W error::RuntimeWarning, вторую находит правило ruff RUF006: оно ругается на create_task, результат которого никуда не сохранён. Если фоновая работа должна пережить запрос, кандидату стоит сказать, что надёжнее отдать её в очередь задач, а не держать в памяти процесса. Подробнее о ссылках на задачи — на странице про event loop

⚠️ Где ошибаются чаще всего

  • Ловят слишком широко. except BaseException в retry или воркере глотает CancelledError, и задачу больше нельзя отменить. Лови Exception или конкретные типы
  • Путают лимит одновременности и лимит частоты. Semaphore отвечает на вопрос «сколько сразу», rate limiter — «сколько в секунду»
  • Не думают об остановке. Воркеры на while True без отмены, shutdown или sentinel вешают программу при выходе
  • Создают клиент на каждый запрос. httpx.AsyncClient() внутри цикла убивает пул соединений, и каждый запрос заново делает TLS-рукопожатие
  • Пишут сразу сложное. Молча 20 минут собирают пул с метриками, а простая версия так и не заработала. Начни с работающего цикла и проговаривай улучшения

Ловушки с изменяемым аргументом по умолчанию и лямбдами в цикле тоже встречаются на лайвкодинге, они разобраны на страницах «Объекты, ссылки и изменяемость» и «Функции, замыкания и области видимости»

📚 Что почитать

  • Coroutines and Tasks — официальная документация: create_task и ссылки на задачи, TaskGroup, asyncio.timeout, отмена
  • asyncio Queues — очередь, task_done, join и shutdown с примером пула воркеров
  • python_interview_questions — сборник вопросов с собеседований на Python-разработчика с ответами