పాత్ మరియు query పారామీటర్‌లు ఎలా పనిచేస్తాయి?

Question

Accepted Answer

FastAPI ఫంక్షన్ ఆర్గ్యుమెంట్‌ల నుండి **పాత్ పారామీటర్‌లను** (URL పాత్ యొక్క భాగం) మరియు **query పారామీటర్‌లను** (`?` తర్వాత) సంగ్రహిస్తుంది, స్వయంచాలక కన్వర్షన్ మరియు ధృవీకరణ కోసం టైప్ హింట్‌లను ఉపయోగిస్తుంది.

## పాత్ పారామీటర్‌లు — URL యొక్క భాగం

```python
@app.get("/items/{item_id}")        # {item_id} in the path
def get_item(item_id: int):          # matched by NAME; `int` converts & validates
    return {"item_id": item_id}
# GET /items/5 → item_id = 5 (int).  GET /items/abc → 422 error (not an int)
```

పాత్‌లోని `{placeholder}` సరిపోయే పేరు కలిగిన ఫంక్షన్ పారామీటర్ ఒక **పాత్ పారామీటర్** అవుతుంది. టైప్ హింట్ (`int`) URL నుండి స్ట్రింగ్‌ను స్వయంచాలకంగా మారుస్తుంది మరియు అది సరిపోకపోతే స్పష్టమైన 422 ఎరర్‌ను చూపుతుంది.

## Query పారామీటర్‌లు — మిగతా సమస్త

```python
@app.get("/items")
def list_items(skip: int = 0, limit: int = 10, q: str | None = None):
    # parameters NOT in the path become QUERY parameters
    # GET /items?skip=20&limit=5&q=phone → skip=20, limit=5, q="phone"
    return {"skip": skip, "limit": limit, "q": q}
```

పాత్‌లో **లేని** ఫంక్షన్ పారామీటర్‌లు **query పారామీటర్‌లు** అవుతాయి. డిఫాల్ట్ విలువ వాటిని ఐచ్ఛికమైనవిగా చేస్తుంది (`skip: int = 0`); `str | None = None` ఒక నల్ లేయిన ఐచ్ఛిక query పారామీటర్‌ను తయారు చేస్తుంది. డిఫాల్ట్ లేకుండా, అవి అవసరమైనవి.

## అవసరమైన vs ఐచ్ఛిక

```python
def search(q: str):              # REQUIRED query param (no default) → ?q=... must be present
def search(q: str = ""):          # optional, defaults to ""
def search(q: str | None = None): # optional, defaults to None
```

## రెండింటినీ కలపడం

```python
@app.get("/users/{user_id}/items")
def user_items(user_id: int, limit: int = 10):
    # user_id = path param, limit = query param — distinguished by the path
```

## ఇది ఎందుకు ముఖ్యమైనది

పాత్ మరియు query పారామీటర్‌లు URL నుండి ఎండ్‌పాయింట్‌లు ఇన్‌పుట్‌ను పొందే విధానం — దాదాపు ప్రతి API రూట్‌కు ప్రాథమికమైనది (రిసోర్స్‌ను id ద్వారా ఫెచ్ చేయడం, ఫిల్టర్ చేయడం, పేజీనేషన్, సెర్చ్).

FastAPI యొక్క విధానం సుందరమైనది మరియు ఇది ఎక్కువ ఉత్పాదకతకు ఒక కీ కారణం: సరళంగా టైప్ చేయిన ఫంక్షన్ పారామీటర్‌లను ప్రకటించడం ద్వారా మీరు స్వయంచాలక సంగ్రహణ, **టైప్ కన్వర్షన్**, **ధృవీకరణ** (చెడ్డ ఇన్‌పుట్‌లో స్పష్టమైన 422 ఎరర్‌లతో) మరియు అవసరమైన-vs-ఐచ్ఛిక సెమాంటిక్‌లు (డిఫాల్ట్‌ల ద్వారా) పొందుతారు — అన్నీ ప్రామాణిక Python టైప్ హింట్‌ల నుండి తీసుకోబడ్డాయి, గట్టి పార్సింగ్ లేకుండా.

పాత్ పారామీటర్‌లు `{placeholder}` నుండి వచ్చే వాటి మధ్య తేడాను అర్థం చేసుకోవడం, మిగతా సంపూర్ణ query పారామీటర్, మరియు ఎలా డిఫాల్ట్‌లు ఆప్షనాలిటీని నియంత్రిస్తాయి, FastAPI ఎండ్‌పాయింట్‌లను నిర్మించడానికి అත్యంత ముఖ్యమైన రోజువారీ జ్ఞానం.