FastAPI Flashcards

Question

Which of the following is NOT a benefit of using summary and description features in FastAPI? A) Improved documentation B) Enhanced security C) Clearer API understanding D) Better usability

Answer 1

B) Enhanced security

Answer 2

Detailed information about the endpoint's purpose, usage, and any relevant details for users.

Answer 3

To define and organize the application's endpoints and their associated HTTP methods.

Answer 4

app.include_router()

Answer 5

They help in organizing code into modular components, making it easier to manage and maintain.

Answer 6

It is used to define additional information about parameters in API endpoints.

Answer 7

D) response

Answer 8

It provides a human-readable name for the parameter in the generated documentation.

Answer 9

To ensure that the data received in requests meets specified criteria before processing.

Answer 10

Pydantic model ex. from fastapi import FastAPI from pydantic import BaseModel app = FastAPI() class Item(BaseModel): name: str price: float is_available: bool = True # Default value @app.post("/items/") async def create_item(item: Item): return item

Answer 11

By declaring a Pydantic model as a parameter in the path operation function.

Answer 12

id: Optional[List[str]] = Query(['1', '2', '3'])

Answer 13

value: int = Path(None, gt=5, le=10)

Answer 14

Type hints & type annotation

Answer 15

def greet(name: str) -> str: # 'name: str' is a type annotation return f"Hello, {name}!" age: int = 30 # 'age: int' is a type annotation result = greet("Alice") # 'result' is inferred to be of type 'str'

Answer 16

A type hint is a suggestion to the type checker about what type a variable or function parameter should be. It does not enforce type checking at runtime but provides information to developers and tools (like IDEs and static analyzers) about the expected types.

Answer 17

A type annotation is the actual syntax used to provide type hints in the code. It involves using a colon (:) followed by the type after the variable name or function parameter. For function return types, the annotation is placed after the -> symbol.

Answer 18

mypy is a static type checker for Python that analyzes the code and checks the type hints for consistency. It helps identify type-related errors without executing the code.

Answer 19

Type hints and type annotations in Python provide a way to specify expected types, but they do not enforce type checking at runtime. This means that even with type hints, you can still write code that has type-related errors that won't be caught until runtime.

Answer 20

In FastAPI, a dependency is a way to define reusable components that can be injected into your route handlers (endpoints). Dependencies allow you to encapsulate common logic, such as authentication, database connections, or any other functionality that you want to share across multiple routes. A simple dependency function def get_query_param(q: str = None): if q: return q raise HTTPException(status_code=400, detail="Query parameter 'q' is required") @app.get("/items/") async def read_items(q: str = Depends(get_query_param)): return {"query": q}

Answer 21

Schema refers to a Pydantic model that defines the structure and validation rules for incoming data from users A model in this context typically refers to an ORM (Object-Relational Mapping) model that represents the structure of a database table. This model defines how data is stored in the database and may include relationships with other tables.

Answer 22

class UserCreateSchema(BaseModel): username: str email: str password: str

Answer 23

class UserModel(Base): __tablename__ = 'users' id = Column(Integer, primary_key=True, index=True) username = Column(String, unique=True, index=True) email = Column(String, unique=True, index=True) password = Column(String)

Answer 24

This ensures that any fields automatically set by the database (like autogenerated IDs, timestamps, or default values) are updated in your Python object before you return it. Without db.refresh(new_user), those fields might remain unset or outdated in the returned object after db.commit().

Answer 25

yield is used instead of return in FastAPI dependencies like get_db() to allow for cleanup actions after the request is handled. When you use yield, FastAPI injects the database session into your endpoint, and after the response is sent, the code after yield (such as db.close()) runs automatically to close the session.

Answer 26

db.query(DbUser).all()

Answer 27

db.query(DbUser).filter(DbUser.id == id).first()

Answer 28

If you write db: Session = get_db(), Python will call get_db() once at startup, not per request. This means: - The same DB session (or generator) is shared across all requests (very bad!). - Resource cleanup (e.g., closing the session) won’t work as intended. - You lose all the benefits of FastAPI’s dependency system.

Answer 29

class MyCustomException(Exception): def __init__(self, name: str): self.name = name

Answer 30

@app.exception_handler(MyCustomException) async def my_custom_exception_handler(request: Request, exc: MyCustomException): return JSONResponse( status_code=418, content={"message": f"Oops! {exc.name} did something. There goes a rainbow..."}, )

Answer 31

return HTMLResponse(content=out, media_type="text/html")

Answer 32

return PlainTextResponse(content=out, media_type="text/plain")

Answer 33

@app.get( "/my-endpoint", responses={ 200: { "description": "Successful HTML response", "content": { "text/html": { "example": "

Hello, World!

" } }, }, 404: { "description": "Not Found as plain text", "content": { "text/plain": { "example": "Not found" } }, }, }, )

Answer 34

Required vs. Optional: The ellipsis (...) inside File(...) means the file is required. You can make it optional by providing a default value, e.g., File(default=None)

FastAPI Flashcards

(72 cards)

Hello, World!