Python Academy · Lektion

Sökvägsparametrar, frågeparametrar och request bodies

Definiera typade parametrar och scheman för request bodies med Pydantic.

Lektion 2 av 413 steg

Sökvägsparametrar, frågeparametrar och request bodies är en gratis lektion i Python Academy på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Python Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Python Academy innehåller totalt 4 lektioner.

Validering av path-parametrar

Ange valideringsregler för path-parametrar med Path(): ställ in begränsningar med ge, le, gt och lt.

from fastapi import FastAPI, Path
app = FastAPI()

@app.get("/items/{item_id}")
def get_item(item_id: int = Path(ge=1, le=1000)):
    return {"item_id": item_id}

# GET /items/0  → 422 (must be >= 1)

Validering av query-parametrar

Använd Query() för att lägga till validering, standardvärden, alias och beskrivningar för query-parametrar.

from fastapi import FastAPI, Query
app = FastAPI()

@app.get("/search")
def search(
    q: str = Query(min_length=2, max_length=50),
    page: int = Query(default=1, ge=1),
):
    return {"q": q, "page": page}

Valfria query-parametrar

Använd | None = None (Python 3.10+) eller Optional[str] = None för att göra en query-parameter valfri.

from fastapi import FastAPI
app = FastAPI()

@app.get("/users")
def list_users(
    dept: str | None = None,
    active: bool = True
):
    return {"dept": dept, "active": active}

# GET /users → dept=None, active=True
# GET /users?dept=HR&active=false

Flera värden för en query-parameter

Acceptera en lista med värden för en enda query-parameter med list[str] och Query().

from fastapi import FastAPI, Query
from typing import Annotated
app = FastAPI()

@app.get("/filter")
def filter_items(tags: Annotated[list[str], Query()] = []):
    return {"tags": tags}

# GET /filter?tags=python&tags=web

Nästlade request bodies

Pydantic-modeller kan nästlas. FastAPI hanterar nästlad JSON automatiskt.

from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()

class Address(BaseModel):
    street: str
    city: str

class User(BaseModel):
    name: str
    address: Address

@app.post("/users")
def create_user(user: User):
    return user.model_dump()

Fältbegränsningar i Pydantic

Använd Field() i en modell för att lägga till begränsningar, standardvärden och beskrivningar för enskilda fält.

from pydantic import BaseModel, Field

class Product(BaseModel):
    name: str = Field(min_length=1, max_length=100)
    price: float = Field(gt=0)
    quantity: int = Field(ge=0, default=0, description="Items in stock")

Request body + path + query tillsammans

Kombinera alla tre parametertyperna i samma endpoint. FastAPI skiljer dem åt utifrån position: path i URL:en, enkla typer som query och modeller som body.

from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()

class ItemUpdate(BaseModel):
    name: str
    price: float

@app.put("/shops/{shop_id}/items/{item_id}")
def update_item(
    shop_id: int,
    item_id: int,
    item: ItemUpdate,
    notify: bool = False,
):
    return {"shop": shop_id, "item": item_id,
            "data": item.model_dump(), "notify": notify}

Filuppladdningar

Använd UploadFile och File() för att ta emot filuppladdningar. Åtkomst till innehållet sker med await file.read().

from fastapi import FastAPI, UploadFile, File
app = FastAPI()

@app.post("/upload")
async def upload(file: UploadFile = File(...)):
    content = await file.read()
    return {"filename": file.filename, "size": len(content)}

Formulärdata

Använd Form() för att ta emot HTML-formulärdata (application/x-www-form-urlencoded eller multipart/form-data).

# pip install python-multipart
from fastapi import FastAPI, Form
app = FastAPI()

@app.post("/login")
def login(username: str = Form(...), password: str = Form(...)):
    return {"username": username}

Sammanfattning av request-validering

FastAPI validerar alla parametertyper automatiskt. Ogiltiga indata returnerar HTTP 422 med ett detaljerat felmeddelande innan hanteraren anropas.

# Auto-validated:
# - Path params: type coercion, Path() constraints
# - Query params: Query() constraints, type coercion
# - Request body: Pydantic model validation
# - All errors → HTTP 422 Unprocessable Entity
# - No manual validation needed

Alias och utfasning

Använd alias= i Query() eller Field() för att acceptera ett annat namn i requesten, och deprecated=True för att markera gamla parametrar.

from fastapi import FastAPI, Query
app = FastAPI()

@app.get("/items")
def get_items(
    q: str | None = Query(default=None, alias="search-query"),
    old: str | None = Query(default=None, deprecated=True),
):
    return {"q": q, "old": old}

# GET /items?search-query=python

Snabbkontroll

Hur skiljer FastAPI mellan en path-parameter, en query-parameter och en request body?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Använd Path()/Query() för parameterbegränsningar. Nästla Pydantic-modeller för komplexa bodies. Kombinera path-, query- och body-parametrar fritt. UploadFile hanterar filer och Form() hanterar HTML-formulär. FastAPI validerar allt innan hanteraren körs.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 76
Lektioner: 320

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Sökvägsparametrar, frågeparametrar och request bodies” gratis?

Ja – hela texten till ”Sökvägsparametrar, frågeparametrar och request bodies” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Python Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Python Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Sökvägsparametrar, frågeparametrar och request bodies”?

Definiera typade parametrar och scheman för request bodies med Pydantic. Ni övar på Python Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Python Academy?

Du behöver inga förkunskaper. Utbildningen i Python Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Sökvägsparametrar, frågeparametrar och request bodies”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Python Academy-lektionen?

Ja. Varje Python Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Projektkonfiguration i FastAPI och första endpointen
Sökvägsparametrar, frågeparametrar och request bodies
Dependency Injection och autentisering
Asynkrona endpoints och databasintegration

← Tillbaka till Python Academy