Numeric validation (gt, lt, ge, le) in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a FastAPI endpoint receives a value violating gt constraint?

Consider this FastAPI endpoint using Pydantic for validation:

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI()

class Item(BaseModel):
    quantity: int = Field(..., gt=0)

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

What will be the response if the client sends {"quantity": 0}?

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI()

class Item(BaseModel):
    quantity: int = Field(..., gt=0)

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

A The server accepts the value and returns {"quantity": 0}.

B The server crashes with a TypeError due to invalid input.

C The server responds with a 422 Unprocessable Entity error explaining quantity must be greater than 0.

D The server responds with a 400 Bad Request without details.

💡 Hint

Think about how Pydantic validates fields with gt constraints.

Pydantic enforces the gt=0 constraint by rejecting values not greater than 0. FastAPI returns a 422 error with details about the validation failure.

📝 Syntax

intermediate

Which Field declaration correctly enforces value less than or equal to 10?

Choose the correct Pydantic Field declaration to ensure a numeric value is at most 10.

A value: int = Field(..., lt=10)

B value: int = Field(..., le=10)

C value: int = Field(..., ge=10)

D value: int = Field(..., gt=10)

💡 Hint

Remember: le means less than or equal, lt means less than.

le=10 means the value can be 10 or less. lt=10 excludes 10 itself.

🔧 Debug

advanced

Why does this FastAPI endpoint accept a score of null despite ge=0?

Examine this code snippet:

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI()

class Data(BaseModel):
    score: float = Field(ge=0)

@app.post("/data/")
async def post_data(data: Data):
    return {"score": data.score}

Why does sending {"score": null} not raise a validation error?

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI()

class Data(BaseModel):
    score: float = Field(ge=0)

@app.post("/data/")
async def post_data(data: Data):
    return {"score": data.score}

A Because the type float ignores Field constraints.

B Because the default value is missing, so the field is optional and validation is skipped.

C Because FastAPI does not validate numeric constraints automatically.

D Because the Field declaration lacks the required ellipsis (...) making the field optional and validation not enforced.

💡 Hint

Check how required fields are declared in Pydantic.

Without ... as the first argument, the field is optional and defaulted to None, so validation on input is not enforced.

❓ state_output

advanced

What is the value of 'price' after validation with ge and le constraints?

Given this Pydantic model:

class Product(BaseModel):
    price: float = Field(..., ge=1.0, le=100.0)

And this input JSON:

{"price": 100.0}

What will be the value of price in the validated model instance?

FastAPI

from pydantic import BaseModel, Field

class Product(BaseModel):
    price: float = Field(..., ge=1.0, le=100.0)

product = Product(price=100.0)
value = product.price

A 100.0

B 99.999999

C Raises a validation error because 100.0 is not less than 100.0

D None

💡 Hint

Check the meaning of le constraint.

le=100.0 means the value can be equal to 100.0, so 100.0 passes validation and is assigned as is.

🧠 Conceptual

expert

Which numeric validation combination allows values from 5 (inclusive) up to but not including 10?

Using Pydantic's Field constraints, which combination correctly restricts a number to be at least 5 and less than 10?

A Field(..., ge=5, lt=10)

B Field(..., gt=5, le=10)

C Field(..., ge=5, le=10)

D Field(..., gt=5, lt=10)

💡 Hint

Remember: ge means greater or equal, lt means less than.

ge=5 includes 5, lt=10 excludes 10, so values are from 5 up to but not including 10.