Route decorator syntax in FastAPI - Step-by-Step Execution

Concept Flow - Route decorator syntax

Define function

↓

Apply @app.route decorator

↓

Register route with path and method

↓

Wait for HTTP request

↓

If request matches path and method

↓

Call decorated function

↓

Return response to client

This flow shows how a function is decorated with a route, registered, and called when a matching HTTP request arrives.

Execution Sample

FastAPI

from fastapi import FastAPI
app = FastAPI()

@app.get("/hello")
async def say_hello():
    return {"message": "Hello!"}

Defines a GET route at /hello that returns a JSON greeting message.

Execution Table

Step	Action	Evaluation	Result
1	Define async function say_hello	Function created	Function object stored
2	Apply @app.get("/hello") decorator	Register route '/hello' with GET method	Route added to app's routing table
3	Start FastAPI server	Server listens for requests	Ready to accept HTTP requests
4	Receive GET request at /hello	Match request path and method	Route matched, call say_hello()
5	Execute say_hello()	Return {'message': 'Hello!'}	Response JSON generated
6	Send response to client	HTTP 200 with JSON body	Client receives greeting message

💡 Execution stops after response sent to client.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 5	Final
say_hello	undefined	function object	function object	function object	function object
app.routes	empty list	contains route '/hello' GET	contains route '/hello' GET	contains route '/hello' GET	contains route '/hello' GET
request	none	none	GET /hello request object	GET /hello request object	none
response	none	none	none	{'message': 'Hello!'}	sent to client

Key Moments - 3 Insights

Why do we use @app.get("/hello") above the function?

The decorator registers the function as the handler for GET requests to '/hello'. Without it, the function won't be called on requests. See execution_table step 2.

What happens if a request comes to a different path?

FastAPI checks registered routes and finds no match, so it returns a 404 error. This is because only '/hello' is registered here (execution_table step 4).

Why is the function defined as async?

FastAPI supports async functions to handle requests efficiently. The async keyword allows the server to handle other tasks while waiting for this function to complete (execution_table step 5).

Visual Quiz - 3 Questions

Look at the execution table, what is the state of app.routes after step 2?

A It contains the route '/hello' with GET method

B It is still empty

C It contains the route '/hello' with POST method

D It contains multiple routes

💡 Hint

Check the 'app.routes' variable in variable_tracker after step 2.

At which step does FastAPI call the decorated function to handle the request?

A Step 2

B Step 5

C Step 4

D Step 6

💡 Hint

Look at execution_table where the function execution and response generation happen.

If we change @app.get to @app.post, what changes in the execution?

A Both GET and POST requests will call the function

B GET requests to '/hello' will still call the function

C POST requests to '/hello' will call the function instead of GET

D No requests will call the function

💡 Hint

Consider how the route method affects which HTTP requests trigger the function (see execution_table step 2 and 4).

Concept Snapshot

Route decorator syntax in FastAPI:
- Use @app.get('/path') or @app.post('/path') above async function
- Registers function as handler for HTTP method and path
- When matching request arrives, FastAPI calls function
- Function returns response (usually JSON)
- Async functions improve server efficiency

Full Transcript

In FastAPI, you define a function and decorate it with @app.get or @app.post to register it as a route handler. The decorator tells FastAPI which URL path and HTTP method the function should respond to. When the server runs and receives a request, it checks if the path and method match any registered routes. If yes, it calls the decorated function and sends back its return value as the response. This example shows a GET route at '/hello' that returns a JSON greeting. The function is async to allow efficient handling of requests. The execution table traces defining the function, applying the decorator, receiving a request, calling the function, and sending the response. Variables like the function object, app routes, request, and response change state during these steps. Common confusions include why decorators are needed, what happens on unmatched paths, and why async is used. The visual quiz tests understanding of route registration, function calling, and HTTP method effects.