First FastAPI application - Mini Project: Build & Apply

First FastAPI application

📖 Scenario: You want to create a simple web API that responds with a greeting message. This is useful when you want to start learning how to build web services that can be accessed from browsers or other programs.

🎯 Goal: Build a basic FastAPI application that has one route / which returns a JSON response with a greeting message.

📋 What You'll Learn

Create a FastAPI app instance named app

Define a GET route for path /

The route function should be named read_root

The route should return a dictionary with key message and value Hello, FastAPI!

💡 Why This Matters

🌍 Real World

FastAPI is used to build fast and modern web APIs that can serve data to web apps, mobile apps, or other services.

💼 Career

Knowing how to create basic FastAPI apps is essential for backend developers working with Python to build scalable APIs.

1

Create FastAPI app instance

Import FastAPI from fastapi and create an app instance called app.

FastAPI

# Import FastAPI and create app instance
# Your code here

Hint

Use from fastapi import FastAPI and then app = FastAPI().

2

Define GET route for root path

Use the @app.get("/") decorator to define a GET route for the root path /.

FastAPI

from fastapi import FastAPI

app = FastAPI()

# Define GET route for path '/' here
# Your code here

Hint

Use @app.get("/") above a function named read_root.

3

Return greeting message from route

Inside the read_root function, return a dictionary with key message and value Hello, FastAPI!.

FastAPI

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    # Return greeting message here
    # Your code here

Hint

Return a dictionary like {"message": "Hello, FastAPI!"}.

4

Complete FastAPI app

Ensure the full code has the import, app instance, route decorator, function read_root, and the return statement with the greeting message.

FastAPI

from fastapi import FastAPI

app = FastAPI()

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

# Your code here if needed

Hint

Check that all parts are present: import, app, route, function, and return.

Practice

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

easy

A. It starts the FastAPI server automatically.

B. It imports the FastAPI library into the project.

C. It defines a route that responds to HTTP GET requests at the root URL.

D. It creates a database connection for the app.

Solution

1. Step 1: Understand the decorator role

   The @app.get("/") decorator tells FastAPI to listen for GET requests at the root URL path.

2. Step 2: Connect decorator to route handling

   When a user visits the root URL with a GET request, the function below this decorator runs and returns a response.

3. Final Answer:

   It defines a route that responds to HTTP GET requests at the root URL. -> Option C

4. Quick Check:

   Route decorator = defines GET route [OK]

Hint: Decorators like @app.get define routes for HTTP GET requests [OK]

Common Mistakes:

• Thinking @app.get starts the server
• Confusing route decorators with imports
• Assuming it creates database connections

2. Which of the following is the correct way to create a FastAPI app instance?

easy

A. app = FastAPI.create()

B. app = FastAPI()

C. app = FastAPI

D. app = fastapi()

Solution

1. Step 1: Recall FastAPI app creation syntax

   The FastAPI app is created by calling the FastAPI class with parentheses: FastAPI().

2. Step 2: Check each option for correctness

   app = FastAPI() correctly calls FastAPI(). app = fastapi() uses lowercase which is incorrect. app = FastAPI misses parentheses, so it is a class reference, not an instance. app = FastAPI.create() uses a non-existent method.

3. Final Answer:

   app = FastAPI() -> Option B

4. Quick Check:

   FastAPI instance = FastAPI() [OK]

Hint: Create app with FastAPI() including parentheses [OK]

Common Mistakes:

• Omitting parentheses when creating app
• Using lowercase 'fastapi' instead of 'FastAPI'
• Trying to call a non-existent create() method

3. Given this FastAPI code snippet, what will be the JSON response when accessing /hello?

from fastapi import FastAPI
app = FastAPI()

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

medium

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

B. "Hello, FastAPI!"

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

D. 404 Not Found error

Solution

1. Step 1: Identify route and return value

   The route /hello is defined with a GET method. The function returns a dictionary with key "message" and value "Hello, FastAPI!".

2. Step 2: Understand FastAPI response format

   FastAPI automatically converts returned dictionaries to JSON responses. So the response will be JSON with the same key-value pair.

3. Final Answer:

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

4. Quick Check:

   Returned dict = JSON response [OK]

Hint: Returned dict becomes JSON response automatically [OK]

Common Mistakes:

• Expecting plain string instead of JSON
• Confusing function name as JSON key
• Assuming route does not exist causing 404

4. What is wrong with this FastAPI code?

from fastapi import FastAPI
app = FastAPI()

@app.get("/items")
def read_items():
return {"items": [1, 2, 3]}

medium

A. The import statement is incorrect.

B. The route path should be '/item' not '/items'.

C. FastAPI does not support returning lists in JSON.

D. The function read_items is missing an indentation for the return statement.

Solution

1. Step 1: Check Python syntax indentation

   Python requires the return statement inside the function to be indented. Here, return is not indented, causing a syntax error.

2. Step 2: Verify other parts

   The route path '/items' is valid, returning lists is supported, and the import is correct.

3. Final Answer:

   The function read_items is missing an indentation for the return statement. -> Option D

4. Quick Check:

   Python indentation error = missing indent [OK]

Hint: Indent return inside function to avoid syntax errors [OK]

Common Mistakes:

• Ignoring Python indentation rules
• Thinking route path must be singular
• Believing FastAPI can't return lists

5. You want to create a FastAPI app that returns a greeting with a user name from the URL path, like /greet/Alice. Which code correctly implements this?

hard

A. from fastapi import FastAPI
app = FastAPI()

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

B. from fastapi import FastAPI
app = FastAPI()

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

C. from fastapi import FastAPI
app = FastAPI()

@app.get("/greet/{name}")
def greet():
return {"greeting": "Hello!"}

D. from fastapi import FastAPI
app = FastAPI()

@app.get("/greet/{name}")
def greet(name):
return {"greeting": "Hello, name!"}

Solution

1. Step 1: Use path parameter in route

   The route must include {name} in the path to capture the user name from the URL.

2. Step 2: Define function with typed parameter and return greeting

   The function should accept name: str and return a dictionary with a greeting using an f-string to insert the name.

3. Step 3: Check other options for errors

   from fastapi import FastAPI app = FastAPI() @app.get("/greet") def greet(name: str): return {"greeting": f"Hello, {name}!"} misses the path parameter in the route. from fastapi import FastAPI app = FastAPI() @app.get("/greet/{name}") def greet(): return {"greeting": "Hello!"} does not accept the name parameter. from fastapi import FastAPI app = FastAPI() @app.get("/greet/{name}") def greet(name): return {"greeting": "Hello, name!"} does not use f-string, so it returns the literal text "name".

4. Final Answer:

   Uses path parameter and returns personalized greeting. -> Option A

5. Quick Check:

   Path param + f-string = personalized greeting [OK]

Hint: Use {param} in route and f-string to insert it in response [OK]

Common Mistakes:

• Not including path parameter in route string
• Forgetting to type the function parameter
• Returning literal string instead of formatted string