🔥 ГОТОВИШЬСЯ К СОБЕСЕДОВАНИЮ? РАЗБИРАЕМ ТРИ КЛЮЧЕВЫХ КОНЦЕПЦИИ FASTAPI, КОТОРЫЕ НУЖНО ЗНАТЬ КАЖДОМУ РАЗРАБОТЧИКУ!

FastAPI — мощный и современный фреймворк. Чтобы писать на нём качественный код, нужно понимать три вещи: зависимости, жизненный цикл приложения и асинхронность. Разберём каждую простыми словами.

💎 1. DEPENDENCY INJECTION (ВНЕДРЕНИЕ ЗАВИСИМОСТЕЙ)

Это способ передать в эндпоинт всё, что ему нужно: базу данных, настройки, проверки авторизации.

Зачем это нужно?
- Код становится чище: эндпоинт не занимается проверкой прав или созданием подключений.
- Легче тестировать: можно подменить зависимость на мок-объект.
- Удобно переиспользовать логику.

Пример:
from fastapi import Depends, FastAPI

app = FastAPI()

def get_current_user(token: str):
# здесь проверяем токен
return user

@app.get("/profile")
def profile(user = Depends(get_current_user)):
return {"user": user}

Зависимости можно вкладывать друг в друга (каскадные). Это помогает отделить бизнес-логику от эндпоинтов.

⚡ 2. LIFESPAN (УПРАВЛЕНИЕ РЕСУРСАМИ ПРИ ЗАПУСКЕ И ОСТАНОВКЕ)

Раньше использовали события startup и shutdown. Теперь правильный способ — lifespan через асинхронный контекстный менеджер.

Что даёт?
- Гарантирует, что все ресурсы (соединения с БД, пулы, клиенты) будут корректно созданы перед началом работы и закрыты после остановки.
- Код становится более предсказуемым.

Как выглядит:
from contextlib import asynccontextmanager

@asynccontextmanager
async def lifespan(app: FastAPI):
# Старт: создаём ресурсы
app.state.pool = await create_db_pool()
yield
# Стоп: закрываем ресурсы
await app.state.pool.close()

app = FastAPI(lifespan=lifespan)

🔮 3. АСИНХРОННОСТЬ (НЕ ВСЕГДА ОЗНАЧАЕТ БЫСТРОТУ)

async def и await отлично работают, когда код ждёт ответа от внешних сервисов (база данных, API, файловая система). Но если задача CPU-bound (много вычислений), асинхронность не поможет — она просто заблокирует событийный цикл.

Решение для тяжёлых вычислений:
- Использовать ProcessPoolExecutor (отдельные процессы) или отправлять задачи в очередь.

import asyncio
from concurrent.futures import ProcessPoolExecutor

def heavy_cpu(data):
return sum(range(10**7))

@app.get("/compute")
async def compute():
loop = asyncio.get_running_loop()
with ProcessPoolExecutor() as pool:
result = await loop.run_in_executor(pool, heavy_cpu, data)
return {"result": result}

Главное правило: асинхронность — для I/O, процессы — для CPU.

🎯 КАК ЭТО ВСЁ СВЯЗАНО В РЕАЛЬНОМ ПРОЕКТЕ?

1. Lifespan создаёт пул соединений и кладёт его в app.state.
2. Зависимости достают из app.state нужные ресурсы и внедряют их в эндпоинты.
3. Асинхронные эндпоинты обрабатывают запросы, не блокируя другие.

💡 ЧТО ЗАПОМНИТЬ НАЧИНАЮЩЕМУ?

- Dependency Injection помогает писать чистый и тестируемый код.
- Lifespan — правильный способ управлять ресурсами при старте и остановке.
- Асинхронность ускоряет I/O, но не магически ускоряет вычисления — для них нужны процессы.

Эти три кита — база для создания надёжных и производительных приложений на FastAPI. Разберись с ними, и твой код станет на голову выше! 🚀

#FastAPI #Python #Программирование

🔥 FastAPI Dependency Injection: как это работает на самом деле?

Ты на собеседовании на Senior Python разработчика. Тебя спрашивают: «Расскажи, как работает Dependency Injection в FastAPI?» И тут главное — не просто сказать «через Depends()», а показать глубину понимания. Поехали! 🚀

Что такое Dependency Injection (DI)?
Это паттерн, где ты не создаёшь зависимости внутри функции, а просишь, чтобы их «внедрили» извне. FastAPI делает это за тебя. Ты просто объявляешь, что тебе нужно, а фреймворк сам подготавливает и передаёт это в твой эндпоинт.

Как это выглядит в коде?

from fastapi import FastAPI, Depends

app = FastAPI()

# Функция-зависимость
def get_db():
    db = "Подключение к БД"
    return db

# Эндпоинт, который использует зависимость
@app.get("/items")
async def read_items(db: str = Depends(get_db)):
    return {"db": db}

Здесь Depends(get_db) — это магия FastAPI. Когда приходит запрос, FastAPI вызывает get_db(), получает результат и передаёт его в параметр db. Всё просто, но мощно.

Типы зависимостей

• Функциональные зависимости — самый частый случай. Простая функция, которая возвращает нужный объект. Идеально для аутентификации, получения данных из БД, валидации.

• Классовые зависимости — когда нужно сохранять состояние или конфигурацию. Например, работа с API-клиентом, где важно хранить токен.

class AuthChecker:
    def __init__(self, api_key: str):
        self.api_key = api_key

    def __call__(self):
        if not self.api_key:
            raise HTTPException(status_code=403)
        return True

@app.get("/secure")
async def secure_route(auth: bool = Depends(AuthChecker("secret"))):
    return {"access": auth}

Уровни внедрения зависимостей

1. Уровень эндпоинта (Path Operation) — зависимость работает только для одного конкретного маршрута.

2. Уровень роутера (Router) — можно применить ко всем эндпоинтам внутри одного роутера. Супер удобно для группировки: например, все админские маршруты требуют проверки прав.

from fastapi import APIRouter, Depends

router = APIRouter(dependencies=[Depends(verify_token)])

@router.get("/admin")
async def admin_panel():
    return {"message": "Admin only"}

3. Уровень приложения (Application) — глобальная зависимость для всех маршрутов. Используется редко, но полезно для логирования или мониторинга.

Почему это важно для Senior?

Потому что DI в FastAPI — это не просто техническая фича. Это архитектурный паттерн, который делает код:
✅ Модульным — легко менять реализации (например, заменить БД)
✅ Тестируемым — можно подменить зависимость на мок
✅ Чистым — без дублирования логики

На собеседовании покажи, что понимаешь не только «как», но и «зачем». Расскажи про сценарии: аутентификация, управление сессиями БД, кэширование, проверка прав доступа.

Коротко для запоминания:
• Depends() — это способ сказать FastAPI: «Принеси мне это».
• Функции — для простых случаев, классы — для сложных.
• Уровни: эндпоинт, роутер, приложение.
• DI делает код гибким и тестируемым.

Теперь ты готов ответить на этот вопрос как настоящий Senior! 💪

#Python #FastAPI #Senior

🚀 WebSockets в FastAPI: Реальное время для твоего чата!

Представь, что ты звонишь другу: один раз набрал номер, и вы общаетесь без перерыва. WebSocket — это как такой звонок, только между браузером и сервером. Никаких постоянных проверок «а есть ли новое письмо?». Всё мгновенно!

❓ Что такое WebSocket?
Это протокол, который создаёт постоянный канал связи. Клиент (твой браузер или приложение) и сервер могут обмениваться данными в реальном времени. Инициатором может быть кто угодно — не только клиент, но и сервер. Круто, правда?

🆚 Сравним с классическим HTTP:
• HTTP: как почта. Ты отправляешь запрос, сервер отвечает. Чтобы получить новые сообщения, клиент должен постоянно «заглядывать в почтовый ящик» (делать новые запросы). Это медленно, нагружает сервер, тратит трафик.
• WebSocket: как телефонный разговор. Один раз установили соединение — и общаетесь без задержек. Сервер сам может отправить данные, когда они появляются.

🔧 Как это работает в FastAPI?
FastAPI поддерживает WebSocket «из коробки». Нужно просто создать endpoint с websocket.

Пример кода (очень простой):

from fastapi import FastAPI, WebSocket

app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    while True:
        data = await websocket.receive_text()
        await websocket.send_text(f"Эхо: {data}")

Что здесь происходит?
1. Клиент подключается к /ws.
2. Сервер принимает соединение (accept()).
3. В бесконечном цикле сервер ждёт сообщение от клиента и отправляет его обратно (эхо).

💡 Для чата с комнатами нужно чуть больше логики: хранить подключения, рассылать сообщения всем участникам комнаты. Но основа та же.

🔥 Почему это важно для Senior?
На собеседовании спросят:
• Как управлять подключениями? (словарь с websocket-ами)
• Как обрабатывать отключения? (try/except, закрытие соединения)
• Как масштабировать? (через Redis Pub/Sub, чтобы несколько серверов знали друг о друге)

📌 Итог: WebSocket — must-have для real-time фич. FastAPI делает работу с ним простой и элегантной. Учись, и твой чат будет летать!

#Python #FastAPI #WebSocket