🛣️ Routing and View Functions

What Is Routing?

Routing is the mechanism that maps URL patterns to the code that handles them. When a request arrives for a particular URL, the router decides which function in your application should process it and produce a response. That function is called a view function (or simply a "view").

💡 An analogy: Routing is the mailroom of a large office. A letter arrives (the request), the sorter reads the address (the URL), and delivers it to the right department (the view function). Get the addressing scheme right and everything lands where it should; get it wrong and mail piles up in the dead-letter bin (a 404).

Flask's Routing System

Flask connects URLs to functions with the @app.route() decorator. The string you pass is the URL rule; the function beneath it is the view that runs when the rule matches.

from flask import Flask

app = Flask(__name__)

@app.route("/")
def home():
    return "Welcome to the Home Page!"

@app.route("/about")
def about():
    return "About Us Page"

With the dev server running, visiting http://localhost:5000/ executes home(), and http://localhost:5000/about executes about(). The function's name also becomes its endpoint — the identifier url_for() uses later to build a link back to it.

URL Parameters & Converters

Real apps need URLs like /user/john or /post/42. Flask captures a dynamic segment with angle brackets and passes it to the view as an argument:

@app.route("/user/<username>")
def show_user_profile(username):
    return f"User profile: {username}"

Visiting /user/john calls show_user_profile("john"). By default a captured value is a string. Adding a converter both validates the segment and casts it to the right type:

@app.route("/post/<int:post_id>")
def show_post(post_id):
    # post_id arrives already an int
    return f"Post #{post_id}"

@app.route("/files/<path:subpath>")
def show_file(subpath):
    # path converter matches slashes too
    return f"File at: {subpath}"

HTTP Methods

By default a route answers only GET requests. To handle others, list them in the methods argument. A classic pattern is one route that both shows a form (GET) and processes it (POST):

from flask import request

@app.route("/login", methods=["GET", "POST"])
def login():
    if request.method == "POST":
        username = request.form["username"]
        password = request.form["password"]
        # ...authenticate the user...
        return f"Logging in {username}..."
    # GET: show the form
    return """
        <form method="post">
            <input type="text" name="username">
            <input type="password" name="password">
            <input type="submit" value="Login">
        </form>
    """

Anatomy of a View Function

A view function is where your application's logic lives for a given URL. Most views follow the same four-step shape: get data, handle edge cases, do any processing, and return a response.

from flask import render_template, abort

@app.route("/product/<int:product_id>")
def product_detail(product_id):
    # 1. Acquire data (e.g. from a database)
    product = get_product_from_database(product_id)

    # 2. Handle the not-found case
    if product is None:
        abort(404)

    # 3. Process / enrich the data
    similar = find_similar_products(product)

    # 4. Return a response (here, a rendered template)
    return render_template(
        "product_detail.html",
        product=product,
        similar_products=similar,
    )

Keeping this structure consistent makes views easy to read and test: each one acquires data, guards against bad input, prepares what the template needs, and hands back a response.

Response Types

A Flask view can return far more than a string. Here are the common shapes a response can take.

Plain string and HTML

@app.route("/hello")
def hello():
    return "Hello, World!"          # becomes a 200 text/html response

Rendered template

@app.route("/dashboard")
def dashboard():
    user = get_current_user()
    stats = get_user_stats(user.id)
    return render_template("dashboard.html", user=user, stats=stats)

JSON

from flask import jsonify

@app.route("/api/products")
def product_list_api():
    products = get_all_products()
    return jsonify(
        products=[p.to_dict() for p in products],
        count=len(products),
    )

Redirects

from flask import redirect, url_for

@app.route("/old-page")
def old_page():
    return redirect(url_for("new_page"))

@app.route("/new-page")
def new_page():
    return "This is the new page"

Custom status codes

@app.route("/created", methods=["POST"])
def created_example():
    return {"message": "Resource created"}, 201     # (body, status_code)

@app.route("/missing")
def missing_example():
    return "Not found", 404

Returning a tuple of (body, status_code) — or (body, status_code, headers) — lets you control the exact HTTP response without building a full Response object.

URL Building with url_for()

Never hard-code URLs in your templates or redirects. Instead, ask Flask to build them from the endpoint name with url_for():

from flask import url_for

@app.route("/")
def index():
    login_url = url_for("login")                       # -> /login
    profile_url = url_for("profile", username="john")  # -> /user/john
    return f'<a href="{login_url}">Login</a> <a href="{profile_url}">John</a>'

@app.route("/login")
def login():
    return "Login Page"

@app.route("/user/<username>")
def profile(username):
    return f"Profile page for {username}"

In Jinja2 templates you use the very same function: <a href="{{ url_for('profile', username=user.name) }}">.

Organizing with Blueprints

As an app grows, keeping every route in one file becomes unmanageable. Blueprints let you split routes into self-contained modules and register them under a common URL prefix.

# auth.py
from flask import Blueprint

auth_bp = Blueprint("auth", __name__, url_prefix="/auth")

@auth_bp.route("/login")
def login():
    return "Login page"

@auth_bp.route("/register")
def register():
    return "Registration page"

# app.py
from flask import Flask
from auth import auth_bp

app = Flask(__name__)
app.register_blueprint(auth_bp)

@app.route("/")
def index():
    return "Home page"

Because the blueprint sets url_prefix="/auth", its login view lives at /auth/login. Its endpoint becomes auth.login, so you link to it with url_for("auth.login").

Hands-on Exercise

from flask import Flask, request, abort, jsonify

app = Flask(__name__)

POSTS = [
    {"id": 1, "title": "Hello Flask", "category": "python", "body": "First post."},
    {"id": 2, "title": "Routing Deep Dive", "category": "python", "body": "URLs to views."},
    {"id": 3, "title": "Design Notes", "category": "design", "body": "On layout."},
]

def find_post(post_id):
    return next((p for p in POSTS if p["id"] == post_id), None)

@app.route("/")
def home():
    titles = ", ".join(p["title"] for p in POSTS)
    return f"<h1>Latest posts</h1><p>{titles}</p>"

@app.route("/post/<int:post_id>")
def post_detail(post_id):
    post = find_post(post_id)
    if post is None:
        abort(404)
    return f"<h1>{post['title']}</h1><p>{post['body']}</p>"

@app.route("/category/<name>")
def category(name):
    matches = [p["title"] for p in POSTS if p["category"] == name]
    return {"category": name, "posts": matches}

@app.route("/api/posts")
def api_posts():
    return jsonify(posts=POSTS, count=len(POSTS))

@app.route("/search")
def search():
    q = request.args.get("q", "").lower()
    hits = [p["title"] for p in POSTS if q in p["title"].lower()]
    return {"query": q, "results": hits}

if __name__ == "__main__":
    app.run(debug=True)

Summary & Quiz

📚 Further Reading

• Flask docs — Routing
• Flask docs — Modular Applications with Blueprints
• MDN — HTTP request methods

🚀 What's Next?

Your views can now return rendered templates — but we've been writing HTML as raw strings. Next you'll learn the Jinja2 template system: variables, control structures, filters, inheritance, and macros for producing clean, maintainable HTML.