Optional and nullable fields in FastAPI - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean for a field to be optional in FastAPI?

An optional field means you don't have to include it in the request. If you leave it out, FastAPI will use a default value or None.

beginner

How do you declare a field as nullable in FastAPI using Pydantic?

You declare a field as nullable by allowing it to have the value None, usually by typing it as Optional[type] or type | None.

intermediate

What is the difference between Optional[str] and str | None in FastAPI models?

Both mean the field can be a string or None. str | None is the modern Python 3.10+ syntax, while Optional[str] is from the typing module.

beginner

In FastAPI, what happens if you set a field as Optional[str] = None in a Pydantic model?

The field is optional in the request and can be omitted. If omitted, its value will be None inside your code.

intermediate

Why is it important to distinguish between optional and nullable fields in FastAPI?

Optional means the field can be missing from the request. Nullable means the field can be present but set to None. This affects validation and how your app handles data.

In FastAPI, how do you make a field optional in a Pydantic model?

A Set the field type as Optional[type] and provide a default value

B Use the @optional decorator

C Make the field private

D Set the field type as type without default

To make a field optional, you use Optional[type] and give it a default value like None.

What does a nullable field allow in FastAPI?

A The field can be missing from the request

B The field can have the value None

C The field must be a string

D The field is always required

Nullable means the field can be present but set to None.

Which Python syntax is modern and recommended for nullable fields in FastAPI models?

A Optional[str]

B Any

C str | None

D Union[str, int]

The modern Python 3.10+ syntax uses the | operator for unions, like str | None.

If a field is declared as name: str without a default, what does FastAPI expect?

A The field is required in the request

B The field can be None

C The field is optional

D The field is ignored

Without a default, FastAPI treats the field as required.

What is the effect of setting a field as Optional[str] = None in FastAPI?

A Field must be a string

B Field is required and cannot be None

C Field is ignored

D Field is optional and defaults to None if missing

This means the field can be omitted and will be None if not provided.

Explain how to use optional and nullable fields in FastAPI Pydantic models. Include how to declare them and what happens if they are missing or set to None.

Think about Python typing and default values.

Describe the difference between a field being optional and nullable in FastAPI and why it matters for API design.

Consider how clients send data and how your app reads it.

Practice

1. In FastAPI, what does it mean when a field is declared as Optional[str] in a request model?

easy

A. The field is required and cannot be None.

B. The field must always be provided with a string value.

C. The field can only be an empty string but not None.

D. The field can be omitted or set to None in the request.

Solution

1. Step 1: Understand Optional type in FastAPI

   Optional[str] means the field can be missing or have a value of type str or None.

2. Step 2: Interpret the meaning for API requests

   This allows clients to omit the field or explicitly send null (None) as its value.

3. Final Answer:

   The field can be omitted or set to None in the request. -> Option D

4. Quick Check:

   Optional[str] = omitted or None [OK]

Hint: Optional means field can be missing or None [OK]

Common Mistakes:

• Thinking Optional means field is always required
• Confusing Optional with default values
• Assuming Optional forbids None

2. Which of the following is the correct way to declare a nullable string field in a FastAPI Pydantic model?

easy

A. name: Optional[str] = None

B. name: str | None = None

C. name: str = None

D. name: str?

Solution

1. Step 1: Recall Pydantic syntax for optional and nullable fields

   To allow a field to be nullable and optional, use Optional[str] with a default None.

2. Step 2: Check each option

   A is invalid because just assigning None to str without Optional is not correct. B is valid Python 3.10+ syntax but C is the recommended explicit way in FastAPI. D is invalid syntax.

3. Final Answer:

   name: Optional[str] = None -> Option A

4. Quick Check:

   Nullable string = Optional[str] = None [OK]

Hint: Use Optional[type] with = None for nullable fields [OK]

Common Mistakes:

• Using just type with = None without Optional
• Using invalid syntax like str?
• Confusing Optional with just default values

3. Given this FastAPI model:

from typing import Optional
from pydantic import BaseModel

class User(BaseModel):
    name: str
    nickname: Optional[str] = None

user = User(name='Alice')

What will be the value of user.nickname?

medium

A. '' (empty string)

B. 'Alice'

C. None

D. Raises an error

Solution

1. Step 1: Analyze the model fields and defaults

   The nickname field is Optional[str] with a default of None, so if not provided, it defaults to None.

2. Step 2: Check the instance creation

   When creating user with only name='Alice', nickname is not set, so it uses the default None.

3. Final Answer:

   None -> Option C

4. Quick Check:

   Optional field missing = None [OK]

Hint: Missing optional field defaults to None [OK]

Common Mistakes:

• Assuming nickname defaults to empty string
• Thinking nickname copies name value
• Expecting an error for missing optional field

4. What is wrong with this FastAPI model declaration?

from typing import Optional
from pydantic import BaseModel

class Item(BaseModel):
    description: Optional[str]

medium

A. Optional[str] is not allowed in Pydantic models.

B. Missing default value for Optional field causes validation error.

C. Field description must be declared as str, not Optional[str].

D. No import for Optional is present.

Solution

1. Step 1: Understand Optional fields in Pydantic

   Optional means the field can be None or missing, but Pydantic requires a default value for optional fields.

2. Step 2: Check the model declaration

   The field description is Optional[str] but has no default value, so Pydantic will expect it to be provided and raise an error if missing.

3. Final Answer:

   Missing default value for Optional field causes validation error. -> Option B

4. Quick Check:

   Optional fields need default values [OK]

Hint: Optional fields must have default values [OK]

Common Mistakes:

• Omitting default None for Optional fields
• Thinking Optional alone makes field optional
• Ignoring Pydantic validation rules

5. You want to create a FastAPI model where the field email can be omitted, but if present, it can be set to null explicitly. Which is the best way to declare this field?

hard

A. email: Optional[str] = None

B. email: str = None

C. email: str | None

D. email: Optional[str]

Solution

1. Step 1: Understand requirements for the field

   The field must be optional (can be omitted) and nullable (can be None explicitly).

2. Step 2: Evaluate each declaration

   B lacks Optional and default None, so it is not optional. C lacks default None, so field is required. D lacks default None, so field is required. A uses Optional[str] with default None, making it optional and nullable.

3. Final Answer:

   email: Optional[str] = None -> Option A

4. Quick Check:

   Optional with default None = optional and nullable [OK]

Hint: Use Optional[type] with = None for optional nullable fields [OK]

Common Mistakes:

• Forgetting to assign default None
• Using union without default value
• Assuming Optional alone makes field optional