How to use path parameters in FastAPI for parameterized requests

How to use path parameters in FastAPI for parameterized requests

FastAPI is a fast (high performance), easy to use, and modern web framework developed based on standard APIs (e.g., using Pydantic and OpenAPI). In FastAPI, we can use path parameters to parameterize requests to better handle different requests.

The path parameter refers to the part of the URL that is used to identify a specific instance of the resource. Using path parameters can help us obtain specific data from Web API according to different needs. The following will introduce how to use path parameters to make parameterized requests in FastAPI, and provide corresponding code examples.

First, we need to import the FastAPI and Path modules and create an app object:

from fastapi import FastAPI, Path

app = FastAPI()

Next, We can define path parameters in the routing path. A path parameter is a string surrounded by curly braces where we can define the name and data type of the parameter. For example, we can define a path parameter of item_id:

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

In the above example, we define a routing path of /items/{item_id}, And define the data type of the path parameter item_id as int. In the function parameters, we can directly use the name of the path parameter item_id to get the value.

When we send a request to the server /items/42, FastAPI will automatically pass the value of the path parameter to the corresponding function and return it as the value of the parameter. In the above example, a JSON object will be returned containing the name and value of the parameter:

{"item_id": 42}

We can also specify other parameters for the path parameter. For example, we can specify minimum and maximum values ​​for path parameters. The following is an example:

@app.get("/users/{user_id}")
async def read_user(user_id: int = Path(..., ge=1, le=100)):
    return {"user_id": user_id}

In the above example, we use the two parameters ge and le to limit the range of user_id , indicating that the value of user_id must be greater than or equal to 1 and less than or equal to 100. If the user_id in the request we send exceeds this range, FastAPI will send an HTTP exception response.

In addition to regular data types, we can also use enumeration types as the data types of path parameters. Here is an example:

from enum import Enum

class Size(str, Enum):
    small = "small"
    medium = "medium"
    large = "large"

@app.get("/items/{item_id}/size/{size}")
async def read_item_size(item_id: int, size: Size):
    return {"item_id": item_id, "size": size}

In the above example, we define a Size enumeration class and use it as the data type of the parameter size. When we send the request /items/42/size/small, FastAPI will pass the value of the path parameter to the corresponding function and return it as the value of the parameter.

Using path parameters to parameterize requests is one of the important techniques for using FastAPI to handle different requests in Web API. Through path parameters, we can define different routing paths and obtain specific data from the server according to different needs. In the above example, we demonstrate how to use path parameters to parameterize requests and provide corresponding code examples.

To summarize, the steps for using path parameters to make parameterized requests in FastAPI are as follows:

1. Import the Path module and FastAPI library .
2. Create a app object as an instance of the application.
3. Define path parameters in the routing path and use curly braces to enclose the parameters.
4. In the corresponding function, you can directly use the name of the path parameter to obtain the value of the parameter.

Using path parameters can help us better handle different requests and accurately obtain specific data from the server.

Reference:

• [FastAPI Documentation](https://fastapi.tiangolo.com/)

I hope this article will help you understand how to Using path parameters in FastAPI for parameterized requests helps.

The above is the detailed content of How to use path parameters in FastAPI for parameterized requests. For more information, please follow other related articles on the PHP Chinese website!