15 Prompts for Generating Python Code: From Scripts to FastAPI

Introduction

As a developer who relies on AI daily, I’ve curated a battle-tested collection of prompts that consistently produce high-quality Python code — from quick automation scripts to production-ready FastAPI endpoints. These prompts are designed to be specific, actionable, and repeatable. Each one includes a real-world problem, the prompt you can copy, an example use case, and the resulting code output.

Whether you’re a data engineer automating ETL pipelines, a backend developer building APIs, or a DevOps engineer writing deployment scripts, this list covers the most common scenarios. I’ve personally tested every prompt on GPT-4, Claude 3.5, and Gemini, and they work out of the box.

Let’s dive into 15 prompts that will save you hours of boilerplate and debugging.

1. Generate a Python script that reads a CSV file and outputs summary statistics

Problem: You need a quick data exploration script without rewriting pandas code. The prompt should handle column types, missing values, and basic stats.

Prompt:

Act as a senior data engineer. Write a Python script using pandas that reads a CSV file from a given input_path. The script should:
- Detect column data types automatically
- Print summary statistics (count, mean, std, min, 25%, 50%, 75%, max) for numeric columns
- Count missing values per column
- Save the summary to a JSON file at output_path.
Use argparse for command-line arguments (--input and --output).
Add error handling for missing files and empty dataframes.

Example usage:

python summarize_csv.py --input data.csv --output summary.json

Result: A self-contained script with argparse, try-except blocks, and a clean output structure. You get both the printed table and a machine-readable JSON.

Why it works: The prompt explicitly requests argparse, error handling, and two output formats — covering both human and machine consumption.

2. Write a Python function that retries an HTTP request with exponential backoff

Problem: You need a robust retry mechanism for an external API that occasionally fails.

Prompt:

Write a decorator @retry(max_retries=3, backoff_factor=2) that catches requests.exceptions.RequestException. After each failed attempt, wait backoff_factor^attempt seconds. After exhausting retries, raise the last exception. Also log each retry attempt using Python's logging module.

Example:

@retry(max_retries=5, backoff_factor=1.5)
def fetch_user(user_id):
    return requests.get(f"https://api.example.com/users/{user_id}", timeout=30)

Result: A reusable decorator that works with any requests-based function. Logging gives visibility; exponential backoff prevents overwhelming the server.

Why it works: The prompt specifies the exception to catch, the exact backoff formula, and logging — not just a vague “add retry logic”.

3. Generate a FastAPI endpoint for file upload with validation

Problem: You need to allow users to upload CSV files, validate their content, and return a preview.

Prompt:

Create a FastAPI endpoint POST /upload/ that accepts a file upload of type text/csv. Use UploadFile and File from FastAPI. Endpoint should:
- Validate file size < 10 MB
- Validate that the file has at least a header row
- Return the first 5 rows as a list of dicts
- Handle errors using HTTPException with appropriate status codes.

Example request:

curl -X POST -F "file=@data.csv" http://localhost:8000/upload/

Response:

{"filename": "data.csv", "columns": ["name", "age"], "preview": [{"name": "Alice", "age": 30}, ...]}

Why it works: The prompt covers validation, error responses, and a concrete response schema. No ambiguous requirements.

4. Write a Python script that downloads files from an S3 bucket using boto3

Problem: Automating file retrieval from AWS S3 without writing boilerplate credentials and client code.

Prompt:

Write a Python script using boto3 that downloads all files from a given S3 bucket and prefix. Use environment variables for AWS credentials. Accept bucket name, prefix, and local destination directory as command-line arguments with argparse. Implement multipart download for files larger than 50 MB using s3.Object.download_fileobj. Print progress for each file.

Example:

python s3_download.py --bucket my-bucket --prefix data/2024/ --dest ./local_data/

Why it works: By specifying multipart download and progress output, the prompt produces a production-ready script, not a minimal example.

5. Create a Python class for a thread-safe queue with a maximum size

Problem: You need a bounded, thread-safe queue for producer-consumer patterns beyond what queue.Queue offers (e.g., custom item filtering).

Prompt:

Implement a thread-safe BoundedPriorityQueue class using threading.Lock and heapq. It should have a maxsize parameter. Methods:
- put(item, priority): blocks if queue is full until space becomes available
- get(): blocks if empty, returns lowest-priority item first
- qsize(): returns current size
Raise Full exception if blocking is disabled.

Example:

q = BoundedPriorityQueue(maxsize=3)
q.put("task1", 2)
q.put("task2", 1)
print(q.get())  # task2 (lower priority number)

Why it works: The prompt defines methods, behavior for blocking, and custom ordering — covering edge cases like full/empty states.

6. Write a script to merge multiple JSON files into one

Problem: You have dozens of JSON logs or API responses and need a single merged file.

Prompt:

Write a Python script that reads all .json files from a given input directory, merges them into a single list, and writes the result to an output file. Assume each JSON file contains either a dict or a list of dicts. If a file contains a dict, wrap it in a list before merging. Use pathlib and json module. Add command-line arguments: --input-dir, --output-file.

Why it works: It handles both dict and list inputs — a common real-world variation — and uses pathlib for modern path handling.

7. Generate a Dockerfile for a Python FastAPI application

Problem: You need a production-ready Docker image for your FastAPI app.

Prompt:

Write a Dockerfile for a FastAPI application using Python 3.11-slim. It should:
- Set WORKDIR to /app
- Copy only requirements.txt first (for layer caching)
- Install dependencies with pip --no-cache-dir
- Copy the rest of the application
- Run the app with uvicorn on port 8000, with 4 workers
- Use a non-root user (create a user 'appuser')
- Include healthcheck running curl --fail http://localhost:8000/health every 30s

Example:

FROM python:3.11-slim
...

Why it works: Multi-stage not needed for slim, but caching, non-root, and healthcheck are explicitly mentioned — all best practices.

8. Write a Python script that schedules a daily task using schedule library

Problem: You need a simple cron-like scheduler without external crontab setup.

Prompt:

Using the schedule library, write a script that runs a function daily_report() every day at 8:00 AM. The function should write a timestamp to a log file and send an email via SMTP_SSL if an error occurs. Use environment variables for email credentials. The script should run indefinitely with while True: schedule.run_pending(); time.sleep(60).

Why it works: It combines scheduling, error reporting via email, and environment variables — a complete background job pattern.

9. Create a FastAPI middleware for request timing

Problem: You need to measure and log response times for all endpoints.

Prompt:

Write a FastAPI middleware using @app.middleware("http") that records the time before the request is processed and after, then logs the method, path, and duration in milliseconds using logging.info. Use time.perf_counter() for precision. Exclude the /health endpoint from logging.

Example output:

2024-07-28 10:00:00 INFO GET /users/ 45ms

Why it works: The prompt specifies perf_counter, exclusion logic, and log format — no ambiguity about precision or filtering.

10. Write a Python script that converts Markdown to HTML using mistune

Problem: You need a simple Markdown-to-HTML conversion script for documentation.

Prompt:

Write a script that reads a Markdown file, converts it to HTML using the mistune library (not markdown2), and writes the output to an HTML file. Add code block syntax highlighting by rendering <pre><code> with the language class. Accept input and output file paths as command-line arguments.

Why it works: Explicitly names mistune, avoids ambiguity with other markdown parsers, and requests syntax highlighting class—making the output ready for Prism.js or Highlight.js.

11. Generate a Python script that watches a directory for new files and processes them

Problem: You need to automate processing of incoming files in a folder (e.g., CSV uploads).

Prompt:

Write a script using watchdog library that monitors a given directory for new file creation events (not modifications). When a new file is created, move it to a processing/ subdirectory and call a function process_file(filepath). Log all events. Use argparse to accept the watch directory. The script should run until interrupted.

Why it works: It uses watchdog correctly (many examples misuse it), moves files to avoid reprocessing, and includes logging.

12. Write a Python function using asyncio to fetch multiple URLs concurrently

Problem: You need to speed up HTTP requests by making them concurrently rather than sequentially.

Prompt:

Write an async function fetch_all(urls: list) -> dict using aiohttp and asyncio.gather. Each request should have a 10-second timeout. If a request fails, return None for that URL. Use semaphore with concurrency limit of 5.

Example:

results = await fetch_all(["https://api1.com", "https://api2.com"])

Why it works: The prompt includes semaphore for rate-limiting, timeout, and graceful failure handling — essential for production async code.

13. Create a Python script that generates a password-protected ZIP file

Problem: You need to securely package files with encryption.

Prompt:

Write a script using pyzipper library (AES encryption) that creates a password-protected ZIP file from a given directory. Use pyzipper.AESZipFile with encryption method pyzipper.WZ_AES. Accept source directory, output ZIP path, and password via argparse. List all files added.

Why it works: Specifying pyzipper (not standard zipfile) ensures AES encryption is used, and includes the exact class name.

14. Write a FastAPI background task that runs after a response is sent

Problem: You want to offload heavy processing (e.g., image resizing) after the API returns immediately.

Prompt:

Use FastAPI's BackgroundTasks to run a function process_image() after returning the response. The endpoint POST /images/ should accept an image upload, return {"status": "processing", "id": uid} immediately, and then in the background: resize the image to 800x600 using Pillow and save to processed/ directory. Use uuid for unique filenames.

Why it works: It demonstrates the correct use of BackgroundTasks with file upload — a common use case often implemented incorrectly with threading.

15. Generate a Python script that tests an API endpoint with pytest

Problem: You need a simple test suite for a REST endpoint.

Prompt:

Write a pytest test file that tests a FastAPI endpoint GET /items/{item_id}. Use TestClient from FastAPI. Test at least three scenarios:
- 200 OK when item exists
- 404 when item does not exist
- 422 when item_id is not an integer
Use parametrize for the valid/invalid cases.

Why it works: The prompt covers happy path, error paths, and validation — a complete unit test suite.

16. Write a Python class that implements a simple LRU cache

Problem: You need an in-memory cache with a size limit, evicting least recently used items.

Prompt:

Implement an LRUCache class with get(key) and put(key, value) methods. Use OrderedDict from collections. Both methods must be O(1) amortized. Raise KeyError if key not found. The constructor takes capacity: int. When capacity is exceeded, evict the least recently used item.

Why it works: OrderedDict-based LRU is an interview classic; this prompt ensures O(1) and proper error handling.

17. Write a script that validates JSON schema against a given JSON file

Problem: You need to ensure incoming JSON data conforms to a predefined schema.

Prompt:

Write a script using jsonschema library that validates a JSON data file against a JSON Schema file. Use jsonschema.validate(). If validation fails, print all errors with their paths. If passes, print "Schema valid". Accept two command-line arguments: --data and --schema.

Why it works: It uses the official jsonschema library, prints detailed errors, and is easy to integrate into CI pipelines.

18. Generate a FastAPI app with multiple routers and dependency injection

Problem: You want a modular FastAPI application structure for a larger project.

Prompt:

Create the following structure:
- app/main.py: FastAPI instance, include routers
- app/routers/users.py: endpoints GET /users/, POST /users/, GET /users/{id}
- app/routers/items.py: endpoints GET /items/, POST /items/
- app/dependencies.py: a dependency get_db() that returns a mock database session (just print "DB session")
Use APIRouter with prefix and tags. In main.py, include both routers.

Why it works: This prompt teaches modular FastAPI design, which is essential for real applications. The mock dependency makes it testable.

Conclusion

These 18 prompts cover the most frequent Python code generation scenarios I encounter in daily development — from file I/O and scheduling to async and FastAPI. By being explicit about libraries, error handling, and edge cases, each prompt yields production-quality code with minimal modifications. Try them with your favorite AI assistant, adapt the parameters, and watch your productivity multiply.

If you have a specific Python problem not covered here, leave a comment below — I’ll add it to the next edition.