12 промтов для генерации Python-кода: от скриптов до FastAPI

Умение формулировать точные промты для нейросетей — современный навык Python-разработчика. Вместо того чтобы писать шаблонный код вручную, вы можете делегировать рутину AI и сосредоточиться на архитектуре. Эта подборка — 12 проверенных промтов для задач разного уровня: от обработки CSV до полноценных FastAPI-приложений. Каждый промт сопровождается примером и комментарием. Источники лучших практик — официальные документации Python, FastAPI, pytest и Docker.

1. Скрипт для парсинга CSV с обработкой ошибок

Проблема: Нужно быстро прочитать некачественный CSV, отфильтровать строки и сохранить результат.
Промт: «Напиши скрипт на Python, который читает файл data.csv с колонками name, age, email. Пропускай строки с ошибками (неверный возраст). Выводи только записи с age > 18. Используй модуль csv. Добавь try-except. Сохрани в output.csv.»
Результат:

import csv

def filter_csv(infile, outfile):
    with open(infile) as f_in, open(outfile, 'w', newline='') as f_out:
        reader = csv.DictReader(f_in)
        writer = csv.DictWriter(f_out, fieldnames=['name', 'age', 'email'])
        writer.writeheader()
        for row in reader:
            try:
                age = int(row['age'])
                if age > 18:
                    writer.writerow(row)
            except (ValueError, KeyError):
                continue

if __name__ == '__main__':
    filter_csv('data.csv', 'output.csv')

Комментарий: Промт чётко описывает структуру, обработку исключений и условие. AI генерирует готовый к запуску скрипт — экономия 5–10 минут.

2. Декоратор для логирования времени выполнения

Проблема: Нужно быстро замерить производительность нескольких функций.
Промт: «Создай декоратор timer, который выводит имя функции и время её выполнения в секундах. Используй time.perf_counter. Примени к функциям load_data и process_data.»
Результат:

import time
from functools import wraps

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f'{func.__name__} заняла {elapsed:.3f} сек')
        return result
    return wrapper

@timer
def load_data():
    time.sleep(0.1)

@timer
def process_data():
    time.sleep(0.2)

Комментарий: Промт задаёт конкретные детали (time.perf_counter, @wraps). AI соблюдает best practices — декоратор не теряет метаданные.

3. Юнит-тест с pytest для функции

Проблема: Написать тесты для функции расчёта скидки.
Промт: «Напиши тесты на pytest для функции calculate_discount(price, discount). Проверь: normal case, нулевая скидка, отрицательная скидка (raise ValueError). Используй параметризацию.»
Результат:

import pytest
from discounts import calculate_discount

@pytest.mark.parametrize('price, discount, expected', [
    (100, 10, 90),
    (50, 0, 50),
])
def test_discount(price, discount, expected):
    assert calculate_discount(price, discount) == expected

def test_invalid_discount():
    with pytest.raises(ValueError):
        calculate_discount(100, -5)

Комментарий: Промт включает требование параметризации и обработки исключений. Результат соответствует стандарту pytest. Подробнее: docs.pytest.org.

4. FastAPI-эндпоинт с Pydantic-валидацией

Проблема: Создать POST-эндпоинт, принимающий JSON и возвращающий подтверждение.
Промт: «Напиши FastAPI-приложение с эндпоинтом POST /items. Принимай JSON с полями name (str, длина 1–50) и price (float > 0). Возвращай {“message”: “Item created”, “id”: }. Используй Pydantic BaseModel.»
Результат:

from fastapi import FastAPI
from pydantic import BaseModel, Field
from uuid import uuid4

app = FastAPI()

class Item(BaseModel):
    name: str = Field(..., min_length=1, max_length=50)
    price: float = Field(..., gt=0)

@app.post('/items')
def create_item(item: Item):
    return {'message': 'Item created', 'id': uuid4()}

Комментарий: Промт явно указывает ограничения (min_length, gt). Генерируется корректный код с импортами. Официальная документация: fastapi.tiangolo.com.

5. Dockerfile для Python-приложения

Проблема: Упаковать скрипт в Docker-образ.
Промт: «Создай Dockerfile для Python-скрипта app.py. Используй python:3.11-slim, установи зависимости из requirements.txt, установи рабочую директорию /app, запусти скрипт как модуль.»
Результат:

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "app.py"]

Комментарий: Промт задаёт базовые опции — slim-образ, кэширование pip. AI следует рекомендациям Docker. См. docs.docker.com.

6. Модель SQLAlchemy для базы данных

Проблема: Описать таблицу пользователей с полями id, username, email.
Промт: «Напиши модель SQLAlchemy для таблицы users. Поля: id (Integer, primary key), username (String(50), unique, not null), email (String(120), unique). Используй декларативный стиль.»
Результат:

from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import DeclarativeBase

class Base(DeclarativeBase):
    pass

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    username = Column(String(50), unique=True, nullable=False)
    email = Column(String(120), unique=True)

Комментарий: Промт указывает декларативный стиль и конкретные типы. AI генерирует современный синтаксис (DeclarativeBase). Документация: docs.sqlalchemy.org.

7. CLI-утилита с argparse

Проблема: Создать скрипт, принимающий аргументы командной строки.
Промт: «Напиши скрипт cli.py с argparse. Поддержи аргументы: --input (обязательный), --output (по умолчанию out.txt), --verbose (флаг). Выводи приветствие с именем input-файла.»
Результат:

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--input', required=True, help='Input file')
parser.add_argument('--output', default='out.txt', help='Output file')
parser.add_argument('--verbose', action='store_true')
args = parser.parse_args()

if args.verbose:
    print(f'Processing {args.input} -> {args.output}')
else:
    print('Done')

Комментарий: Чётко указаны типы аргументов (required, default, store_true). AI корректно реализует логику.

8. Асинхронный HTTP-клиент с httpx

Проблема: Отправить несколько GET-запросов параллельно.
Промт: «Напиши асинхронную функцию fetch_all(urls: list[str]) с httpx. Используй asyncio.gather. Возвращай список текстов ответов. Обработай ошибки через try.»
Результат:

import asyncio
import httpx

async def fetch_one(client, url):
    try:
        r = await client.get(url)
        return r.text
    except Exception as e:
        return str(e)

async def fetch_all(urls):
    async with httpx.AsyncClient() as client:
        tasks = [fetch_one(client, url) for url in urls]
        return await asyncio.gather(*tasks)

Комментарий: Промт включает обработку ошибок и использование async with. Документация: python-httpx.org.

9. Генерация docstring в стиле Google

Проблема: Документировать функцию с неочевидными параметрами.
Промт: «Добавь docstring в стиле Google для функции split_data(data, test_size=0.2). Опиши Args, Returns, Raises. data — list, test_size — float, возвращает кортеж (train, test).»
Результат:

def split_data(data, test_size=0.2):
    """Разделяет данные на обучающую и тестовую выборки.

    Args:
        data (list): Исходный список.
        test_size (float): Доля тестовых данных (0–1).

    Returns:
        tuple: (train, test) — два списка.

    Raises:
        ValueError: Если test_size вне [0, 1].
    """
    if not 0 <= test_size <= 1:
        raise ValueError('test_size must be between 0 and 1')
    split = int(len(data) * test_size)
    return data[split:], data[:split]

Комментарий: Промт детализирует структуру docstring. AI добавляет типы и описание исключений — стандарт Google.

10. Middleware для логирования запросов в FastAPI

Проблема: Логировать метод, путь и время обработки каждого запроса.
Промт: «Создай middleware для FastAPI, который логирует метод, путь и время выполнения. Используй logging и time.perf_counter. Оберни все запросы.»
Результат:

import time
import logging
from starlette.middleware.base import BaseHTTPMiddleware

logger = logging.getLogger(__name__)

class LogMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        start = time.perf_counter()
        response = await call_next(request)
        elapsed = time.perf_counter() - start
        logger.info(f'%s %s - %.3f', request.method, request.url.path, elapsed)
        return response

app = FastAPI()
app.add_middleware(LogMiddleware)

Комментарий: Промт использует BaseHTTPMiddleware из Starlette. AI выбирает правильный класс и асинхронный dispatch.

11. CRUD-операции FastAPI + SQLAlchemy

Проблема: Создать простой REST-сервис для пользователей.
Промт: «Напиши FastAPI-приложение с SQLAlchemy. Модель User (id, name). Реализуй GET /users (список), POST /users (создать), GET /users/{id}. Используй сессию через Depends. Pydantic схемы UserIn, UserOut.»
Результат:

from fastapi import FastAPI, Depends, HTTPException
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import Session, sessionmaker, DeclarativeBase
from pydantic import BaseModel

app = FastAPI()
engine = create_engine('sqlite:///./test.db')
SessionLocal = sessionmaker(bind=engine)

class Base(DeclarativeBase): pass

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)

class UserIn(BaseModel):
    name: str

class UserOut(BaseModel):
    id: int
    name: str

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.get('/users', response_model=list[UserOut])
def list_users(db: Session = Depends(get_db)):
    return db.query(User).all()

@app.post('/users', response_model=UserOut)
def create_user(user: UserIn, db: Session = Depends(get_db)):
    db_user = User(name=user.name)
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

@app.get('/users/{id}', response_model=UserOut)
def get_user(id: int, db: Session = Depends(get_db)):
    user = db.query(User).get(id)
    if not user:
        raise HTTPException(404)
    return user

Комментарий: Промт объединяет модели, схемы, CRUD — AI генерирует полное приложение. Типичный шаблон для быстрого старта.

12. Фикстура pytest для тестирования базы данных

Проблема: Создать временную базу SQLite для тестов.
Промт: «Напиши pytest-фикстуру, создающую in-memory SQLite базу с таблицей users (id, name), и sessionmaker. Фикстура должна возвращать сессию, после теста — закрывать. Используй yield.»
Результат:

import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, DeclarativeBase

class Base(DeclarativeBase):
    pass

@pytest.fixture
def db_session():
    engine = create_engine('sqlite://', echo=True)
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    session = Session()
    yield session
    session.close()
    Base.metadata.drop_all(engine)

Комментарий: Промт указывает yield-фикстуру, создание и удаление таблиц. AI корректно управляет жизненным циклом.

Эти 12 промтов покрывают широкий спектр задач — от одноразовых скриптов до инфраструктурного кода. Пользуйтесь ими как шаблонами: адаптируйте под свои данные, проверяйте сгенерированный код, дополняйте тестами. И помните: лучшие промты — те, что конкретны и содержат примеры ожидаемого результата. Экспериментируйте с формулировками, и AI станет вашим ассистентом, экономящим часы рутинной работы.