FastAPI վթարի դասընթաց

FastAPI-ն ժամանակակից, արագ (բարձր արդյունավետությամբ) վեբ շրջանակ է Python 3.6+-ով API-ներ ստեղծելու համար՝ հիմնված ստանդարտ Python տիպի հուշումների վրա: Այն ապահովում է պարզ և ինտուիտիվ միջոց՝ ստեղծելու ամուր, մասշտաբային և պահպանվող վեբ API-ներ: FastAPI-ն օգտագործում է Python-ի վերջին հնարավորությունները և Pydantic գրադարանի տվյալների վավերացման և սերիականացման հզոր հնարավորությունները՝ ավելի արդյունավետ զարգացման փորձ ապահովելու ավելի քիչ սխալներով: FastAPI-ն նաև նախագծված է հեշտ սովորելու և օգտագործելու համար՝ գերազանց փաստաթղթերով և մշակողների ակտիվ համայնքով, որոնք նպաստում են դրա զարգացմանն ու աջակցությանը: Դրա ուշագրավ առանձնահատկություններից մի քանիսը ներառում են.

1. Բարձր կատարողականություն. FastAPI-ն նախատեսված է բարձր կատարողականության համար՝ շնորհիվ իր ասինխրոն ծրագրավորման և Python-ի ժամանակակից առանձնահատկությունների, ինչպիսիք են տիպի ակնարկները:
2. Հեշտ օգտագործման համար. FastAPI-ն հեշտ է սովորել և օգտագործել՝ պարզ և ինտուիտիվ API-ով, որը արագացնում է այն սկսելու և գործարկելու համար:
3. Տվյալների վավերացում. FastAPI-ն օգտագործում է Pydantic գրադարանի տվյալների վավերացման և սերիականացման հզոր հնարավորությունները՝ ապահովելու, որ տվյալները լավ ձևավորված են և ճիշտ մուտքագրված:
4. Ինտեգրում հանրաճանաչ տվյալների շտեմարանների և ORM-ների հետ. FastAPI-ն անխափան կերպով ինտեգրվում է հանրաճանաչ տվյալների բազաներին և ORM-ներին, ինչպիսիք են PostgreSQL, MySQL, SQLite, MongoDB, SQLAlchemy և Tortoise ORM՝ տրամադրելով ճկունություն մշակողներին՝ օգտագործելու իրենց նախընտրած տվյալների բազայի տեխնոլոգիան և ORM-ը՝ իրենց տվյալները կառավարելու համար:
5. API-ի ավտոմատ փաստաթղթավորում. FastAPI-ն ավտոմատ կերպով ստեղծում է համապարփակ և ինտերակտիվ API փաստաթղթեր՝ հիմնվելով հենց կոդի վրա՝ հեշտացնելով ուսումնասիրել և հասկանալ API-ը:
6. OpenAPI և JSON Schema. FastAPI-ն լիովին աջակցում է OpenAPI և JSON Schema ստանդարտներին՝ տրամադրելով ստանդարտացված եղանակ՝ նկարագրելու API-ները և դրանց տվյալները:
7. Արագ զարգացում. FastAPI-ն ապահովում է սահուն զարգացման փորձ այնպիսի գործառույթներով, ինչպիսիք են կենդանի վերաբեռնումը, ինտերակտիվ API փաստաթղթերը և հեշտ օգտագործման զարգացման սերվերը:
8. Փորձարկման հնարավորություն. FastAPI-ն խիստ փորձարկվող է, ներկառուցված աջակցությամբ API-ների փորձարկման և վրիպազերծման համար:

FastAPI-ի հետ կապված պայմաններ.

Ահա FastAPI-ի հետ կապված որոշ տերմինների համառոտ բացատրությունը.

1. Ուղու շահագործման գործառույթներ. FastAPI-ում ուղու գործողության ֆունկցիան Python ֆունկցիա է, որը մշակում է HTTP հարցման որոշակի մեթոդ (օրինակ՝ GET, POST, PUT, DELETE և այլն) և URL-ի ուղին:
2. Ուղու պարամետրեր. Ուղու պարամետրերը URL ուղու մի մասն են, որոնք օգտագործվում են հաճախորդի խնդրանքից որոշակի արժեքներ վերցնելու համար: Դրանք սահմանվում են երթուղու ուղու վրա՝ օգտագործելով փակագծեր {}:
3. Հարցման պարամետրեր. Հարցման պարամետրերը լրացուցիչ պարամետրեր են, որոնք կարող են ավելացվել URL-ի ուղու վերջում API-ի վերջնակետի վարքագիծը փոփոխելու համար: Դրանք սահմանվում են մի ? URL-ում և կարելի է մուտք գործել՝ օգտագործելով հարցումի օբյեկտը:
4. Հարցման մարմին. Հարցման մարմինը հաճախորդի կողմից ուղարկված տվյալներն են հարցման օգտակար բեռնվածքում: FastAPI-ն կարող է ավտոմատ կերպով վերլուծել հարցման մարմինը և ստեղծել տվյալների համապատասխան տեսակի հուշումներ:
5. Արձագանքման մոդել. FastAPI-ում դուք կարող եք նշել պատասխանի տվյալների կառուցվածքը՝ օգտագործելով Pydantic մոդելները: Սա թույլ է տալիս պատասխանի տվյալների ավտոմատ սերիականացումը համապատասխան ձևաչափով (օրինակ՝ JSON):
6. Pydantic. Pydantic-ը տվյալների վավերացման և սերիականացման գրադարան է, որը մեծապես օգտագործվում է FastAPI-ում: Այն ապահովում է պարզ և ինտուիտիվ եղանակ՝ վավերացնելու և փոխակերպելու տվյալները Python օբյեկտների և JSON-ի միջև:
7. OpenAPI. OpenAPI-ն API-ների կառուցման հստակեցում է, ներառյալ API-ների և դրանց տվյալների նկարագրության ստանդարտացված եղանակը: FastAPI-ն լիովին աջակցում է OpenAPI ստանդարտին և տրամադրում է գործիքներ՝ OpenAPI-ի փաստաթղթերը ավտոմատ կերպով ստեղծելու համար:
8. Swagger UI. Swagger UI-ն վեբ վրա հիմնված գործիք է API-ների ուսումնասիրման և փորձարկման համար: FastAPI-ն ավտոմատ կերպով ստեղծում է Swagger UI էջ, որը թույլ է տալիս ծրագրավորողներին փորձարկել և ուսումնասիրել API-ի վերջնակետերը:
9. JSON Schema. JSON Schema-ն JSON տվյալները նկարագրելու բառապաշար է՝ ներառյալ դրա կառուցվածքը, տվյալների տեսակները և վավերացման սահմանափակումները: FastAPI-ն լայնորեն օգտագործում է JSON Schema-ն տվյալների վավերացման և սերիականացման համար:
10. ASGI. ASGI (Asynchronous Server Gateway Interface) պրոտոկոլ է Python-ում ասինխրոն վեբ հավելվածներ ստեղծելու համար: FastAPI-ն կառուցված է ASGI-ի վերևում և ապահովում է բարձր արդյունավետությամբ վեբ սերվեր, որը օպտիմիզացված է թրաֆիկի մեծ ծավալների կառավարման համար:

Ընդհանուր առմամբ, FastAPI-ն հզոր և ճկուն վեբ շրջանակ է, որը հեշտացնում է Python-ում բարձր արդյունավետության API-ներ ստեղծելը: Նրա աջակցությունը ասինխրոն կոդի, API-ի փաստաթղթերի ավտոմատ ստեղծման և Pydantic տվյալների վավերացման համար այն դարձնում է հիանալի ընտրություն ժամանակակից վեբ հավելվածներ ստեղծելու համար:

Խնդրում ենք գտնել այս հոդվածի կոդը իմ GitHub պահեստում:

Հիմնական հատկանիշների և կոդի օրինակների ուսումնասիրություն

FastAPI-ում ուղու պարամետրերը և հարցման պարամետրերը հաճախորդից տվյալներ ընդունելու երկու եղանակ են:

Ուղու պարամետր

Ուղու պարամետրերը օգտագործվում են URL-ի ուղու մասերը գրավելու համար և հայտարարվում են՝ դրանք փաթաթելով ուղու մեջ գանգուր փակագծերով {}: Օրինակ՝ հետևյալ «/items/{item_id}» ուղու մեջ {item_id} ուղու պարամետր է: Ուղու պարամետրի արժեքը հանվում է URL-ից և որպես փաստարկ փոխանցվում հավելվածի համապատասխան ֆունկցիային:

Ահա FastAPI վերջնակետի օրինակ, որն ընդունում է ուղու պարամետրը.

from fastapi import FastAPI

app = FastAPI()

items = {
  1: {
    "name": "apple",
    "price": 0.5,
    "description": "A sweet fruit with a red or green skin and a core containing seeds."
  },
  2: {
    "name": "banana",
    "price": 0.25,
    "description": "A long curved fruit with a yellow skin and soft sweet flesh."
  },
  3: {
    "name": "orange",
    "price": 0.35,
    "description": "A round citrus fruit with a tough bright reddish-yellow rind and juicy acid pulp."
  }
}

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

Այս օրինակում read_item ֆունկցիան ընդունում է int տեսակի item_id ուղու պարամետրը: Երբ հաճախորդը պահանջում է URL, ինչպիսին է /items/42-ը, 42 արժեքը կփոխանցվի որպես item_id արգումենտ ֆունկցիային:

Հարցման պարամետր

Հարցման պարամետրերն օգտագործվում են URL հարցման տողում լրացուցիչ տվյալներ փոխանցելու համար: Դրանք հայտարարված են որպես ֆունկցիայի պարամետրեր՝ լռելյայն արժեքներով, և FastAPI-ն ավտոմատ կերպով կվերլուծի հարցման տողը և պարամետրը կհամալրի համապատասխան արժեքով։ Օրինակ, հետևյալ URL-ում /items?skip=0&limit=10, բաց թողնելը և սահմանը հարցման պարամետրեր են:

Ահա FastAPI վերջնակետի օրինակ, որն ընդունում է հարցման պարամետրերը.

from fastapi import FastAPI

app = FastAPI()

items = {
  1: {
    "name": "apple",
    "price": 0.5,
    "description": "A sweet fruit with a red or green skin and a core containing seeds."
  },
  2: {
    "name": "banana",
    "price": 0.25,
    "description": "A long curved fruit with a yellow skin and soft sweet flesh."
  },
  3: {
    "name": "orange",
    "price": 0.35,
    "description": "A round citrus fruit with a tough bright reddish-yellow rind and juicy acid pulp."
  }
}

@app.get("/items/")
async def read_items(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

Այս օրինակում read_items ֆունկցիան ընդունում է հարցման երկու պարամետր՝ skip և limit, երկուսն էլ int տեսակի՝ համապատասխանաբար 0 և 10 լռելյայն արժեքներով։ Երբ հաճախորդը պահանջում է URL, ինչպիսին է /items?skip=20&limit=5, ֆունկցիան կստանա skip=20 և limit=5 որպես համապատասխան պարամետրերի արժեքներ: Եթե ​​URL-ում արժեքներ չկան, ֆունկցիան կօգտագործի լռելյայն արժեքները:

Ուղու և հարցման պարամետրերի համադրում

Մենք կարող ենք համատեղել ուղու և հարցման պարամետրերը FastAPI-ում:

Ահա մի օրինակ, թե ինչպես կարելի է սահմանել վերջնակետ, որն օգտագործում է ինչպես ճանապարհի, այնպես էլ հարցման պարամետրերը.

from fastapi import FastAPI

app = FastAPI()

items = {
  1: {
    "name": "apple",
    "price": 0.5,
    "description": "A sweet fruit with a red or green skin and a core containing seeds."
  },
  2: {
    "name": "banana",
    "price": 0.25,
    "description": "A long curved fruit with a yellow skin and soft sweet flesh."
  },
  3: {
    "name": "orange",
    "price": 0.35,
    "description": "A round citrus fruit with a tough bright reddish-yellow rind and juicy acid pulp."
  }
}

@app.get("/items/{item_id}")
def get_item(item_id: int, q: str = None):
    item = items.get(item_id)
    if not item:
        return {"error": "Item not found"}
    if q:
        item.update({"q": q})
    return item

Այս օրինակում վերջնակետը սահմանվում է՝ օգտագործելով @app.get դեկորատորը, որը նշում է, որ այն պատասխանում է HTTP GET հարցումներին: Վերջնակետի ուղին ներառում է ուղու պարամետր՝ item_id, որը սահմանվում է՝ փակելով այն գանգուր փակագծերում {}: Վերջնական կետը ներառում է նաև հարցման պարամետր՝ q, որը կամընտիր է և ունի None-ի լռելյայն արժեք:

Երբ վերջնակետը կանչվում է, item_id-ի արժեքը վերցվում է URL-ի ուղու պարամետրից, իսկ q-ի արժեքը վերցվում է հարցման տողից, եթե այն առկա է: Վերջնական կետը վերադարձնում է JSON պատասխան, որը պարունակում է երկու պարամետրի արժեքները:

HTTP մեթոդներ

FastAPI-ն աջակցում է մի քանի HTTP մեթոդներ, որոնք կարող են օգտագործվել հավելվածում տարբեր տեսակի վերջնակետեր սահմանելու համար: Ահա FastAPI-ում յուրաքանչյուր HTTP մեթոդի կարճ նկարագրությունը.

• ՍՏԱՆԵԼ. Օգտագործվում է ռեսուրս կամ ռեսուրսների ցանկ առբերելու համար: Այս մեթոդը պետք է լինի անվտանգ և անգործունակ, այսինքն՝ այն չպետք է փոփոխի սերվերի որևէ տվյալ:
• POST. Օգտագործվում է նոր ռեսուրս ստեղծելու համար: Այս մեթոդը անգործունակ չէ, այսինքն՝ բազմաթիվ հարցումները կարող են հանգեցնել բազմաթիվ ռեսուրսների ստեղծման:
• PUT. օգտագործվում է գոյություն ունեցող ռեսուրսը թարմացնելու համար: Այս մեթոդը պետք է լինի անիմաստ, այսինքն՝ բազմաթիվ հարցումները պետք է հանգեցնեն ռեսուրսի նույն վիճակին:
• PATCH. նման է PUT-ին, բայց օգտագործվում է առկա ռեսուրսը մասամբ թարմացնելու համար:
• ՋՆԵԼ. օգտագործվում է գոյություն ունեցող ռեսուրսը ջնջելու համար: Այս մեթոդը պետք է լինի անիմաստ, այսինքն՝ բազմաթիվ հարցումները պետք է հանգեցնեն ռեսուրսի նույն վիճակին:
• ՏԱՐԲԵՐԱԿՆԵՐ. Օգտագործվում է ռեսուրսի համար հասանելի հաղորդակցման տարբերակների մասին տեղեկատվություն ստանալու համար:
• HEAD. նման է GET-ին, բայց միայն առբերում է HTTP վերնագրերը ռեսուրսի համար՝ առանց իրական բովանդակության:

FastAPI-ում այս HTTP մեթոդներից յուրաքանչյուրը կարող է քարտեզագրվել Python ֆունկցիայի հետ, որը սահմանում է համապատասխան վերջնակետի վարքագիծը:

@app.get, @app.post, @app.put, @app.patch, @app.delete, @app.options և @app.head decorators օգտագործվում են վերջնակետեր ստեղծելու համար, որոնք արձագանքում են համապատասխան HTTP մեթոդներին:

Հարցման մարմին և փակցման մեթոդ

FastAPI-ում դուք կարող եք սահմանել հարցման մարմին՝ օգտագործելով BaseModel դասը pydantic մոդուլից: Հարցման մարմինը այն տվյալն է, որը հաճախորդը ուղարկում է սերվերին որպես POST հարցումի մաս:

Ահա մի օրինակ, թե ինչպես կարելի է սահմանել հարցման մարմին՝ տարրերի բառարանում նոր տարր ավելացնելու համար՝ օգտագործելով POST մեթոդը.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float
    description: Optional[str] = None

items = {}

@app.post("/create_item")
def create_item(item_id: int, item: Item):
    if item_id in items:
        return {"error": "Item already exists!"}
    items[item_id] = item
    return items[item_id]

Այս օրինակում մենք նախ սահմանում ենք նոր Item դաս, որը ժառանգում է BaseModel դասից FastAPI-ի pydantic մոդուլում: Item դասը ունի երեք դաշտ՝ անուն, գին և նկարագրություն:

Հաջորդը, մենք սահմանում ենք create_item վերջնակետը @app.post decorator-ով: Create_item ֆունկցիայի մեջ մենք սահմանում ենք պարամետր, որը կոչվում է item Item տիպով, որը մեր ավելի վաղ սահմանած դասն է։ Սա նշանակում է, որ հարցումի մարմինը պետք է ունենա JSON տվյալներ՝ նույն ստեղներով, ինչ Item դասի ատրիբուտները: Այս վերջնակետը որպես հարցման մարմին վերցնում է Item օբյեկտը, որը ավտոմատ կերպով վերլուծվում և վավերացվում է FastAPI-ի կողմից՝ հիմնվելով Item դասում նշված դաշտերի տեսակների և վավերացման կանոնների վրա:

Վերջնական կետի ներսում մենք ստեղծում ենք նոր item_id՝ հիմնվելով տարրերի բառարանի ընթացիկ երկարության վրա, նոր տարրը ավելացնում ենք բառարանում՝ item_id-ով որպես բանալի, և վերադարձնում ենք նոր նյութի_id պարունակող պատասխան:

PUT մեթոդ

Ահա FastAPI-ում PUT մեթոդի օգտագործման օրինակ.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class UpdateItem(BaseModel):
    name: Optional[str] = None
    price: Optional[float] = None
    description: Optional[str] = None

items = {
  1: {
    "name": "apple",
    "price": 0.5,
    "description": "A sweet fruit with a red or green skin and a core containing seeds."
  }
}

@app.put("/items/{item_id}")
async def update_item(item_id: int, item: UpdateItem):
    if item_id not in items:
        return {"error": "Item not found"}
    if item.name != None:
        items[item_id]["name"] = item.name
    if item.price != None:
        items[item_id]["price"] = item.price
    if item.description != None:
        items[item_id]["description"] = item.description
    return {"message": "Item updated successfully"}

Այս օրինակում մենք սահմանել ենք PUT վերջնակետ, որը թարմացնում է գոյություն ունեցող տարրը ID-ով: Մենք օգտագործել ենք Item դասը, որը սահմանել ենք ավելի վաղ, և մենք ենթադրել ենք, որ մենք արդեն ունենք բառարան, որը կոչվում է տարրեր, որը պարունակում է առկա տարրերը:

Վերջնական կետը վերցնում է երկու պարամետր՝ item_id և item: Item_id պարամետրը ուղու պարամետր է, որը սահմանում է այն նյութի ID-ն, որը պետք է թարմացվի: Նյութի պարամետրը հարցման մարմնի պարամետր է, որը պարունակում է նյութի թարմացված տեղեկատվությունը:

Մենք նախ ստուգում ենք, արդյոք նշված item_id-ը գոյություն ունի տարրերի բառարանում: Եթե ​​դա այդպես չէ, մենք վերադարձնում ենք սխալի հաղորդագրություն: Եթե ​​դա տեղի ունենա, մենք թարմացնում ենք համապատասխան նյութը ապրանքի պարամետրի տվյալների հետ: Մենք օգտագործում ենք Item օբյեկտի dict() մեթոդը՝ այն բառարանի վերածելու համար՝ նախքան տարրերի բառարանը թարմացնելը:

Ի վերջո, մենք վերադարձնում ենք հաղորդագրություն, որը ցույց է տալիս, որ տարրը հաջողությամբ թարմացվել է:

Ջնջել մեթոդը

FastAPI-ում դուք կարող եք սահմանել DELETE մեթոդ՝ HTTP DELETE հարցումները կարգավորելու համար: DELETE մեթոդը սովորաբար օգտագործվում է եզակի նույնացուցիչով բացահայտված որոշակի ռեսուրս ջնջելու համար:

Ահա մի օրինակ, թե ինչպես կարող եք կիրառել DELETE մեթոդը տարրերի բառարանից իր ID-ի հիման վրա ջնջելու համար.

from fastapi import FastAPI

app = FastAPI()

items = {
  1: {
    "name": "apple",
    "price": 0.5,
    "description": "A sweet fruit with a red or green skin and a core containing seeds."
  }
}

@app.delete("/items/{item_id}")
async def delete_item(item_id: int):
    if item_id not in items:
        return {"error": "Item not found"}
    del items[item_id]
    return {"message": "Item deleted successfully"}

Այս օրինակում delete_item ֆունկցիան վերցնում է item_id պարամետր, որը փոխանցվում է URL-ի ուղու պարամետրի միջոցով: Եթե ​​նշված ID-ով տարրը գոյություն չունի տարրերի բառարանում, ֆունկցիան վերադարձնում է սխալի հաղորդագրություն: Հակառակ դեպքում, այն ջնջում է նյութը բառարանից՝ օգտագործելով del հիմնաբառը և վերադարձնում է հաջողության հաղորդագրություն:

Նկատի ունեցեք, որ կարևոր է նրբագեղորեն վարվել ձեր հավելվածում առկա սխալների հետ՝ հաճախորդներին տեղեկատվական սխալի հաղորդագրություններ տրամադրելու համար: Այս օրինակում, եթե տարրը չի գտնվել, մենք վերադարձնում ենք սխալ հաղորդագրություն՝ համապատասխան HTTP կարգավիճակի կոդով (օրինակ՝ 404 Not Found):

Հեղինակ՝ Զուբայր Ահմադ

Կապ. Հետևեք ինձ LinkedIn-ում և Twitter-ում: