Python, Django և FastAPI վեբ ծրագրավորողների համար

01Python-ը մեկ էջում վեբ ծրագրավորողների համար

Python-ը ձևավոր փակագծերի փոխարեն օգտագործում է ներքաշում (indentation), չունի կետ-ստորակետեր և կարդացվում է անգլերենին մոտ։ Փոփոխականները դինամիկ տիպավորված են, բայց ժամանակակից կոդը ավելացնում է type hints (name: str, -> list[int]), որոնք mypy կամ Pyright գործիքները ստուգում են մինչև գործարկումը։ Հիմնական տիպերը, որոնք կօգտագործեք ամեն օր՝ str, int, float, bool, None, list, dict, tuple և set։ Ֆունկցիաները սահմանվում են def-ով, կլասները՝ class-ով, իսկ մոդուլները պարզապես .py ֆայլեր են, որոնք import եք անում։ Python 3.14-ը ներկայիս կայուն տարբերակն է (3.15-ը սպասվում է 2026-ի հոկտեմբերի ցիկլում), և միշտ պետք է աշխատել virtual environment-ի ներսում, որպեսզի յուրաքանչյուր նախագիծ ունենա իր կախվածությունները։ Python-ի տարբերակները, միջավայրերը և փաթեթները կառավարելու արագ, ժամանակակից եղանակը uv-ն է. pip-ը venv-ի հետ դեռ աշխատում է ամենուր։

• Truthy և falsy. դատարկ list-ը, դատարկ string-ը, 0-ն և None-ը բոլորը falsy են։
• List և dict comprehension-ները փոխարինում են map և filter կանչերի մեծ մասին։
• async def և await կան, բայց Python կոդի մեծ մասը դեռ սինքրոն է։
• PEP 8-ը ոճի ուղեցույցն է. Ruff-ը միլիվայրկյաններում ֆորմատավորում և lint է անում ըստ դրա։

1from dataclasses import dataclass
2 
3@dataclass
4class Product:
5    name: str
6    price: float
7    tags: list[str]
8 
9def cheap(items: list[Product], limit: float = 10.0) -> list[str]:
10    return [p.name for p in items if p.price < limit]
11 
12items = [Product("Mug", 8.5, ["home"]), Product("Lamp", 40.0, [])]
13print(cheap(items))  # ['Mug']

02Django նախագծի կարգավորում

Django-ն կազմակերպված է project-ի (settings, արմատային URL-ներ, WSGI/ASGI մուտքի կետեր) և app-երի (ինքնուրույն ֆունկցիոնալ մասեր, օրինակ՝ orders կամ blog) տեսքով։ Յուրաքանչյուր app ունի մոդելներ, view-եր, URL-ներ, ադմինում գրանցում և միգրացիաներ։ Django 6.1-ը ներկայիս feature release-ն է, իսկ 5.2-ը long-term support տարբերակն է. հաջորդ LTS-ը՝ 6.2-ը, նախատեսված է 2027-ի ապրիլին։ Django 6.0-ն ավելացրեց ներկառուցված background tasks API, template partials և Content Security Policy-ի աջակցություն։ Հարցման հոսքը պարզ է. URL resolver-ը գտնում է ուղին, կանչում view-ը, view-ը մոդելներով կարդում կամ գրում է տվյալները և վերադարձնում պատասխան, հաճախ template-ով ռենդեր արված կամ JSON-ի սերիալիզացված։

1uv init shop && cd shop
2uv add django
3uv run django-admin startproject config .
4uv run python manage.py startapp catalog
5# add "catalog" to INSTALLED_APPS in config/settings.py
6uv run python manage.py migrate
7uv run python manage.py createsuperuser
8uv run python manage.py runserver

03Մոդելներ և ORM

Մոդելը Python կլաս է, որը համապատասխանում է աղյուսակին։ Յուրաքանչյուր ատրիբուտ դաշտ է՝ տիպով և ընտրանքներով, և Django-ն այդ կլասների փոփոխություններից գեներացնում է միգրացիաներ։ ORM-ը տալիս է QuerySet-ներ՝ ծույլ (lazy), շղթայվող query builder-ներ, որոնք դիմում են բազային միայն այն ժամանակ, երբ իտերացնում, կտրում (slice) կամ հաշվարկում եք դրանք։ Կապերը սահմանվում են ForeignKey, OneToOneField և ManyToManyField դաշտերով։ Արտադրողականության համար ամենակարևորը երկու մեթոդ է. select_related-ը միայնակ կապերը միացնում է մեկ հարցման մեջ (JOIN), իսկ prefetch_related-ը բազմակի կապերը բեռնում է երկրորդ հարցմամբ։ Առանց դրանց product.category-ին դիմող ցիկլը յուրաքանչյուր տողի համար մեկ հարցում է կատարում՝ դասական N+1 խնդիրը։

1from django.db import models
2 
3class Category(models.Model):
4    name = models.CharField(max_length=100, unique=True)
5 
6class Product(models.Model):
7    name = models.CharField(max_length=200)
8    price = models.DecimalField(max_digits=10, decimal_places=2)
9    category = models.ForeignKey(Category, on_delete=models.PROTECT, related_name="products")
10    created_at = models.DateTimeField(auto_now_add=True)
11 
12    class Meta:
13        indexes = [models.Index(fields=["category", "-created_at"])]
14 
15# One query with a JOIN instead of N+1:
16recent = Product.objects.select_related("category").filter(price__lt=50)[:20]

04Ադմինը՝ back office տասը տողում

Django-ի ադմինը կարդում է ձեր մոդելները և կառուցում լիարժեք CRUD ինտերֆեյս՝ որոնումով, ֆիլտրերով, էջավորմամբ և թույլտվությունների ստուգումով։ Գրանցեք մոդելը, նշեք, որ սյունակները ցույց տալ և որ դաշտերով ֆիլտրել, և աշխատակիցները կարող են անմիջապես կառավարել տվյալները։ Սա այն հիմնական պատճառներից է, որոնց համար թիմերը Django են ընտրում ներքին գործիքների և բովանդակությամբ հարուստ պրոդուկտների համար։ Ադմինին վերաբերվեք որպես վստահելի աշխատակիցների գործիքի, ոչ թե հաճախորդների համար UI-ի. տեղադրեք այն ոչ ակնհայտ ուղու վրա, պահանջեք ուժեղ գաղտնաբառեր կամ SSO, և օգտագործեք list_select_related, որպեսզի մեծ աղյուսակները N+1 հարցումներ չառաջացնեն։

1from django.contrib import admin
2from .models import Product
3 
4@admin.register(Product)
5class ProductAdmin(admin.ModelAdmin):
6    list_display = ("name", "category", "price", "created_at")
7    list_filter = ("category",)
8    search_fields = ("name",)
9    list_select_related = ("category",)
10    ordering = ("-created_at",)

05JSON API-ներ Django REST Framework-ով

Django-ն լռելյայն HTML է ռենդեր անում։ JSON API-ների համար թիմերի մեծ մասն ավելացնում է Django REST Framework (DRF)։ Դրա հիմնական բլոկներն են serializer-ները (մոդելները վերածում են JSON-ի և վալիդացնում մուտքը՝ ինչպես Laravel-ի Form Request-ները գումարած API Resource-ները), view-երը կամ viewset-ները (մշակում են HTTP մեթոդները) և router-ները (գեներացնում են URL-ները)։ DRF-ը տալիս է նաև authentication կլասներ, թույլտվություններ, throttling, էջավորում և զարգացման համար browsable API։ Django Ninja-ն ավելի նոր այլընտրանք է, որը FastAPI-ի ոճով օգտագործում է type hints և Pydantic, միաժամանակ պահպանելով Django-ի ORM-ն ու ադմինը։

1from rest_framework import serializers, viewsets, permissions
2from .models import Product
3 
4class ProductSerializer(serializers.ModelSerializer):
5    class Meta:
6        model = Product
7        fields = ["id", "name", "price", "category"]
8 
9class ProductViewSet(viewsets.ModelViewSet):
10    queryset = Product.objects.select_related("category").order_by("id")
11    serializer_class = ProductSerializer
12    permission_classes = [permissions.IsAuthenticatedOrReadOnly]
13 
14# urls.py
15# router = routers.DefaultRouter(); router.register("products", ProductViewSet)

06FastAPI՝ async, տիպավորված այլընտրանքը

FastAPI-ն միկրո-ֆրեյմվորք է՝ կառուցված Starlette-ի (ASGI գործիքակազմ) և Pydantic-ի (վալիդացիա) վրա։ Հարցման և պատասխանի կառուցվածքները հայտարարում եք որպես Pydantic մոդելներ type hints-ով, և FastAPI-ն ավտոմատ վալիդացնում է մուտքը, սերիալիզացնում ելքը և /docs հասցեում գեներացնում OpenAPI փաստաթղթեր։ Այն async-first է, ուստի լավ է մշակում շատ զուգահեռ, I/O-ով սահմանափակված հարցումներ. դրա համար էլ այն տարածված է ML մոդելներ մատուցելու և API gateway-երի համար։ Փոխզիջումը. չունի ներկառուցված ORM, ադմին, միգրացիաներ կամ auth համակարգ։ Դուք ինքներդ եք ընտրում SQLAlchemy կամ SQLModel, Alembic միգրացիաների համար և ձեր սեփական auth-ը։ Ընտրեք Django, երբ ուզում եք ամբողջական, կարծիք ունեցող (opinionated) պրոդուկտային ֆրեյմվորք. ընտրեք FastAPI, երբ ուզում եք փոքր, արագ, տիպավորված API ծառայություն։

1from fastapi import FastAPI, HTTPException
2from pydantic import BaseModel, Field
3 
4app = FastAPI()
5 
6class ProductIn(BaseModel):
7    name: str = Field(min_length=1, max_length=200)
8    price: float = Field(gt=0)
9 
10@app.post("/products", status_code=201)
11async def create_product(body: ProductIn) -> dict:
12    if body.name.lower() == "test":
13        raise HTTPException(status_code=422, detail="Reserved name")
14    return {"id": 1, **body.model_dump()}
15 
16# run: uv add "fastapi[standard]" && uv run fastapi dev main.py

07Python վեբ հավելվածների գործարկումը production-ում

Զարգացման ժամանակ օգտագործում եք runserver կամ fastapi dev, բայց երբեք production-ում։ Սինքրոն Django հավելվածի համար դասական կարգավորումը Gunicorn-ն է մի քանի worker պրոցեսներով nginx-ի հետևում։ Async կոդի համար (FastAPI, Django async view-եր, WebSocket-ներ Channels-ի միջոցով) գործարկում եք ASGI սերվեր, օրինակ՝ Uvicorn, հաճախ Gunicorn-ի կառավարմամբ կամ որպես մի քանի Uvicorn worker։ Ստատիկ ֆայլերը հավաքվում են collectstatic-ով և մատուցվում nginx-ով, CDN-ով կամ WhiteNoise-ով։ Կարգավորումները գալիս են միջավայրի փոփոխականներից, DEBUG-ը պետք է լինի False, ALLOWED_HOSTS-ը պետք է սահմանված լինի, իսկ manage.py check --deploy-ը ցույց է տալիս բացակայող անվտանգության կարգավորումները։ Ֆոնային աշխատանքը գնում է Celery-ին, RQ-ին, Dramatiq-ին կամ Django-ի նոր tasks API-ին՝ worker backend-ով։

1# Django (WSGI) with 4 workers
2gunicorn config.wsgi:application --workers 4 --bind 127.0.0.1:8000
3 
4# FastAPI or Django ASGI
5uvicorn main:app --host 127.0.0.1 --port 8000 --workers 4
6 
7# Before each deploy
8python manage.py check --deploy
9python manage.py migrate --noinput
10python manage.py collectstatic --noinput

08Ինչպես են QuerySet-ներն իրականում կատարվում

QuerySet-ը ծույլ է. filter-ը, exclude-ը և order_by-ը պարզապես կառուցում են ներքին հարցման ծառ։ SQL-ը կատարվում է, երբ իտերացնում եք, կանչում list(), len(), bool(), կտրում եք քայլով (step) կամ դիմում ինդեքսով։ Առաջին հաշվարկից հետո արդյունքները քեշավորվում են այդ QuerySet օբյեկտի վրա, ուստի այն երկու անգամ իտերացնելը բազային դիմում է մեկ անգամ, բայց .all()-ը կրկին կանչելը ստեղծում է նոր QuerySet և նոր հարցում։ exists()-ը և count()-ը կատարում են էժան, նպատակային հարցումներ, ուստի օգտագործեք դրանք len()-ի փոխարեն, երբ ձեզ պետք է միայն թիվ։ Հսկայական աղյուսակների համար .iterator(chunk_size=2000)-ը հոսքով բերում է տողերը՝ առանց բոլորը հիշողությունում քեշավորելու։ F() արտահայտությունները թվաբանությունը տեղափոխում են SQL և խուսափում race condition-ներից, իսկ annotate-ը Subquery-ով կամ ագրեգատներով հաշվետվական տրամաբանությունը պահում է բազայում։

1from django.db.models import F, Count, Q
2 
3# Atomic increment in SQL, no read-modify-write race
4Product.objects.filter(pk=42).update(stock=F("stock") - 1)
5 
6# Aggregate in the database, not in Python
7Category.objects.annotate(
8    active=Count("products", filter=Q(products__price__gt=0))
9).order_by("-active")
10 
11# Stream a large export
12for p in Product.objects.only("id", "name").iterator(chunk_size=2000):
13    ...

09Տրանզակցիաներ, կողպումներ և հետևողականություն

Լռելյայն Django-ն աշխատում է autocommit ռեժիմում. յուրաքանչյուր հարցում commit է լինում ինքնուրույն։ Բազմաքայլ փոփոխությունները փաթեթավորեք transaction.atomic()-ի մեջ, որպեսզի դրանք միասին հաջողվեն կամ ձախողվեն։ Տողային կողպումների համար atomic-ի ներսում select_for_update()-ը կատարում է SELECT ... FOR UPDATE, և այսպես եք անվտանգ նվազեցնում պահեստի քանակը կամ գումար տեղափոխում հաշիվների միջև։ Կողմնակի ազդեցությունները, օրինակ՝ email ուղարկելը կամ task հերթագրելը, պետք է կատարվեն միայն commit-ից հետո. transaction.on_commit()-ը հենց դա է անում, ուստի worker-ը երբեք չի մշակի rollback արված տող։ ATOMIC_REQUESTS-ը յուրաքանչյուր հարցում փաթեթավորում է տրանզակցիայի մեջ, ինչը պարզ է, բայց դանդաղ view-երի ժամանակ տրանզակցիաները բաց է պահում, ուստի շատ թիմեր նախընտրում են բացահայտ atomic բլոկներ։

1from django.db import transaction
2 
3def reserve(product_id: int, qty: int) -> None:
4    with transaction.atomic():
5        p = Product.objects.select_for_update().get(pk=product_id)
6        if p.stock < qty:
7            raise ValueError("Out of stock")
8        p.stock -= qty
9        p.save(update_fields=["stock"])
10        transaction.on_commit(lambda: notify_warehouse.enqueue(product_id))

10Async Python-ում. ինչն է իրականում զուգահեռ աշխատում

Python-ի asyncio-ն coroutine-ները գործարկում է մեկ thread-ով event loop-ի վրա։ Զուգահեռությունը գալիս է I/O-ին await անելուց. մինչ մի հարցումը սպասում է ցանցին, մյուսն աշխատում է։ Արգելափակող կանչը (time.sleep, սինքրոն DB դրայվեր, requests) կանգնեցնում է ամբողջ loop-ը։ FastAPI-ն սա լավ է լուծում. սովորական def endpoint-ներն աշխատում են thread pool-ում, async def endpoint-ները՝ loop-ի վրա։ Django-ի async view-երն աշխատում են, և ORM-ը տրամադրում է async մեթոդներ (aget, acreate, async for), բայց բազայի շերտը դեռ հիմնականում աշխատում է thread-ում sync_to_async-ի միջոցով, ուստի async Django-ն հիմնականում օգուտ է տալիս I/O fan-out-ին և երկարատև կապերին, ոչ թե հարցումների մաքուր throughput-ին։ CPU-ով սահմանափակված աշխատանքին պետք են պրոցեսներ կամ native կոդ. Python 3.13-ը և 3.14-ը առաջարկում են ընտրովի free-threaded build, որը հեռացնում է GIL-ը, բայց գրադարանների աջակցությունը դեռ հասունանում է։

11Django deployment-ի մասշտաբավորում և ամրապնդում

Django-ն մասշտաբավորվում է հորիզոնական. հավելվածը stateless է, եթե session-ներն ու քեշը ապրում են Redis-ում կամ բազայում, ուստի load balancer-ի հետևում ավելացնում եք Gunicorn պրոցեսներ և սերվերներ։ Առաջին նեղ տեղը դառնում է կապերի քանակը. սահմանեք CONN_MAX_AGE մշտական կապերի համար, կամ օգտագործեք Django 5.1+-ի native PostgreSQL connection pooling-ը, կամ PgBouncer բազայի առջև։ Թանկ ֆրագմենտներն ու view-երը քեշավորեք Redis-ի վրա հիմնված cache framework-ով։ Read replica-ները աջակցվում են database router-ների միջոցով։ Անվտանգության առումով միացրեք SECURE_SSL_REDIRECT, SESSION_COOKIE_SECURE, CSRF_COOKIE_SECURE և HSTS, SECURE_PROXY_SSL_HEADER-ը կարգավորեք միայն այն դեպքում, երբ ձեր proxy-ն սահմանում է այդ header-ը, և ադմինը պահեք անսովոր URL-ի հետևում MFA-ով։

1# settings/production.py (excerpt)
2DEBUG = False
3ALLOWED_HOSTS = ["example.com"]
4SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
5SECURE_SSL_REDIRECT = True
6SESSION_COOKIE_SECURE = CSRF_COOKIE_SECURE = True
7SECURE_HSTS_SECONDS = 31536000
8DATABASES["default"]["CONN_MAX_AGE"] = 60
9CACHES = {"default": {"BACKEND": "django.core.cache.backends.redis.RedisCache",
10                      "LOCATION": "redis://127.0.0.1:6379/1"}}