Python Introduction to Flask

Flask(__name__) creates the application: the object that stores routes, configuration and extensions, and handles every request. __name__ tells Flask where the app's module lives, so it can find templates and static files.

from flask import Flask

app = Flask(__name__)
app.config["MAX_SLOTS"] = 3

Save this as app.py and start the development server with flask --app app run --debug. --debug enables automatic reloading when you edit code, and an in-browser debugger for errors.

Installing Flask gives you the tools, not a design. As an app grows, structure it with blueprints (groups of related routes) and an application factory, a create_app() function that builds and configures the app. Factories make it easy to create a separate app with test settings, which matters once you write tests.

A route connects a URL path and HTTP method to a view function. What the function returns becomes the response:

bookings = {}

@app.get("/bookings/<int:booking_id>")
def get_booking(booking_id):
    booking = bookings.get(booking_id)
    if booking is None:
        return {"error": "booking not found"}, 404
    return booking

@app.post("/bookings")
def create_booking():
    ...

• @app.get and @app.post (Flask 2.0+) are shortcuts for @app.route(path, methods=[...]).
• <int:booking_id> captures part of the URL and converts it to an int, returning 404 automatically for non-numbers.
• Returning a dict produces a JSON response; returning a (body, status) tuple sets the status code; strings return HTML or text.

The dictionary above lives in memory, so bookings vanish when the server restarts and aren't shared between server processes. Real apps store data in a database, for example with the patterns from SQL CRUD with Python.

Inside a view, the request object holds the incoming data: request.args for the query string, request.form for HTML forms, and request.get_json() for JSON bodies.

from flask import request

@app.post("/bookings")
def create_booking():
    data = request.get_json(silent=True)
    if not isinstance(data, dict):
        return {"error": "send a JSON object"}, 400
    name = str(data.get("name", "")).strip()
    item = str(data.get("item", "")).strip()
    if not name or not item:
        return {"error": "name and item are required"}, 422
    booking_id = len(bookings) + 1
    bookings[booking_id] = {"id": booking_id, "name": name, "item": item}
    return bookings[booking_id], 201

Flask parses the JSON but doesn't validate it. A client can send missing fields, wrong types or a list instead of an object, so check everything you rely on and answer with a clear status: 400 for a malformed request, 422 for valid JSON that fails your rules, 201 when something was created. Libraries such as Pydantic or marshmallow help when there are many fields.

Flask's built-in server and debugger are for development only. The interactive debugger lets anyone who can reach the error page run Python code on the server, so it must never be enabled on a public server. The development server also isn't built for production traffic.

For testing, Flask provides a test client that sends requests to the app in-process, without a running server:

with app.test_client() as client:
    response = client.post("/bookings", json={"name": "Ana", "item": "Lamp"})
    assert response.status_code == 201

In production, run the app with a WSGI server such as Gunicorn or Waitress (gunicorn "app:app"), usually behind a reverse proxy such as Nginx that handles HTTPS. Turn debug off, set a strong SECRET_KEY from an environment variable, use a real database, and log errors. Platforms such as Render, Fly.io and cloud services follow the same pattern.

Task: create a validated booking route, add test client checks and document a production deployment boundary. Add a DELETE /bookings/<int:booking_id> route to the example app that returns 204 on success and 404 if the booking doesn't exist, then test both cases:

@app.delete("/bookings/<int:booking_id>")
def delete_booking(booking_id):
    if bookings.pop(booking_id, None) is None:
        return {"error": "booking not found"}, 404
    return "", 204

with app.test_client() as client:
    client.post("/bookings", json={"name": "Cara", "item": "Radio"})
    print(client.delete("/bookings/1").status_code)   # 204
    print(client.delete("/bookings/1").status_code)   # 404

Document the boundary in your README: "Development: flask --app app run --debug. Production: Gunicorn behind HTTPS with debug disabled." For the worked check: should the Flask development debugger be exposed in production? No. It allows code execution from the browser.

The official Flask quickstart, testing guide and deployment options are the best next reads. Continue with the NumPy tutorial or revisit HTTP and REST. Practise with the Python exercises and Python quiz.