🚀 FastAPI

Zamonaviy Web API'lar uchun To'liq Darslik

Python bilan yuqori samarali API'larni yaratish bo'yicha qo'llanma

FastAPI nima?

FastAPI - bu Python 3.7+ uchun standart Python type hint'lariga asoslangan, zamonaviy, tez (yuqori samarali) web framework bo'lib, API'larni yaratish uchun mo'ljallangan.

Asosiy Xususiyatlar:

Tez: Juda yuqori samaradorlik, NodeJS va Go bilan teng
Tez kodlash: Ishlab chiqish tezligini 200-300% ga oshirish
Kam xatolar: Inson qilgan xatolarni 40% ga kamaytirish
Intuitiv: Avtomatik to'ldirish bilan ajoyib editor qo'llab-quvvatlash
Oson: Foydalanish va o'rganish oson bo'lishi uchun yaratilgan
Qisqa: Kod takrorlashini minimallashtirish
Mustahkam: Avtomatik hujjatlar bilan ishlab chiqarishga tayyor kod

O'rnatish va Sozlash

1. FastAPI va Uvicorn'ni o'rnating:

pip install fastapi uvicorn[standard]

2. Birinchi ilovangizni yarating (main.py):

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello World"}

3. Serverni ishga tushiring:

uvicorn main:app --reload

✓ Muvaffaqiyat! API'ingiz endi http://127.0.0.1:8000 manzilida ishlamoqda

Path Parametrlari

Path parametrlari URL yo'lidan qiymatlarni olish imkonini beradi.

Asosiy Misol:

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

Bir Nechta Parametrlar bilan:

@app.get("/users/{user_id}/posts/{post_id}")
def read_user_post(user_id: int, post_id: int):
    return {
        "user_id": user_id,
        "post_id": post_id
    }

                💡 Maslahat: FastAPI path parametrlarini type hint'lar asosida avtomatik tekshiradi va o'zgartiradi!
            

Query Parametrlari

Query parametrlari URL'dagi ? belgisidan keyin paydo bo'ladigan kalit-qiymat juftliklaridir.

Misol:

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

URL: http://localhost:8000/items/?skip=0&limit=20

Ixtiyoriy Parametrlar:

from typing import Optional

@app.get("/items/{item_id}")
def read_item(item_id: int, q: Optional[str] = None):
    if q:
        return {"item_id": item_id, "q": q}
    return {"item_id": item_id}

Pydantic bilan Request Body

Avtomatik tekshiruv bilan request body sxemalarini belgilash uchun Pydantic modellaridan foydalaning.

Modelni belgilang:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

Endpoint'da ishlatish:

@app.post("/items/")
def create_item(item: Item):
    return {
        "name": item.name,
        "price": item.price
    }

✓ Avtomatik Tekshiruv: FastAPI barcha kiruvchi ma'lumotlarni avtomatik tekshiradi!

Response Modellari

API javoblarining strukturasini belgilang va avtomatik hujjatlar yarating.

Misol:

class ItemResponse(BaseModel):
    id: int
    name: str
    price: float

@app.post("/items/", response_model=ItemResponse)
def create_item(item: Item):
    # Imagine this saves to database
    return {
        "id": 1,
        "name": item.name,
        "price": item.price
    }

Afzalliklar:

Avtomatik ma'lumot filtrlash (faqat belgilangan maydonlarni qaytarish)
Javoblar uchun ma'lumot tekshiruvi
Avtomatik hujjatlashtirish
Type tekshiruvi va editor qo'llab-quvvatlash

HTTP Status Kodlari

Turli vaziyatlar uchun mos status kodlarini qaytaring.

Asosiy Foydalanish:

from fastapi import status

@app.post("/items/", status_code=status.HTTP_201_CREATED)
def create_item(item: Item):
    return item

Keng Tarqalgan Status Kodlar:

status.HTTP_200_OK           # Muvaffaqiyat
status.HTTP_201_CREATED      # Resurs yaratildi
status.HTTP_204_NO_CONTENT   # Muvaffaqiyat, kontent yo'q
status.HTTP_400_BAD_REQUEST  # Noto'g'ri so'rov
status.HTTP_401_UNAUTHORIZED # Autentifikatsiya qilinmagan
status.HTTP_403_FORBIDDEN    # Ruxsat berilmagan
status.HTTP_404_NOT_FOUND    # Resurs topilmadi
status.HTTP_500_INTERNAL_SERVER_ERROR

Xatolarni Boshqarish

HTTPException bilan xatolarni chiroyli boshqaring.

Misol:

from fastapi import HTTPException

items = {"1": "Item One"}

@app.get("/items/{item_id}")
def read_item(item_id: str):
    if item_id not in items:
        raise HTTPException(
            status_code=404,
            detail="Item not found"
        )
    return {"item": items[item_id]}

Maxsus Exception Handler:

from fastapi.responses import JSONResponse

@app.exception_handler(ValueError)
async def value_error_handler(request, exc):
    return JSONResponse(
        status_code=400,
        content={"message": str(exc)}
    )

Dependency Injection

Bir nechta endpoint'lar bo'ylab umumiy mantiqni qayta ishlating.

Oddiy Dependency:

from fastapi import Depends

def get_query_param(q: str = None):
    return q

@app.get("/items/")
def read_items(query: str = Depends(get_query_param)):
    return {"query": query}

Ma'lumotlar Bazasi Dependency Misoli:

def get_db():
    db = Database()
    try:
        yield db
    finally:
        db.close()

@app.get("/users/")
def read_users(db = Depends(get_db)):
    return db.get_all_users()

Middleware

Har bir so'rovdan oldin yoki keyin ishlaydigan maxsus mantiq qo'shing.

CORS Middleware:

from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

Maxsus Middleware:

import time

@app.middleware("http")
async def add_process_time(request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    return response

Background Vazifalar

Javob qaytarilgandan keyin vazifalarni fon rejimida bajarish.

Misol:

from fastapi import BackgroundTasks

def send_email(email: str, message: str):
    # Simulate sending email
    print(f"Sending email to {email}: {message}")

@app.post("/send-notification/")
def send_notification(
    email: str,
    background_tasks: BackgroundTasks
):
    background_tasks.add_task(
        send_email,
        email,
        "Thanks for subscribing!"
    )
    return {"message": "Notification sent"}

                💡 Foydalanish: Email yuborish, log yozish yoki javobni bloklamaydigan ma'lumotlarni qayta ishlash uchun ideal.
            

Fayl Yuklash

FastAPI bilan fayl yuklashni oson boshqaring.

Bitta Fayl Yuklash:

from fastapi import File, UploadFile

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

Bir Nechta Fayllar:

from typing import List

@app.post("/uploadfiles/")
async def upload_files(files: List[UploadFile] = File(...)):
    return {
        "filenames": [file.filename for file in files]
    }

Autentifikatsiya

API'ingizda xavfsiz autentifikatsiyani amalga oshiring.

Parol bilan OAuth2:

from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

@app.get("/users/me")
def read_users_me(token: str = Depends(oauth2_scheme)):
    return {"token": token}

JWT Token Misoli:

from datetime import datetime, timedelta
import jwt

SECRET_KEY = "your-secret-key"

def create_token(data: dict):
    to_encode = data.copy()
    expire = datetime.utcnow() + timedelta(minutes=30)
    to_encode.update({"exp": expire})
    return jwt.encode(to_encode, SECRET_KEY, algorithm="HS256")

Avtomatik API Hujjatlari

FastAPI avtomatik ravishda interaktiv API hujjatlarini yaratadi.

Mavjud Hujjatlar:

Swagger UI: http://127.0.0.1:8000/docs
ReDoc: http://127.0.0.1:8000/redoc
OpenAPI Schema: http://127.0.0.1:8000/openapi.json

Metadata Qo'shish:

app = FastAPI(
    title="My API",
    description="A comprehensive API",
    version="1.0.0",
    docs_url="/documentation",
    redoc_url="/redocumentation"
)

✓ Interaktiv Testlash: Endpoint'laringizni to'g'ridan-to'g'ri hujjatlar sahifasidan test qiling!

Eng Yaxshi Amaliyotlar

1. Type Hint'lardan foydalaning:

def process_item(item_id: int, name: str) -> dict:
    return {"id": item_id, "name": name}

2. Router'lar bilan tashkil qiling:

from fastapi import APIRouter

router = APIRouter(prefix="/items", tags=["items"])

@router.get("/")
def read_items():
    return []

app.include_router(router)

3. Environment O'zgaruvchilaridan foydalaning:

from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    database_url: str
    secret_key: str
    
    class Config:
        env_file = ".env"

Ma'lumotlar Bazasi Integratsiyasi (SQLAlchemy)

Ma'lumotlar Bazasini Sozlash:

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(SQLALCHEMY_DATABASE_URL)
SessionLocal = sessionmaker(bind=engine)

Ma'lumotlar Bazasi Dependency:

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.get("/users/")
def read_users(db: Session = Depends(get_db)):
    return db.query(User).all()

API'ingizni Test Qilish

Test Client'ni Sozlash:

from fastapi.testclient import TestClient

client = TestClient(app)

def test_read_root():
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"message": "Hello World"}

def test_create_item():
    response = client.post(
        "/items/",
        json={"name": "Test", "price": 10.5}
    )
    assert response.status_code == 200
    assert response.json()["name"] == "Test"

                💡 Maslahat: Testlaringizni ishga tushirish uchun pytest'dan foydalaning: pip install pytest
            

Deploy Qilish

Production Server (Gunicorn + Uvicorn):

pip install gunicorn

gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker

Docker Deployment:

FROM python:3.9
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Environment O'zgaruvchilar:

# .env file
DATABASE_URL=postgresql://user:pass@localhost/db
SECRET_KEY=your-secret-key-here
DEBUG=False

Xulosa

Qanday Mavzularni Ko'rib Chiqdik:

✓ FastAPI asoslari va o'rnatish
✓ Path va query parametrlar
✓ Pydantic bilan request/response modellar
✓ Xatolarni boshqarish va status kodlar
✓ Dependency injection
✓ Middleware va background vazifalar
✓ Fayl yuklash
✓ Autentifikatsiya
✓ Avtomatik hujjatlashtirish
✓ Ma'lumotlar bazasi integratsiyasi va testlash
✓ Deploy strategiyalari

🎉 Tabriklaymiz! Endi sizda FastAPI bilan ishlab chiqarishga tayyor API'larni yaratish bilimi bor!

Qo'shimcha Resurslar

Rasmiy Hujjatlar:

FastAPI Docs: https://fastapi.tiangolo.com
Pydantic Docs: https://docs.pydantic.dev
Uvicorn Docs: https://www.uvicorn.org

Amaliy Loyihalar:

Ma'lumotlar bazasi bilan TODO API yarating
Autentifikatsiya bilan blog API yarating
Fayl saqlash xizmatini ishlab chiqing
Real-time chat API yarating
E-commerce API yarating

                💡 Keyingi Qadamlar: O'z API loyihangizni yarata boshlang va kerak bo'lganda ushbu taqdimotga qaytib keling!
            