FastAPI vs Flask vs Django comparison - Practice Questions

Challenge - 5 Problems

❓ component_behavior

intermediate

How does FastAPI handle request validation compared to Flask and Django?

Consider how each framework processes incoming data and validates it automatically or manually. Which statement best describes FastAPI's approach?

A FastAPI requires manual validation of request data similar to Flask, while Django automatically validates using Python type hints.

B Flask automatically validates request data using decorators, FastAPI requires manual validation, and Django does not support validation.

C Django uses Python type hints for validation, Flask uses forms, and FastAPI does not validate request data.

D FastAPI uses Python type hints to automatically validate and convert request data, unlike Flask which requires manual validation and Django which uses forms or serializers.

💡 Hint

Think about how FastAPI leverages modern Python features to reduce boilerplate.

FastAPI uses Python type hints to automatically validate and convert incoming request data. Flask requires developers to write validation code manually. Django uses forms or serializers for validation but does not use Python type hints in the same way.

📝 Syntax

intermediate

Which code snippet correctly creates a simple GET endpoint in FastAPI?

Select the code that defines a GET endpoint at path '/' returning JSON {'message': 'Hello'} in FastAPI.

A

from fastapi import FastAPI
app = FastAPI()

@app.get('/')
async def root():
    return {'message': 'Hello'}

B

from flask import Flask
app = Flask(__name__)

@app.route('/')
def root():
    return {'message': 'Hello'}

C

from django.http import JsonResponse

def root(request):
    return JsonResponse({'message': 'Hello'})

D

import fastapi
app = fastapi.FastAPI()

@app.post('/')
def root():
    return {'message': 'Hello'}

💡 Hint

Look for the FastAPI decorator for GET and async function.

FastAPI uses the @app.get decorator for GET endpoints and supports async functions. Flask uses @app.route and synchronous functions. Django uses views returning JsonResponse. Option A uses POST instead of GET.

❓ lifecycle

advanced

What happens when you add a middleware in FastAPI compared to Flask and Django?

Which statement best describes middleware behavior differences among FastAPI, Flask, and Django?

A FastAPI middleware runs before and after each request asynchronously, Flask middleware runs synchronously, and Django middleware runs synchronously but supports hooks at multiple points.

B Django middleware runs only after the response, FastAPI middleware runs only before the request, Flask middleware runs both before and after synchronously.

C Flask middleware runs asynchronously, FastAPI middleware runs synchronously, and Django middleware does not exist.

D All three frameworks run middleware only after the response is generated.

💡 Hint

Consider async support and lifecycle hooks in each framework.

FastAPI middleware supports async functions and runs before and after requests. Flask middleware is synchronous and simpler. Django middleware runs synchronously but has multiple hooks for request and response processing.

🔧 Debug

advanced

Why does this FastAPI code raise a validation error but similar Flask code does not?

Given this FastAPI endpoint: from fastapi import FastAPI from pydantic import BaseModel app = FastAPI() class Item(BaseModel): name: str price: float @app.post('/items/') async def create_item(item: Item): return item Why would sending {'name': 'Book', 'price': 'free'} cause an error in FastAPI but not in Flask?

A Flask raises a validation error too, but it is silent and does not stop execution.

B Flask automatically converts 'price' to float, but FastAPI does not support type conversion.

C FastAPI uses Pydantic to enforce type validation and rejects 'price' as a string, while Flask does not validate types automatically.

D FastAPI requires all fields to be strings, so 'price' as float causes error, Flask accepts any type.

💡 Hint

Think about how FastAPI uses Pydantic models for input validation.

FastAPI uses Pydantic models to validate and convert input data types. If 'price' is given as a string 'free', it cannot convert to float and raises a validation error. Flask does not validate input types automatically, so it accepts the data as is.

🧠 Conceptual

expert

Which framework is best suited for building a high-performance asynchronous API with automatic docs and why?

Choose the framework that naturally supports asynchronous programming, automatic interactive API documentation, and modern Python features.

A Flask, because it has built-in async support and automatic API documentation generation.

B FastAPI, because it is built on ASGI, supports async/await natively, and generates OpenAPI docs automatically.

C Django, because it is the oldest and most stable framework with async support and automatic docs.

D None of these frameworks support asynchronous programming or automatic docs.

💡 Hint

Consider which framework was designed with async and docs in mind from the start.

FastAPI is designed for high-performance async APIs using ASGI. It uses Python type hints and Pydantic for validation and automatically generates OpenAPI and Swagger UI docs. Flask and Django have limited or no native async support and require extra tools for docs.