🧩 Задачи с лайвкодинга
На лайвкодинге по конкурентности просят не теорию, а 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-разработчика с ответами