Промпты для кода Python. 27 готовых примеров для генерации

Многие разработчики уже пытались использовать нейросети, но часто результат разочаровывает. Вместо аккуратного решения получается набор несвязанного кода, который проще написать с нуля. Эта статья покажет, как правильно использовать промпты для кода Python, чтобы нейросеть стала настоящим помощником, а не генератором проблем.

Проблема не в искусственном интеллекте, а в том, как мы ставим ему задачи. Без четкого контекста и точных инструкций даже самая мощная модель выдаст бесполезный ответ. Здесь нет магии, только технология, требующая правильного подхода.

Этот материал создан, чтобы исправить ситуацию. Вы получите не просто список запросов, а полноценную систему для работы с ИИ в Python-разработке. Внутри вы найдете:

• Готовые шаблоны для самых разных задач.
• Объяснение, почему именно такие формулировки работают.
• Разбор частых ошибок, которые допускают даже опытные специалисты.
• Практические советы для повышения эффективности.

Цель – превратить нейросеть из игрушки в мощный рабочий инструмент, который экономит часы и помогает писать чистый, эффективный и поддерживаемый код.

Типичные ошибки при составлении промптов для ИИ

Прежде чем переходить к готовым решениям, важно понять, что обычно делают не так. Большинство проблем с качеством генерируемого кода возникает из-за одних и тех же упущений. Избегая этих ошибок, вы уже на 80% повысите свои шансы на успех.

1. Просить написать код без указания контекста. Нейросеть не может догадаться, какие библиотеки вы используете, какая у вас версия Python или какова общая архитектура проекта. Без этого она выдаст универсальный, но часто несовместимый с вашим окружением код.
2. Формулировать задачу слишком общо. Запрос «напиши скрипт для парсинга сайта» – это путь в никуда. ИИ не знает, какой сайт, какие данные нужны, в каком формате их сохранить и как обходить блокировки. Результат будет требовать полной переделки.
3. Не указывать требуемый формат ответа. Если не попросить явно, модель может выдать код в виде сплошного текста, без комментариев, без разбивки на функции или классы. Это затрудняет и чтение, и интеграцию кода в проект.
4. Забывать про обработку ошибок и крайние случаи. Генераторы кода по умолчанию создают «счастливый путь», игнорируя ситуации, когда что-то идет не так: файл не найден, API не отвечает, данные пришли в неверном формате. Такой код опасен для реального использования.
5. Не требовать комментариев и документации. Сгенерированный код, особенно если он сложный, может быть непонятен. Без строк документации (docstrings) и поясняющих комментариев разобраться в логике работы будет крайне сложно, особенно спустя время.
6. Принимать первый полученный ответ как финальный. Часто первая версия кода – это лишь черновик. Многие останавливаются на этом, вместо того чтобы уточняющими запросами довести код до ума: попросить его оптимизировать, сделать более читаемым или добавить тесты.
7. Просить ИИ сделать слишком много за один раз. Попытка сгенерировать целое приложение одним промптом почти всегда обречена на провал. Модель лучше справляется с небольшими, четко очерченными задачами. Декомпозиция – ключ к успеху.

ol>

Сравнение неэффективных и сильных промптов для Python-задач

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

Задача	Слабый промпт	Сильный промпт	Почему сильный лучше
Написать функцию для чтения CSV	Напиши функцию на Python для чтения CSV-файла.	Ты – опытный Python-разработчик. Напиши функцию `read_csv_data`, которая принимает путь к файлу. Используй библиотеку `pandas`. Функция должна возвращать DataFrame и обрабатывать ошибку `FileNotFoundError`, возвращая пустой DataFrame в этом случае. Добавь type hints и docstring в стиле Google.	Указана роль, название функции, используемая библиотека (`pandas`), обработка конкретной ошибки, требования к типизации и стилю документации. Это убирает любую двусмысленность.
Создать класс для пользователя	Сделай класс пользователя.	Ты – архитектор ПО. Создай класс `User` на Python с использованием `pydantic`. Класс должен содержать поля: `user_id` (int), `username` (str, от 3 до 20 символов), `email` (EmailStr), `registration_date` (datetime, по умолчанию текущая дата). Добавь валидацию для `username`.	Определяет технологический стек (`pydantic`), задает конкретные поля, их типы и правила валидации. Это создает готовый к использованию компонент, а не абстрактный шаблон.
Рефакторинг кода	Улучши этот код. [вставка кода]	Ты – эксперт по качеству кода. Проведи рефакторинг этого Python-кода. Цели: повысить читаемость согласно PEP 8, разбить большую функцию на несколько маленьких, логически сгруппированных, и заменить `for` цикл на более идиоматичный list comprehension, если это возможно. Объясни внесенные изменения.	Задает конкретные цели рефакторинга (PEP 8, декомпозиция, идиоматичность) и требует объяснения. ИИ не просто меняет код, а действует как наставник, обучая лучшим практикам.
Написать unit-тест	Напиши тест для этой функции. [вставка кода функции]	Ты – QA-инженер. Напиши unit-тест для предоставленной функции `calculate_discount` с использованием фреймворка `pytest`. Тест должен покрывать следующие случаи: скидка для обычной цены, скидка для нулевой цены и проверка вызова исключения `ValueError` при отрицательной цене.	Специфицирует фреймворк (`pytest`) и, что самое важное, перечисляет конкретные тестовые случаи (кейсы), которые нужно проверить. Это обеспечивает полное покрытие логики функции.

27 готовых промптов для кода на Python

Ниже представлены проверенные шаблоны запросов для решения самых разных задач в Python-разработке. Каждый промпт построен так, чтобы минимизировать доработку кода и получать предсказуемый, качественный результат.

1. Генерация функции с обработкой ошибок и типизацией

Проблема: Нужно быстро написать стандартную функцию, но не хочется тратить время на ручное добавление обработки исключений, аннотаций типов и документации.

Решение: Промпт, который заставляет ИИ сразу создавать полноценную, готовую к использованию в проекте функцию.

Текст промпта:

*****

Ты – старший Python-разработчик, приверженец чистого кода. Твоя задача – написать функцию на Python.

Задача: Создай функцию с названием [укажите название функции, например, "get_data_from_url"].
Аргументы: Функция должна принимать следующие аргументы: [перечислите аргументы с их типами, например, "url: str, timeout: int = 10"].
Логика работы:

1. Опиши основной алгоритм функции. Например: «Функция должна отправлять GET-запрос по указанному URL с помощью библиотеки requests».
2. «Она должна вернуть содержимое ответа в виде текста.»

Требования к коду:

1. Используй аннотации типов (type hints) для всех аргументов и возвращаемого значения.
2. Добавь подробную строку документации (docstring) в стиле Google, описывающую назначение функции, ее аргументы и что она возвращает.
3. Реализуй обработку следующих исключений: [перечислите возможные ошибки, например, "requests.exceptions.RequestException, requests.exceptions.Timeout"]. При возникновении этих ошибок функция должна возвращать [укажите значение по умолчанию, например, "None"].

Ограничения: Не используй сторонние библиотеки, кроме [укажите разрешенные библиотеки, например, "requests"].

Формат ответа: Только код на Python. Никаких объяснений до или после кода.

*****

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

2. Рефакторинг существующего кода по стандартам PEP 8

Проблема: Есть фрагмент кода, который работает, но выглядит грязно, трудно читается и не соответствует общепринятым стандартам стиля.

Решение: Запрос, который поручает ИИ выступить в роли ревизора кода и привести его в порядок согласно PEP 8.

Текст промпта:

*****

Ты – эксперт по качеству кода и автоматическому форматированию, досконально знаешь стандарт PEP 8.
Твоя задача – провести рефакторинг предоставленного фрагмента кода на Python, чтобы он полностью соответствовал PEP 8.

Основные цели рефакторинга:

1. Исправить отступы и длину строк (не более 88 символов).
2. Привести именование переменных и функций к стилю snake_case.
3. Добавить необходимые пробелы вокруг операторов и после запятых.
4. Упорядочить импорты согласно рекомендациям (стандартная библиотека, сторонние, свои).

Исходный код для рефакторинга:

[вставьте ваш "грязный" код сюда]

Формат ответа: Предоставь только исправленную версию кода. Не добавляй комментариев о том, что было изменено, если я не просил об этом отдельно.

*****

Почему это работает: Запрос не просто просит «улучшить код», а дает конкретные, измеримые критерии улучшения, основанные на стандарте PEP 8. Это превращает абстрактную задачу в конкретный набор правил, которым ИИ легко следовать.

3. Написание Unit-тестов с использованием Pytest

Проблема: Написание тестов – рутинная, но необходимая задача. Нужно быстро покрыть функцию тестами, проверив основные и крайние случаи.

Решение: Промпт для генерации полного набора тестов для указанной функции с использованием популярного фреймворка Pytest.

Текст промпта:

*****

Ты – опытный QA-инженер, специализирующийся на автоматизации тестирования в Python.
Твоя задача – написать unit-тесты для следующей Python-функции с использованием фреймворка `pytest`.

Функция для тестирования:

[вставьте код вашей функции здесь]

Требования к тестам:

1. Импортируй тестируемую функцию в файл с тестами.
2. Создай отдельные тестовые функции для каждого из следующих сценариев:
   • [опишите первый тестовый случай, например, "Тест с типичными позитивными входными данными"].
   • [опишите второй тестовый случай, например, "Тест с крайним значением, например, 0 или пустой строкой"].
   • [опишите третий тестовый случай, например, "Тест, который должен вызывать исключение, например, ValueError при передаче отрицательного числа. Используй pytest.raises"].
   • [добавьте столько сценариев, сколько необходимо].
3. Используй понятные имена для тестовых функций, например, test_my_function_positive_case.

Формат ответа: Предоставь полный код файла с тестами, готовый к запуску.

*****

Почему это работает: Вместо общей просьбы «написать тесты» мы даем ИИ четкий сценарий: какие именно случаи нужно проверить. Упоминание конкретного фреймворка (`pytest`) и его инструментов (`pytest.raises`) помогает получить идиоматичный и корректный код тестов.

4. Объяснение сложного фрагмента кода

Проблема: Вы столкнулись с непонятным кодом (например, сложное list comprehension, рекурсия или алгоритм) и хотите быстро понять, как он работает.

Решение: Запрос, который превращает ИИ в терпеливого наставника, способного пошагово объяснить логику кода.

Текст промпта:

*****

Ты – преподаватель программирования, умеющий объяснять сложные вещи простым языком.
Твоя задача – проанализировать следующий фрагмент кода на Python и объяснить его работу.

Код для анализа:

[вставьте сложный код здесь]

Формат объяснения:

1. Общее назначение: Опиши в одном-двух предложениях, что делает этот код в целом.
2. Пошаговое описание: Объясни логику работы кода шаг за шагом. Если это цикл, опиши, что происходит на каждой итерации. Если это сложная строка, разбери ее на части.
3. Пример работы: Приведи простой пример входных данных и покажи, какой будет результат на выходе, объяснив, почему он именно такой.
4. Возможные улучшения: Если видишь способы сделать код проще или эффективнее, кратко упомяни их.

Стиль объяснения: Простой, ясный, как для начинающего разработчика, который впервые видит подобную конструкцию.

*****

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

5. Генерация класса данных с Pydantic

Проблема: Необходимо создать класс для валидации данных, например, приходящих из API. Ручное написание валидаторов – долго и чревато ошибками.

Решение: Промпт для быстрой генерации Pydantic-модели с нужными полями, типами и правилами валидации.

Текст промпта:

*****

Ты – бэкенд-разработчик, эксперт по работе с API и валидации данных.
Твоя задача – создать модель Pydantic для представления `[опишите сущность, например, «профиля пользователя»]`.

Название класса: [укажите название, например, "UserProfile"].
Поля класса:

• [имя_поля_1]: тип [тип_данных, например, "int"], описание [краткое описание, например, "уникальный идентификатор"].
• [имя_поля_2]: тип [тип_данных, например, "str"], валидация: [правило валидации, например, "минимальная длина 3 символа"].
• [имя_поля_3]: тип [тип_данных, например, "EmailStr"], описание [описание, например, "электронная почта пользователя"].
• [имя_поля_4]: тип [тип_данных, например, "datetime"], значение по умолчанию: [значение, например, "текущее время UTC"].
• [добавьте столько полей, сколько нужно].

Дополнительные требования:

• Импортируй все необходимые типы из pydantic и datetime.
• Добавь Config класс для [укажите настройку, например, "генерации примера в схеме OpenAPI"].

Формат ответа: Только код модели Pydantic.

*****

Почему это работает: Промпт использует табличный формат для описания полей, что делает задание максимально структурированным. Указание конкретной библиотеки (Pydantic) и ее продвинутых возможностей (EmailStr, Config) позволяет получить современный и мощный код валидации.

6. Конвертация кода из Python 2 в Python 3

Проблема: У вас есть старый скрипт или библиотека, написанные на Python 2, и их нужно адаптировать для работы с современными версиями Python 3.

Решение: Запрос, который поручает ИИ выступить в роли «модернизатора» и автоматически исправить синтаксис и идиомы.

Текст промпта:

*****

Ты – эксперт по миграции кода с Python 2 на Python 3.
Твоя задача – проанализировать следующий код, написанный на Python 2, и сконвертировать его в идиоматичный код для Python 3 (версия 3.8+).

Основные изменения, которые нужно учесть:

1. Заменить оператор print на функцию print().
2. Заменить xrange на range.
3. Убедиться, что целочисленное деление / работает корректно (в Python 3 это всегда float-деление).
4. Обработать изменения в модуле urllib.
5. Заменить использование .iteritems() у словарей на .items().

Код на Python 2 для конвертации:

[вставьте ваш старый код сюда]

Формат ответа: Предоставь две части:

1. Итоговый код на Python 3: Полностью сконвертированный код.
2. Краткий список изменений: Перечень основных правок, которые были сделаны, с пояснением, почему они были необходимы.

*****

Почему это работает: Промпт не просто говорит «конвертируй», а перечисляет ключевые отличия между версиями. Это служит для ИИ чек-листом, гарантируя, что все основные проблемные места будут исправлены. Требование объяснить изменения помогает лучше понять процесс миграции.

7. Создание простого API-эндпоинта на Flask/FastAPI

Проблема: Нужно быстро создать прототип API-эндпоинта для проверки какой-либо идеи или для простого веб-сервиса.

Решение: Промпт для генерации минимально необходимого кода для запуска веб-эндпоинта на одном из популярных фреймворков.

Текст промпта:

*****

Ты – бэкенд-разработчик, специализирующийся на создании REST API.
Твоя задача – написать код для простого API-эндпоинта с использованием фреймворка `[выберите: «Flask» или «FastAPI»]`.

Спецификация эндпоинта:

• Фреймворк: [Flask/FastAPI]
• Путь (URL): [укажите путь, например, "/api/v1/status"]
• HTTP-метод: [укажите метод, например, "GET"]
• Логика: Эндпоинт должен возвращать JSON-ответ со следующим содержимым: [опишите структуру JSON, например, '{"status": "ok", "timestamp": "текущее время в формате ISO"}' ].
• Код ответа: [укажите HTTP-статус, например, "200 OK"].

Требования к коду:

• Код должен быть в одном файле и готовым к запуску.
• Включи все необходимые импорты.
• Добавь блок if __name__ == "__main__": для запуска сервера для разработки (для Flask).

Формат ответа: Только код на Python.

*****

Почему это работает: Запрос декомпозирует задачу на ключевые компоненты API: фреймворк, путь, метод и ожидаемый ответ. Такая детализация не оставляет ИИ пространства для неверных интерпретаций и позволяет сгенерировать точный и рабочий код с первого раза.

8. Оптимизация производительности участка кода

Проблема: Есть функция, которая работает слишком медленно, и нужно найти способ ее ускорить.

Решение: Запрос, который просит ИИ проанализировать код с точки зрения производительности и предложить конкретные улучшения.

Текст промпта:

*****

Ты – эксперт по оптимизации производительности Python-кода, знаешь все о структурах данных, алгоритмах и «бутылочных горлышках».
Твоя задача – проанализировать медленную функцию и предложить способы ее оптимизации.

Медленная функция:

[вставьте ваш медленный код здесь, например, с вложенными циклами]

Контекст: [опишите, в каких условиях функция работает медленно, например, "функция тормозит при обработке списков размером более 100 000 элементов"].

Формат анализа:

1. Анализ проблемы: Определи, почему текущая реализация неэффективна. Укажи на конкретные «бутылочные горлышки» (например, сложность O(n^2), многократное создание объектов).
2. Предлагаемая оптимизация: Напиши новую, оптимизированную версию функции.
3. Объяснение улучшения: Объясни, за счет чего новая версия работает быстрее (например, «заменили поиск в списке O(n) на поиск в множестве O(1)» или «использовали векторизованные операции NumPy вместо цикла»).

Стиль: Технический, но ясный. Сфокусируйся на конкретных изменениях и их влиянии на производительность.

*****

Почему это работает: Промпт требует не просто «сделать быстрее», а провести полный анализ: найти причину, предложить решение и объяснить его. Это заставляет ИИ не применять случайные оптимизации, а действовать как настоящий инженер, решающий проблему производительности системно.

9. Генерация скрипта для работы с файлами

Проблема: Нужно написать скрипт для выполнения рутинной файловой операции, например, переименования, перемещения или обработки группы файлов.

Решение: Промпт для создания готового скрипта, который автоматизирует работу с файловой системой.

Текст промпта:

*****

Ты – системный администратор и Python-разработчик, мастер автоматизации рутинных задач.
Твоя задача – написать скрипт на Python для `[опишите задачу, например, «переименования всех .jpg файлов в указанной папке»]`.

Спецификация скрипта:

• Целевая папка: Скрипт должен принимать путь к папке как аргумент командной строки (используй argparse).
• Критерий выбора файлов: [опишите, какие файлы нужно обрабатывать, например, "все файлы с расширением .txt"].
• Действие: [опишите, что нужно сделать с каждым файлом, например, "добавить к имени файла префикс с датой создания в формате ГГГГ-ММ-ДД_"].
• Обработка ошибок: Скрипт должен корректно обрабатывать ситуацию, если указанная папка не существует.
• Логирование: Выводи в консоль информацию о том, какой файл был переименован и в какое имя.

Библиотеки: Используй только стандартные библиотеки Python (os, argparse, datetime).

Формат ответа: Полный и готовый к выполнению код скрипта с комментариями, объясняющими ключевые части.

*****

Почему это работает: Промпт четко определяет интерфейс скрипта (аргументы командной строки), его логику (выбор файлов, действие) и требования к надежности (обработка ошибок, логирование). Это позволяет получить не просто фрагмент кода, а полноценный инструмент.

10. Написание простого веб-скрапера с BeautifulSoup

Проблема: Нужно извлечь specific информацию с веб-страницы, но нет времени разбираться со структурой HTML и писать парсер вручную.

Решение: Промпт, который генерирует скрапер для извлечения нужных данных по CSS-селекторам.

Текст промпта:

*****

Ты – специалист по сбору данных из веба (web scraping).
Твоя задача – написать Python-скрипт, который извлекает данные с веб-страницы с помощью библиотек `requests` и `beautifulsoup4`.

Спецификация скрапера:

• URL для скрапинга: [укажите URL целевой страницы]
• Данные для извлечения:
  • [Название данных 1, например, "Заголовки статей"]: найди все элементы по CSS-селектору [CSS-селектор, например, "h2.article-title"] и извлеки их текст.
  • [Название данных 2, например, "Ссылки на статьи"]: найди те же элементы и извлеки значение атрибута href.
• Структура результата: Скрипт должен собрать данные в список словарей. Каждый словарь должен представлять одну сущность, например: {'title': 'Заголовок', 'url': '/link-to-article'}.
• Вывод: Распечатай итоговый список в консоль в читаемом виде (используй pprint).

Формат ответа: Готовый к запуску скрипт на Python.

*****

Почему это работает: Ключ к успеху здесь – конкретные CSS-селекторы. Промпт заставляет пользователя заранее их определить (например, с помощью инструментов разработчика в браузере), что превращает задачу из исследовательской в исполнительскую, с которой ИИ отлично справляется.

11. Генерация SQL-запроса с помощью SQLAlchemy Core

Проблема: Нужно сформировать сложный SQL-запрос, но хочется избежать написания сырого SQL, чтобы сохранить переносимость между СУБД и защиту от инъекций.

Решение: Запрос, который использует SQLAlchemy Core для программного построения SQL-запроса.

Текст промпта:

*****

Ты – эксперт по базам данных и SQLAlchemy.
Твоя задача – сгенерировать Python-код, который строит SQL-запрос с использованием SQLAlchemy Core. Не используй ORM.

Описание таблиц:

from sqlalchemy import Table, Column, Integer, String, MetaData

metadata = MetaData()

users = Table('users', metadata,
    Column('id', Integer, primary_key=True),
    Column('name', String),
    Column('age', Integer)
)

orders = Table('orders', metadata,
    Column('id', Integer, primary_key=True),
    Column('user_id', Integer),
    Column('amount', Integer)
)

Задача запроса: [опишите, что должен делать запрос, например, "Выбрать имена всех пользователей старше 30 лет, у которых есть хотя бы один заказ на сумму более 500"].

Требования:

• Используй select, join, where и другие конструкции SQLAlchemy Core.
• В конце выведи скомпилированный SQL-запрос для диалекта PostgreSQL, чтобы можно было проверить его корректность.

Формат ответа: Только код на Python, который определяет таблицы и строит запрос.

*****

Почему это работает: Промпт предоставляет ИИ полную схему данных (определение таблиц SQLAlchemy). Это дает весь необходимый контекст для построения корректного и сложного запроса, связывающего несколько таблиц.

12. Создание декоратора для логирования вызовов функций

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

Решение: Промпт для генерации универсального декоратора, который можно применять к любой функции для логирования ее активности.

Текст промпта:

*****

Ты – опытный Python-разработчик, мастер метапрограммирования.
Твоя задача – написать декоратор `log_function_call`.

Функциональность декоратора:

1. Перед вызовом декорируемой функции он должен выводить в консоль сообщение вида: Вызывается [имя_функции] с аргументами: [аргументы] и ключевыми аргументами: [ключевые_аргументы].
2. После вызова функции он должен выводить сообщение: Функция [имя_функции] вернула результат: [результат].
3. Декоратор должен корректно работать с функциями, принимающими любое количество позиционных и именованных аргументов.
4. Используй functools.wraps для сохранения метаданных исходной функции (имя, docstring).

Формат ответа: Предоставь код декоратора и небольшой пример его использования на простой функции (например, суммирования двух чисел).

*****

Почему это работает: Промпт четко описывает поведение декоратора «до» и «после» вызова основной функции. Упоминание `functools.wraps` и необходимости поддержки `*args`, `**kwargs` гарантирует, что ИИ сгенерирует не просто работающий, а правильный и универсальный декоратор.

13. Парсинг данных из JSON

Проблема: Есть сложный вложенный JSON-ответ от API, и нужно извлечь из него только определенные значения.

Решение: Запрос, который генерирует код для безопасного извлечения данных из JSON-структуры.

Текст промпта:

*****

Ты – специалист по обработке данных.
Твоя задача – написать Python-функцию, которая извлекает определенные данные из JSON-структуры.

Пример JSON-структуры:

[вставьте пример вашего JSON, можно сокращенный, но сохраняющий структуру]

Данные для извлечения:

• [опишите, какие данные нужны, и укажите путь к ним, например, "Имя пользователя из поля 'data.user.profile.name'"]
• [опишите вторые данные, например, "Список ID продуктов из массива 'data.products', где у каждого продукта есть поле 'id'"]

Требования к функции:

• Функция должна принимать на вход Python-объект (словарь), полученный после json.loads().
• Она должна безопасно извлекать данные. Если какой-либо ключ на пути отсутствует (например, нет ключа ‘profile’), функция не должна падать с KeyError, а должна возвращать None или пустой список для этого значения. Используй метод .get().
• Функция должна возвращать словарь с извлеченными данными.

Формат ответа: Код функции и пример ее вызова с представленным JSON.

*****

Почему это работает: Предоставление примера JSON-структуры и точных «путей» к данным устраняет всю неопределенность. Требование безопасного извлечения (через `.get()`) заставляет ИИ писать надежный код, устойчивый к изменениям в структуре API-ответа.

14. Взаимодействие с API с аутентификацией

Проблема: Нужно обратиться к защищенному API, которое требует передачи токена аутентификации в заголовках запроса.

Решение: Промпт для генерации функции, которая выполняет запрос к API, добавляя необходимый заголовок авторизации.

Текст промпта:

*****

Ты – бэкенд-разработчик, интегрирующий сторонние сервисы.
Твоя задача – написать функцию для отправки запроса к защищенному API.

Спецификация:

• Библиотека: requests.
• Название функции: fetch_secure_data.
• Аргументы: api_url: str и auth_token: str.
• Тип аутентификации: Bearer Token. Функция должна формировать заголовок Authorization в формате Bearer [auth_token].
• HTTP-метод: [укажите метод, например, "GET"].
• Логика: Функция отправляет запрос по указанному URL с сформированным заголовком. В случае успеха (статус 200) она должна вернуть ответ в виде JSON. В случае ошибки (любой другой статус или исключение) она должна вернуть None.

Требования к коду: Добавь аннотации типов и docstring.

Формат ответа: Только код функции на Python.

*****

Почему это работает: Промпт явно указывает тип аутентификации (Bearer Token) и формат заголовка. Это ключевая деталь, которая позволяет ИИ сгенерировать корректный код для взаимодействия с большинством современных REST API.

15. Создание класса с использованием `dataclasses`

Проблема: Нужно создать простой класс для хранения данных, но не хочется писать boilerplate-код вроде `__init__`, `__repr__` и `__eq__` вручную.

Решение: Запрос, использующий стандартный модуль `dataclasses` для автоматической генерации этих методов.

Текст промпта:

*****

Ты – Python-разработчик, ценящий лаконичность и современный синтаксис.
Твоя задача – создать класс для хранения данных с использованием модуля `dataclasses`.

Название класса: [укажите название, например, "InventoryItem"].
Атрибуты класса:

• [имя_атрибута_1]: тип [тип, например, "str"].
• [имя_атрибута_2]: тип [тип, например, "int"], значение по умолчанию [значение, например, "0"].
• [имя_атрибута_3]: тип [тип, например, "float"].
• [имя_атрибута_4]: тип list[str], который должен инициализироваться пустым списком по умолчанию (используй default_factory=list).

Требования:

• Используй декоратор @dataclass.
• Добавь аннотации типов для всех атрибутов.
• Укажи, что класс должен быть неизменяемым (frozen=True).

Формат ответа: Код класса и пример его создания.

*****

Почему это работает: Промпт ссылается на конкретный современный инструмент (`dataclasses`) и его возможности (`frozen=True`, `default_factory`). Это позволяет получить не просто класс, а оптимизированный, идиоматичный и безопасный контейнер для данных.

16. Генерация регулярного выражения

Проблема: Нужно составить сложное регулярное выражение для поиска или валидации строк, но синтаксис «регулярок» сложен и неочевиден.

Решение: Запрос, который просит ИИ не только написать регулярное выражение, но и объяснить, как оно работает.

Текст промпта:

*****

Ты – эксперт по регулярным выражениям.
Твоя задача – составить регулярное выражение на Python для `[опишите, что нужно найти или валидировать, например, «валидации E-mail адреса»]`.

Требования к шаблону:

• [опишите правило 1, например, "Должен содержать символ @"].
• [опишите правило 2, например, "Доменная часть должна содержать хотя бы одну точку"].
• [опишите правило 3, например, "Имя пользователя может содержать буквы, цифры, точки и дефисы"].

Формат ответа:

1. Регулярное выражение: Сам шаблон в виде строки Python.
2. Объяснение шаблона: Покомпонентно разбери выражение и объясни, что означает каждая его часть (например, ^ – начало строки, d+ – одна или более цифр).
3. Пример использования: Приведи короткий код на Python, который показывает, как использовать это выражение с re.match или re.search на нескольких примерах (корректных и некорректных строках).

*****

Почему это работает: Промпт заставляет разбить задачу на простые, вербальные правила. ИИ переводит эти правила на язык регулярных выражений. Требование объяснить результат делает промпт обучающим, а не просто «магическим».

17. Работа с данными в Pandas DataFrame

Проблема: Есть DataFrame в Pandas, и нужно выполнить над ним определенную операцию: фильтрацию, группировку или создание нового столбца.

Решение: Запрос для генерации кода, выполняющего конкретную манипуляцию с данными в Pandas.

Текст промпта:

*****

Ты – аналитик данных, виртуозно владеющий библиотекой Pandas.
Твоя задача – написать код для обработки Pandas DataFrame.

Пример DataFrame для работы:

import pandas as pd
data = {'category': ['A', 'B', 'A', 'B', 'A'],
        'value': [10, 15, 20, 25, 30],
        'sales': [100, 150, 50, 200, 120]}
df = pd.DataFrame(data)

Задача: [опишите операцию, например, "Сгруппировать данные по столбцу 'category' и для каждой категории посчитать среднее значение по столбцу 'value' и сумму по столбцу 'sales'"].

Формат ответа: Предоставь только одну строку кода Pandas, которая решает поставленную задачу, и покажи, какой DataFrame получится в результате.

*****

Почему это работает: Предоставление начального DataFrame и четкое описание желаемого результата (например, «сгруппировать по X, посчитать среднее по Y») создает абсолютно конкретную задачу, с которой Pandas-ориентированные модели справляются превосходно.

18. Создание простого графика с Matplotlib

Проблема: Нужно быстро визуализировать данные, построив простой график, но синтаксис Matplotlib может быть многословным.

Решение: Промпт для генерации кода, который создает и настраивает график для наглядного представления данных.

Текст промпта:

*****

Ты – специалист по визуализации данных.
Твоя задача – написать код на Python для создания графика с использованием `matplotlib`.

Данные для визуализации:

• Ось X: [опишите данные для X, например, "список лет: [2020, 2021, 2022, 2023]"]
• Ось Y: [опишите данные для Y, например, "список продаж: [120, 150, 180, 210]"]

Требования к графику:

• Тип графика: [укажите тип, например, "линейный график (plot)"].
• Заголовок графика: [укажите заголовок, например, "Динамика продаж по годам"].
• Подпись оси X: [укажите подпись, например, "Год"].
• Подпись оси Y: [укажите подпись, например, "Объем продаж, млн"].
• Стиль: [укажите дополнительный элемент, например, "Добавить сетку на график"].

Формат ответа: Полный, готовый к выполнению скрипт, который генерирует и отображает график (plt.show()).

*****

Почему это работает: Промпт разбивает визуализацию на составные части: данные, тип графика и элементы оформления (заголовки, подписи). Это позволяет ИИ последовательно собрать код, не упустив ни одной детали.

19. Асинхронная функция с `asyncio`

Проблема: Нужно выполнить несколько долгих I/O-операций (например, веб-запросов) и хочется сделать это параллельно, а не последовательно, чтобы сэкономить время.

Решение: Запрос для создания асинхронного кода с использованием `asyncio` и `aiohttp`.

Текст промпта:

*****

Ты – эксперт по асинхронному программированию в Python.
Твоя задача – написать асинхронный код для параллельного выполнения нескольких веб-запросов.

Библиотеки: asyncio и aiohttp.
Задача:

1. Создай асинхронную функцию fetch(session, url), которая выполняет GET-запрос по URL и возвращает его текстовое содержимое.
2. Создай главную асинхронную функцию main(). Внутри нее определи список из 3-5 URL-адресов для запроса.
3. В main создай клиентскую сессию aiohttp.ClientSession.
4. Используя asyncio.gather, одновременно запусти fetch для каждого URL из списка.
5. Распечатай результаты всех запросов.
6. В конце запусти main с помощью asyncio.run().

Формат ответа: Полностью рабочий асинхронный скрипт.

*****

Почему это работает: Промпт четко прописывает всю структуру асинхронного приложения: вспомогательную корутину (`fetch`), главную точку входа (`main`) и механизм параллельного запуска (`asyncio.gather`). Это руководство к действию, которому ИИ легко следовать.

20. Преобразование данных из одного формата в другой

Проблема: Есть данные в одном структурированном формате (например, список словарей), и их нужно преобразовать в другой (например, CSV-строку или словарь с вложенными объектами).

Решение: Запрос, который генерирует функцию-трансформер данных.

Текст промпта:

*****

Ты – ETL-инженер, мастер преобразования данных.
Твоя задача – написать функцию `transform_data`, которая преобразует данные из одного формата в другой.

Исходный формат данных (пример):

[вставьте пример исходных данных, например:
source_data = [
  {'id': 1, 'name': 'Alice', 'role': 'admin'},
  {'id': 2, 'name': 'Bob', 'role': 'user'}
]]

Целевой формат данных (пример):

[вставьте пример желаемого результата, например:
target_data = {
  1: {'username': 'Alice', 'access_level': 'admin'},
  2: {'username': 'Bob', 'access_level': 'user'}
}]

Задача: Напиши функцию, которая принимает на вход данные в исходном формате и возвращает их в целевом формате.

Формат ответа: Код функции transform_data и пример ее использования.

*****

Почему это работает: Этот промпт работает по принципу «обучение на примерах». Предоставляя четкие примеры «до» и «после», мы даем ИИ возможность самому вывести логику преобразования, что часто эффективнее, чем пытаться описать ее словами.

21. Создание Dockerfile для Python-приложения

Проблема: Нужно упаковать Python-приложение в Docker-контейнер для удобства развертывания, но синтаксис Dockerfile не всегда очевиден.

Решение: Запрос для генерации оптимизированного, многоэтапного Dockerfile.

Текст промпта:

*****

Ты – DevOps-инженер, специализирующийся на контейнеризации Python-приложений.
Твоя задача – создать эффективный `Dockerfile` для простого веб-приложения на `[укажите фреймворк, например, «Flask»]`.

Структура проекта:

• app.py: основной файл приложения.
• requirements.txt: файл с зависимостями.

Требования к Dockerfile:

1. Используй многоэтапную сборку (multi-stage build).
2. Первый этап (builder): используй базовый образ python:3.9-slim, установи зависимости в отдельную директорию с помощью pip install --user.
3. Второй, финальный этап: используй тот же базовый образ python:3.9-slim, создай непривилегированного пользователя appuser и работай из-под него.
4. Скопируй зависимости, установленные на первом этапе. Скопируй код приложения.
5. В качестве команды запуска (CMD) используй gunicorn для запуска приложения.

Формат ответа: Только содержимое файла Dockerfile.

*****

Почему это работает: Промпт не просто просит «сделать Dockerfile», а предписывает использование лучших практик: многоэтапной сборки для уменьшения размера образа и запуска от непривилегированного пользователя для повышения безопасности. Это уровень профессионального DevOps-подхода.

22. Написание класса-менеджера контекста

Проблема: Нужно выполнить какой-то код для настройки перед выполнением блока кода и для очистки после него (например, открытие/закрытие файла или транзакции в базе данных).

Решение: Запрос, который генерирует класс, реализующий протокол менеджера контекста (методы `__enter__` и `__exit__`), для использования с оператором `with`.

Текст промпта:

*****

Ты – архитектор программного обеспечения, знающий все тонкости идиоматичного Python.
Твоя задача – написать класс-менеджер контекста.

Название класса: [укажите название, например, "DatabaseConnection"].
Задача менеджера контекста: [опишите, что он должен делать, например, "Управлять подключением к базе данных SQLite"].

Логика работы:

• Метод __init__: Принимает [аргументы, например, "путь к файлу базы данных"].
• Метод __enter__: Выполняет [действие при входе в блок, например, "устанавливает соединение с БД и возвращает курсор"]. Выводит в консоль сообщение «Соединение открыто».
• Метод __exit__: Выполняет [действие при выходе из блока, например, "совершает commit транзакции, если не было ошибок, или rollback, если была, и закрывает соединение"]. Выводит сообщение «Соединение закрыто». Должен корректно обрабатывать исключения, возникающие внутри блока with.

Формат ответа: Код класса-менеджера контекста и короткий пример его использования с оператором with.

*****

Почему это работает: Промпт явно указывает на необходимость реализовать магические методы `__enter__` и `__exit__` и описывает их логику. Это точная инструкция по реализации одного из самых мощных паттернов Python, что гарантирует корректный результат.

23. Генерация документации в формате reStructuredText/Markdown

Проблема: Есть готовая функция или класс, и нужно быстро сгенерировать для них документацию в формате, понятном для Sphinx или MkDocs.

Решение: Запрос, который анализирует код и создает для него структурированную документацию.

Текст промпта:

*****

Ты – технический писатель, который документирует Python-проекты.
Твоя задача – сгенерировать документацию для следующего кода в формате `[выберите: «reStructuredText» или «Markdown»]`.

Код для документирования:

[вставьте ваш код с type hints и docstrings]

Требования к документации:

1. Начни с названия функции/класса как заголовка.
2. Добавь краткое описание назначения кода, взятое из его docstring.
3. Создай раздел «Аргументы» (или «Параметры»), где для каждого аргумента будет указано его имя, тип и описание.
4. Создай раздел «Возвращает», где будет описано, что возвращает функция, и указан тип возвращаемого значения.
5. Если функция может вызывать исключения, создай раздел «Исключения» и перечисли их.
6. Приведи пример использования в блоке кода.

Формат ответа: Только текст документации в выбранном формате.

*****

Почему это работает: Промпт задает стандартную структуру технической документации. ИИ не придумывает ее сам, а следует заданному шаблону, извлекая информацию из уже существующего кода (аннотаций типов и docstring), что делает процесс быстрым и точным.

24. Алгоритмическая задача (например, сортировка, поиск)

Проблема: Нужно реализовать стандартный алгоритм, но нет желания вспоминать все детали его реализации.

Решение: Запрос для генерации канонической реализации известного алгоритма с пояснениями.

Текст промпта:

*****

Ты – ученый в области компьютерных наук, преподаватель алгоритмов и структур данных.
Твоя задача – реализовать `[название алгоритма, например, «алгоритм быстрой сортировки (Quicksort)»]` на Python.

Требования к реализации:

1. Напиши функцию [имя_функции, например, "quicksort"], которая принимает на вход список чисел.
2. Реализация должна быть [укажите особенность, например, "рекурсивной"].
3. Добавь комментарии, объясняющие ключевые шаги алгоритма (выбор опорного элемента, разделение массива, рекурсивные вызовы).
4. Укажи в docstring временную сложность алгоритма в лучшем, среднем и худшем случаях, а также пространственную сложность.

Формат ответа: Код функции и краткое объяснение принципа ее работы.

*****

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

25. Реализация паттерна «Одиночка» (Singleton)

Проблема: Нужно гарантировать, что у класса будет только один экземпляр в рамках всего приложения (например, для класса настроек или пула соединений).

Решение: Запрос для генерации классической реализации паттерна Singleton в Python.

Текст промпта:

*****

Ты – архитектор ПО, эксперт по паттернам проектирования.
Твоя задача – реализовать паттерн «Одиночка» (Singleton) в Python для класса `[название класса, например, «AppSettings»]`.

Требования к реализации:

• Реализация должна быть потокобезопасной (thread-safe). Используй блокировки (threading.Lock).
• Создай класс, который будет управлять единственным экземпляром.
• Продемонстрируй, что при нескольких попытках создания объекта всегда возвращается один и тот же экземпляр.

Формат ответа:

1. Код класса-одиночки.
2. Код для демонстрации, который создает два объекта и проверяет, что они ссылаются на один и тот же экземпляр (id(obj1) == id(obj2)).

*****

Почему это работает: Промпт указывает на критически важное требование для Singleton в реальных приложениях – потокобезопасность. Это направляет ИИ на создание более сложной и надежной реализации, а не самого простого учебного примера.

26. Создание CLI-инструмента с `argparse`

Проблема: Нужно создать утилиту командной строки с несколькими аргументами и опциями.

Решение: Промпт, который генерирует каркас CLI-приложения с разбором аргументов.

Текст промпта:

*****

Ты – разработчик инструментов командной строки (CLI).
Твоя задача – написать каркас Python-скрипта, который использует библиотеку `argparse` для разбора аргументов.

Спецификация CLI:

• Позиционный аргумент: [имя, например, "input_file"], описание: [описание, например, "Путь к входному файлу"].
• Опциональный аргумент (флаг): [имя, например, "--verbose"], действие: [действие, например, "store_true"], описание: [описание, например, "Включить подробный вывод"].
• Опциональный аргумент со значением: [имя, например, "--output"], описание: [описание, например, "Путь к выходному файлу"], значение по умолчанию: [значение, например, "output.txt"].

Логика скрипта:

• Скрипт должен парсить эти аргументы.
• Затем он должен выводить в консоль значения, которые были переданы.
• Вся логика должна находиться внутри функции main(), а вызов – под if __name__ == "__main__":.

Формат ответа: Полный код скрипта.

*****

Почему это работает: Промпт использует терминологию `argparse` (позиционный, опциональный аргумент, `store_true`), что позволяет ИИ точно сконфигурировать парсер. Структурированное описание аргументов делает задачу предельно ясной.

27. Разработка мок-объекта для тестов

Проблема: При тестировании функции, которая зависит от внешнего сервиса (например, API или базы данных), нужно изолировать тест от этой зависимости.

Решение: Запрос, который использует `unittest.mock.MagicMock` для создания «заглушки» (мок-объекта), имитирующей поведение внешней системы.

Текст промпта:

*****

Ты – QA-инженер, мастер по написанию изолированных тестов.
Твоя задача – написать unit-тест, который использует мок-объект для имитации зависимости.

Ситуация: Есть функция get_user_status(user_id), которая внутри обращается к внешнему сервису ApiService через его метод fetch_data(id). Мы хотим протестировать get_user_status, не делая реального сетевого запроса.

Код для тестирования:

class ApiService:
    def fetch_data(self, user_id):
        # здесь происходит реальный сетевой запрос
        raise NotImplementedError

def get_user_status(api: ApiService, user_id: int):
    data = api.fetch_data(user_id)
    return data.get("status")

Задача теста:

1. Используй unittest.mock.MagicMock для создания мок-объекта ApiService.
2. Настрой мок-объект так, чтобы его метод fetch_data при вызове с определенным user_id возвращал заранее заданный словарь, например, {'status': 'active'}.
3. Вызови тестируемую функцию get_user_status с мок-объектом.
4. Проверь с помощью assert, что функция вернула ожидаемый статус «active».
5. Проверь, что метод fetch_data у мок-объекта был вызван ровно один раз с правильным user_id. Используй mock_api.fetch_data.assert_called_once_with(...).

Формат ответа: Полный код тестовой функции с использованием unittest или pytest.

*****

Почему это работает: Промпт детально описывает сценарий мокирования: что подменяем, как настраиваем поведение «заглушки» и, что важно, как проверяем, что взаимодействие с ней произошло корректно (`assert_called_once_with`). Это полный цикл работы с моками.

Продвинутые приемы для генерации кода на Python

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

Прием	Описание	Когда применять
Запрос на самокритику	После генерации кода вы просите ИИ: «Проанализируй собственный код на предмет возможных улучшений, ошибок или неэффективности. Предложи лучшую версию».	Когда сгенерированный код кажется слишком сложным или вы подозреваете, что есть более «питоничный» (idiomatic) способ решения задачи.
Принцип «одного касания»	В одном промпте вы просите сгенерировать функцию, unit-тесты к ней, документацию и пример использования. Весь пакет за один запрос.	Для небольших, хорошо изолированных функций. Позволяет получить полностью готовый к коммиту модуль за один раз.
Цепочка мыслей (Chain-of-Thought)	Вы просите ИИ сначала составить план решения сложной задачи по шагам, а только потом, во втором запросе, написать код по этому плану. Например: «Сначала опиши шаги для создания…».	Для сложных алгоритмов или многокомпонентных систем. Помогает ИИ структурировать «мысли» и избежать ошибок в логике.
Кодирование на основе псевдокода	Вы сами пишете логику на псевдокоде или простом языке, а затем просите ИИ: «Переведи этот псевдокод в работающий код на Python».	Когда у вас есть четкое понимание алгоритма, но не хочется тратить время на написание синтаксически верного кода.
Указание на стиль и сложность	Вы добавляете в промпт требования к стилю: «Напиши этот код так, чтобы он был понятен новичку» или «Используй только функциональный стиль программирования».	Когда важен не только результат, но и то, как он написан. Например, для обучающих материалов или проектов со строгими код-стайлами.

Неочевидные советы для работы с ИИ

Напоследок – несколько советов, которые редко упоминают в статьях, но которые сильно влияют на продуктивность при работе с генераторами кода. Это результат накопленного опыта и множества экспериментов.

1. Начинайте новый чат для каждой новой задачи. Контекст предыдущих вопросов может «загрязнять» ответы ИИ. Если вы сначала обсуждали FastAPI, а потом просите написать скрипт на Pandas, модель может по инерции пытаться вставить элементы веб-фреймворка туда, где они не нужны.
2. Сохраняйте не только удачные промпты, но и саму сессию с ИИ. Иногда важен не только финальный промпт, а вся цепочка уточнений, которая к нему привела. Сохраняйте ссылки на удачные диалоги, чтобы вернуться к ним в будущем.
3. Просите ИИ объяснить сгенерированный им код как для новичка. Это отличный способ не только проверить, насколько вы поняли решение, но и убедиться, что сам ИИ «понимает» свой код. Если объяснение путаное – вероятно, и в коде есть проблемы.
4. Используйте ИИ для поиска «неизвестных неизвестных». Задавайте открытые вопросы: «Я написал эту функцию. Какие есть альтернативные способы решения этой задачи в Python?», «Какие библиотеки обычно используют для этой задачи, кроме той, что я применил?». Это расширяет ваш кругозор.
5. Не бойтесь «спорить» с нейросетью. Если ответ вас не устраивает, прямо укажите на это: «Этот код неэффективен, потому что… Предложи другой вариант» или «Это не соответствует PEP 8. Перепиши». Такое итеративное уточнение часто приводит к лучшему результату. И да, это немного забавно.
6. Предоставляйте примеры того, что вам НЕ нравится. Иногда проще показать неудачный пример и сказать: «Не делай так». Например: «Вот старая версия функции. Сделай рефакторинг, избегая вложенных циклов, как в этом примере».
7. Используйте английский язык для самых сложных и нишевых задач. Несмотря на прогресс, большинство моделей все еще лучше обучены на англоязычном коде и документации. Если задача касается редкой библиотеки или сложного алгоритма, переключение на английский может дать более точные промпты для кода Python и качественные ответы.