Route decorator syntax in FastAPI - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the @app.get() decorator in FastAPI?

It defines a route that listens for HTTP GET requests at the specified path and links it to a function that handles those requests.

beginner

How do you specify the URL path for a route in FastAPI?

You pass the path as a string argument inside the route decorator, for example, @app.post('/items/') sets the route to '/items/'.

beginner

What HTTP methods can you use with FastAPI route decorators?

Common methods include @app.get(), @app.post(), @app.put(), @app.delete(), and @app.patch().

intermediate

How do you add a route that accepts any HTTP method in FastAPI?

Use the @app.api_route() decorator and specify the methods list, for example: @app.api_route('/path', methods=['GET', 'POST']).

beginner

What does the function decorated by a FastAPI route decorator return?

It returns the response data that FastAPI converts to JSON or another response format to send back to the client.

Which decorator would you use to create a route that handles HTTP POST requests in FastAPI?

A @app.get()

B @app.post()

C @app.put()

D @app.delete()

The @app.post() decorator is used to define routes that handle POST requests.

How do you define a route for the URL path '/users' that accepts GET requests?

A @app.get('/users')

B @app.post('/users')

C @app.route('/users')

D @app.api_route('/users')

The @app.get('/users') decorator sets a GET route for the '/users' path.

What is the correct way to create a route that accepts both GET and POST methods?

A @app.api_route('/path', methods=['GET', 'POST'])

B @app.get('/path', methods=['POST'])

C @app.post('/path', methods=['GET'])

D @app.route('/path')

The @app.api_route decorator allows specifying multiple HTTP methods.

What does the function decorated by a route decorator usually return?

A The URL path string

B The HTTP method name

C Response data to send back to the client

D Nothing

The function returns data that FastAPI sends as the HTTP response.

Which of these is NOT a valid FastAPI route decorator?

A @app.delete()

B @app.get()

C @app.put()

D @app.fetch()

@app.fetch() is not a valid FastAPI route decorator.

Explain how to create a GET route in FastAPI and what the decorated function should do.

Think about how you tell FastAPI what URL to listen to and what to send back.

Describe how to handle multiple HTTP methods for a single route in FastAPI.

Remember the decorator that lets you list methods.

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