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.

Practice

1. In FastAPI, which parameter would you use in a Pydantic Field to ensure a number is strictly greater than 10?

easy

A. gt=10

B. lt=10

C. ge=10

D. le=10

Solution

1. Step 1: Understand the meaning of gt

   The gt parameter means "greater than" and excludes the value itself.

2. Step 2: Match the requirement

   Since the question asks for strictly greater than 10, gt=10 is the correct choice.

3. Final Answer:

   gt=10 -> Option A

4. Quick Check:

   Strictly greater than 10 = gt=10 [OK]

Hint: Use gt for strictly greater than, ge for greater or equal [OK]

Common Mistakes:

• Confusing gt with ge and using ge=10 instead
• Using lt or le which mean less than
• Thinking gt includes the number 10

2. Which of the following is the correct syntax to validate a number field in FastAPI to be less than or equal to 100 using Pydantic?

easy

A. Field(ge=100)

B. Field(lt=100)

C. Field(le=100)

D. Field(gt=100)

Solution

1. Step 1: Identify the parameter for less than or equal

   The parameter le stands for "less than or equal to".

2. Step 2: Check the syntax

   The correct syntax is Field(le=100) to enforce the value to be at most 100.

3. Final Answer:

   Field(le=100) -> Option C

4. Quick Check:

   Less than or equal to 100 = le=100 [OK]

Hint: Use le for less or equal, lt for strictly less [OK]

Common Mistakes:

• Using lt=100 which excludes 100
• Using ge or gt which are for greater values
• Writing Field(le100) without equals sign

3. Given this FastAPI model snippet:

from pydantic import BaseModel, Field

class Item(BaseModel):
    price: float = Field(gt=0, le=100)

What happens if you send a request with price=0?

medium

A. Accepted because price is a float

B. Accepted because price is less than or equal to 100

C. Validation error because price must be less than or equal to 0

D. Validation error because price must be greater than 0

Solution

1. Step 1: Analyze the validation rules

   The field has gt=0 (greater than 0) and le=100 (less or equal to 100).

2. Step 2: Check the input value

   Input price is 0, which is not greater than 0, so it violates the gt=0 rule.

3. Final Answer:

   Validation error because price must be greater than 0 -> Option D

4. Quick Check:

   Price 0 fails gt=0 validation [OK]

Hint: gt excludes the number itself; 0 is not > 0 [OK]

Common Mistakes:

• Thinking 0 passes because it is less than 100
• Confusing gt with ge and allowing 0
• Ignoring validation errors in FastAPI

4. You wrote this FastAPI model:

from pydantic import BaseModel, Field

class User(BaseModel):
    age: int = Field(ge=18, lt=65)

But when you send age=65, it passes validation. Why?

medium

A. Because lt=65 means less than 65, so 65 should fail but it passes because you used le=65 instead of lt=65

B. Because lt=65 means less than 65, so 65 should fail but it passes because you used ge incorrectly

C. Because lt=65 means less than 65, so 65 should fail but it passes because the validation is not enforced on int

D. Because lt=65 means age must be less than 65, so 65 should fail but it passes due to a bug

Solution

1. Step 1: Understand the meaning of lt and le

   lt=65 means strictly less than 65, so 65 should fail validation.

2. Step 2: Identify the cause of passing validation

   If 65 passes, likely the code uses le=65 (less or equal) instead of lt=65, allowing 65.

3. Final Answer:

   Because lt=65 means less than 65, so 65 should fail but it passes because you used le=65 instead of lt=65 -> Option A

4. Quick Check:

   lt excludes value; le includes it [OK]

Hint: lt excludes value; le includes it. Check which you used [OK]

Common Mistakes:

• Confusing lt and le parameters
• Assuming validation is not enforced on integers
• Thinking ge affects upper bound

5. You want to create a FastAPI model for a product rating that must be between 1 and 5 inclusive. Which is the correct way to define this field using Pydantic validation?

hard

A. rating: int = Field(gt=1, lt=5)

B. rating: int = Field(ge=1, le=5)

C. rating: int = Field(gt=1, le=5)

D. rating: int = Field(ge=1, lt=5)

Solution

1. Step 1: Understand inclusive range requirements

   Inclusive means the value can be equal to the limits, so use ge (greater or equal) and le (less or equal).

2. Step 2: Match parameters to the range 1 to 5 inclusive

   Use ge=1 and le=5 to allow 1 and 5 as valid values.

3. Final Answer:

   rating: int = Field(ge=1, le=5) -> Option B

4. Quick Check:

   Inclusive range uses ge and le [OK]

Hint: Use ge and le for inclusive ranges, gt and lt for exclusive [OK]

Common Mistakes:

• Using gt or lt excludes boundary values
• Mixing gt with le or ge with lt incorrectly
• Forgetting to include both bounds