Route decorator syntax in FastAPI

Introduction

Route decorators tell FastAPI which web address should run a specific function. They connect URLs to your code.

When you want to create a web page or API endpoint for users to visit.

When you need to handle different HTTP methods like GET or POST for a URL.

When you want to organize your web app by linking URLs to functions clearly.

When you want to add parameters to URLs and get data from users.

When you want to build REST APIs that respond to client requests.

Syntax

FastAPI

@app.<http_method>("/path")
def function_name():
    # code to run
    return response

The @app.get(), @app.post(), etc., are decorators that tell FastAPI which HTTP method and path to use.

The function below the decorator runs when someone visits that URL with that method.

Examples

This creates a GET route at the root URL that returns a simple message.

FastAPI

@app.get("/")
def read_root():
    return {"message": "Hello World"}

This creates a POST route at /items that accepts data and returns it.

FastAPI

@app.post("/items")
def create_item(item: dict):
    return {"item": item}

This route uses a path parameter to get a user ID from the URL.

FastAPI

@app.get("/users/{user_id}")
def read_user(user_id: int):
    return {"user_id": user_id}

Sample Program

This FastAPI app has two routes: one at the root URL that welcomes users, and one that greets a user by name from the URL.

FastAPI

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Welcome to FastAPI!"}

@app.get("/hello/{name}")
def say_hello(name: str):
    return {"greeting": f"Hello, {name}!"}

Important Notes

Route decorators must be placed directly above the function they decorate.

Use different HTTP methods like get, post, put, delete depending on what action you want.

Path parameters are defined with curly braces in the route string and become function arguments.

Summary

Route decorators link URLs and HTTP methods to Python functions.

They help build web APIs by defining what code runs on each URL.

FastAPI uses simple syntax with @app.get(), @app.post(), etc. to create routes.

Practice

1. What does the @app.get("/items") decorator do in FastAPI?

easy

A. It deletes the route for '/items' from the app.

B. It creates a route that responds to POST requests at the URL path '/items'.

C. It defines a function that runs only when the server starts.

D. It creates a route that responds to GET requests at the URL path '/items'.

Solution

1. Step 1: Understand the decorator purpose

   The @app.get() decorator in FastAPI is used to create a route that listens for HTTP GET requests.

2. Step 2: Match the URL path

   The string inside the parentheses, here '/items', specifies the URL path this route will respond to.

3. Final Answer:

   It creates a route that responds to GET requests at the URL path '/items'. -> Option D

4. Quick Check:

   @app.get() = GET route [OK]

Hint: GET decorator means respond to GET requests [OK]

Common Mistakes:

• Confusing @app.get with @app.post
• Thinking it runs on server start
• Assuming it deletes routes

2. Which of the following is the correct syntax to create a POST route for path '/submit' in FastAPI?

easy

A. @app.post('/submit')

B. @app.get('/submit')

C. @app.route('/submit', method='POST')

D. @app.post('/submit', method='GET')

Solution

1. Step 1: Identify the correct decorator for POST

   FastAPI uses @app.post() to define routes that handle POST requests.

2. Step 2: Check the path argument

   The path '/submit' should be passed as a string inside the parentheses.

3. Final Answer:

   @app.post('/submit') -> Option A

4. Quick Check:

   POST route syntax = @app.post(path) [OK]

Hint: Use @app.post() for POST routes with path string [OK]

Common Mistakes:

• Using @app.get for POST routes
• Trying to pass method='POST' inside @app.post
• Using @app.route which is not FastAPI syntax

3. What will be the output when accessing the URL '/hello' if the following FastAPI code is used?

from fastapi import FastAPI
app = FastAPI()

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

medium

A. Hello, FastAPI!

B. 404 Not Found error

C. {"message": "Hello, FastAPI!"}

D. 500 Internal Server Error

Solution

1. Step 1: Identify the route and method

   The route '/hello' is defined with @app.get('/hello'), so GET requests to '/hello' will call say_hello().

2. Step 2: Check the function return value

   The function returns a dictionary with key 'message' and value 'Hello, FastAPI!'. FastAPI automatically converts this to JSON.

3. Final Answer:

   "{\"message\": \"Hello, FastAPI!\"}" -> Option C

4. Quick Check:

   Route returns dict = JSON response [OK]

Hint: Return dict in route becomes JSON response [OK]

Common Mistakes:

• Expecting plain string instead of JSON
• Assuming 404 error without route
• Confusing error codes with correct response

4. Identify the error in this FastAPI route definition:

from fastapi import FastAPI
app = FastAPI()

@app.get('/data')
def get_data():
print("Fetching data")
    return {"data": 123}

medium

A. Indentation error in the function body.

B. Missing parentheses in @app.get decorator.

C. Route path should not start with a slash.

D. Function name cannot be get_data.

Solution

1. Step 1: Check function body indentation

   Python requires the function body to be indented. Here, print("Fetching data") is not indented properly.

2. Step 2: Verify decorator and path syntax

   The decorator @app.get('/data') is correct, and the path starting with '/' is valid in FastAPI.

3. Final Answer:

   Indentation error in the function body. -> Option A

4. Quick Check:

   Python functions need indented bodies [OK]

Hint: Check indentation inside function after decorator [OK]

Common Mistakes:

• Ignoring Python indentation rules
• Thinking path cannot start with '/'
• Assuming decorator needs no parentheses

5. You want to create a FastAPI route that handles both GET and POST requests on the path '/process'. Which is the correct way to write the decorators?

hard

A. @app.get_post('/process')

B. @app.get('/process')
@app.post('/process')

C. @app.route('/process', methods=['GET', 'POST'])

D. @app.get('/process', methods=['GET', 'POST'])

Solution

1. Step 1: Understand FastAPI route decorators

   FastAPI does not have a combined decorator for multiple methods. Instead, you add multiple decorators for each method on the same function.

2. Step 2: Check each option's validity

   @app.get('/process') @app.post('/process') uses two decorators @app.get and @app.post on the same function, which is correct. @app.route('/process', methods=['GET', 'POST']) uses Flask-style syntax which is invalid in FastAPI. Options A and D use non-existent decorators or invalid parameters.

3. Final Answer:

   @app.get('/process') @app.post('/process') -> Option B

4. Quick Check:

   Multiple decorators for multiple methods [OK]

Hint: Use multiple decorators for multiple HTTP methods [OK]

Common Mistakes:

• Trying to use Flask-style @app.route
• Assuming combined decorator exists
• Passing methods param to @app.get