Ո՞ր Python Web Framework-ն ընտրել 2023-ի համար՝ Django, Flask, FastAPI կամ Tornado:

Python-ը հզոր և բազմակողմանի ծրագրավորման լեզու է, որն օգտագործվում է տարբեր ծրագրերի համար: Այն հատկապես հայտնի է վեբ մշակման համար, քանի որ այն առաջարկում է շրջանակների մի շարք, որոնք կարող են օգտագործվել արագ և հեշտությամբ վեբ հավելվածներ մշակելու համար: Այս շրջանակներից են Django, Flask, FastAPI և Tornado:

Django-ն Python-ի բարձր մակարդակի վեբ շրջանակ է, որը թույլ է տալիս արագ զարգացնել անվտանգ և պահպանվող կայքերը: Այն հետևում է Model-Template-View (MTV) ճարտարապետական ​​օրինակին և ապահովում է համապարփակ միջավայր՝ վեբ հավելվածներ ստեղծելու և տեղակայելու համար:

Django-ի որոշ հիմնական հատկանիշները ներառում են.

1. ORM (Object-Relational Mapping) համակարգ. Django-ն ապահովում է բարձր մակարդակի ORM համակարգ տվյալների շտեմարանների հետ փոխազդելու համար՝ թույլ տալով ծրագրավորողներին շփվել տվյալների բազաների հետ՝ օգտագործելով Python կոդը, այլ ոչ թե հումքի SQL գրելու:
2. Admin Panel. Django-ն ներառում է հզոր և օգտագործողի համար հարմար ադմինիստրատորի վահանակ՝ ձեր հավելվածի տվյալները կառավարելու համար:
3. URL-ի երթուղղում. Django-ն ապահովում է URL-ի երթուղման պարզ, մաքուր և ճկուն համակարգ, ինչը հեշտացնում է մուտքային հարցումների մշակման օրինաչափությունների սահմանումը:
4. Անվտանգություն. Django-ն լրջորեն է վերաբերվում անվտանգությանը և ապահովում է մի քանի ներկառուցված անվտանգության առանձնահատկություններ, ինչպիսիք են պաշտպանությունը SQL ներարկումից, միջկայքի սկրիպտավորումից (XSS) և միջկայքի հարցումների կեղծման (CSRF) հարձակումներից:
5. Կաղապարի շարժիչ. Django-ն ներառում է կաղապարի հզոր շարժիչ՝ ներկայացման տրամաբանությունը կիրառական տրամաբանությունից բաժանելու համար, ինչը ժամանակի ընթացքում հեշտացնում է ձեր վեբ կայքի պահպանումն ու թարմացումը:

Ահա մի օրինակ, թե ինչպես ստեղծել Django նախագիծ.

• Տեղադրեք Django. Նախ, դուք պետք է տեղադրեք Django-ն ձեր համակարգչում: Դուք կարող եք դա անել՝ գործարկելով հետևյալ հրամանը ձեր տերմինալում կամ հրամանի տողում.

pip install Django

• Ստեղծեք Django նախագիծ. Երբ տեղադրեք Django-ն, կարող եք ստեղծել նոր նախագիծ՝ գործարկելով հետևյալ հրամանը ձեր տերմինալում կամ հրամանի տողում.

django-admin startproject myproject

Սա կստեղծի նոր գրացուցակ, որը կոչվում է myproject, որը պարունակում է ձեր Django նախագծի հիմնական կառուցվածքը:

• Գործարկեք զարգացման սերվերը. Հաջորդը, նավարկեք նոր ստեղծված myproject գրացուցակ և գործարկեք հետևյալ հրամանը՝ Django-ի զարգացման սերվերը գործարկելու համար.

python manage.py runserver

Սա կգործարկի զարգացման սերվերը և ձեր Django հավելվածը հասանելի կդարձնի http://127.0.0.1:8000/ հասցեով:

• Ստեղծեք Django հավելված. Ձեր նախագծի շրջանակներում դուք կարող եք ստեղծել մեկ կամ մի քանի հավելվածներ, որոնք կառավարում են տարբեր գործառույթներ: Նոր հավելված ստեղծելու համար գործարկեք հետևյալ հրամանը.

python manage.py startapp myapp

Սա կստեղծի նոր գրացուցակ, որը կոչվում է myapp, որը պարունակում է ձեր Django հավելվածի հիմնական կառուցվածքը:

• Սահմանեք մոդելները. Django-ի մոդելները ներկայացնում են ձեր հավելվածի տվյալները և սահմանում ձեր տվյալների դաշտերն ու վարքագիծը: Դուք կարող եք սահմանել ձեր մոդելները models.py ֆայլում՝ ձեր հավելվածի գրացուցակում: Օրինակ:

from django.db import models


class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=100)
    publication_date = models.DateField()

• Ստեղծեք տվյալների բազայի աղյուսակներ. Ձեր մոդելները սահմանելուց հետո կարող եք ստեղծել տվյալների բազայի անհրաժեշտ աղյուսակները՝ գործարկելով հետևյալ հրամանը.

python manage.py makemigrations
python manage.py migrate

• Սահմանեք դիտումները. Django-ում դիտումները մշակում են մուտքային HTTP հարցումները և վերադարձնում HTTP պատասխանները: Դուք կարող եք սահմանել ձեր տեսակետները views.py ֆայլում՝ ձեր հավելվածի գրացուցակում: Օրինակ:

from django.shortcuts import render
from .models import Book

def book_list(request):
    books = Book.objects.all()
    return render(request, 'book_list.html', {'books': books})

• Սահմանեք URL-ի նախշերը. Django-ում URL-ի օրինաչափությունները որոշում են, թե ինչպես են URL-ները համադրվում դիտումներին: Դուք կարող եք սահմանել ձեր URL-ի նախշերը urls.py ֆայլում՝ ձեր հավելվածի գրացուցակում: Օրինակ:

from django.urls import path
from . import views

urlpatterns = [
    path('books/', views.book_list, name='book_list'),
]

• Ստեղծեք ձևանմուշներ. Django-ի կաղապարները սահմանում են ձեր էջերի HTML կառուցվածքը: Դուք կարող եք ստեղծել ձեր ձևանմուշները templates գրացուցակում՝ ձեր հավելվածի գրացուցակում: Օրինակ:

<h1>Book List</h1>

<ul>
{% for book in books %}
  <li>{{ book.title }} by {{ book.author }}</li>
{% endfor %}
</ul>

• Փորձեք ձեր նախագիծը. Վերջապես, դուք կարող եք փորձարկել ձեր Django նախագիծը՝ մուտք գործելով URL

Flask-ը թեթև և ճկուն Python վեբ շրջանակ է, որը հարմար է փոքր և միջին չափի նախագծերին: Ի տարբերություն Django-ի, Flask-ը չի ներառում ORM (Object-Relational Manager) կամ շատ այլ բաղադրիչներ, ինչը թույլ է տալիս ընտրել այն գործիքները, որոնք լավագույնս համապատասխանում են ձեր կոնկրետ պահանջներին:

Flask-ի որոշ հիմնական հատկանիշները ներառում են.

1. Պարզ. Flask-ն ունի փոքր և պարզ միջուկ, ինչը հեշտացնում է սկսելը և հասկանալ, թե ինչպես է աշխատում շրջանակը:
2. Մինիմալիստական. Flask-ը չի ներառում ORM կամ շատ այլ բաղադրիչներ, որոնք դուք կարող եք գտնել այլ վեբ շրջանակներում, ինչը կարող է հեշտացնել ձեր հավելվածը հասկանալն ու հարմարեցնելը:
3. Մոդուլային. Flask-ը նախագծված է խիստ մոդուլային լինելու համար, որը թույլ է տալիս ավելացնել միայն ձեզ անհրաժեշտ բաղադրիչները և հեշտությամբ վերօգտագործել կոդը տարբեր նախագծերում:
4. Թեթև. Flask-ը թեթև շրջանակ է, որը հարմար է փոքր և միջին չափի նախագծերի համար և կարող է հեշտությամբ տեղակայվել տարբեր հարթակներում և հոսթինգ միջավայրերում:
5. Մեծ համայնք. Flask-ն ունի մշակողների մեծ և ակտիվ համայնք, ինչը հեշտացնում է անհրաժեշտության դեպքում օգնություն և ռեսուրսներ գտնելը:

Ահա մի օրինակ, թե ինչպես ստեղծել Flask նախագիծ.

• Տեղադրեք Flask. Նախ, դուք պետք է տեղադրեք Flask-ը ձեր համակարգչում: Դուք կարող եք դա անել՝ գործարկելով հետևյալ հրամանը ձեր տերմինալում կամ հրամանի տողում.

pip install Flask

• Ստեղծեք Flask հավելված. Նոր Flask հավելված ստեղծելու համար ստեղծեք նոր Python ֆայլ և ներմուծեք Flask դասը: Օրինակ:

from flask import Flask

app = Flask(__name__)

• Սահմանեք երթուղի. Հաջորդը, դուք պետք է սահմանեք երթուղի, որին ձեր դիմումը կպատասխանի: Դուք կարող եք դա անել՝ օգտագործելով @app.route decorator-ը: Օրինակ:

@app.route('/')
def index():
    return 'Hello, World!'

• Գործարկեք զարգացման սերվերը. Ձեր Flask հավելվածը գործարկելու համար դուք պետք է օգտագործեք Flask դասի գործարկման մեթոդը: Օրինակ:

if __name__ == '__main__':
    app.run(debug=True)

Սա կգործարկի Flask-ի մշակման սերվերը և ձեր հավելվածը հասանելի կդարձնի http://127.0.0.1:5000/-ում:

• Render կաղապարներ. Flask-ում ձևանմուշները ցուցադրելու համար դուք պետք է օգտագործեք render_template մեթոդը flask փաթեթից: Օրինակ:

from flask import Flask, render_template

@app.route('/')
def index():
    return render_template('index.html')

• Ստեղծեք ձևանմուշներ. այն ձևանմուշները, որոնք դուք ներկայացնում եք render_template մեթոդով, պետք է պահվեն ձեր հավելվածի գրացուցակում գտնվող կաղապարների գրացուցակում: Օրինակ:

<html>
  <head>
    <title>My Flask App</title>
  </head>
  <body>
    <h1>Hello, World!</h1>
  </body>
</html>

FastAPI-ն ժամանակակից, արագ, վեբ շրջանակ է Python 3.7+-ով API-ներ ստեղծելու համար՝ հիմնված ստանդարտ Python տիպի հուշումների վրա: FastAPI-ն կառուցված է Starlette-ի վերևում՝ վեբ մասերի համար, իսկ Pydantic-ը՝ տվյալների մասերի համար:

FastAPI-ի որոշ հիմնական հատկանիշները ներառում են.

1. Արագություն. FastAPI-ն ամենաարագ վեբ շրջանակներից մեկն է API-ներ ստեղծելու համար, որը թույլ է տալիս կարգավորել մեծ քանակությամբ հարցումներ՝ ցածր ծախսերով:
2. Տիպի ակնարկներ. FastAPI-ն օգտագործում է Python տեսակի ակնարկներ մուտքերի և ելքերի համար ակնկալվող տվյալները սահմանելու համար՝ հեշտացնելով ձեր կոդը գրելն ու հասկանալը և նվազեցնելով ձեռքով վավերացման անհրաժեշտությունը:
3. Հեշտ է սովորել. FastAPI-ն նախագծված է հեշտ սովորելու և օգտագործելու համար՝ պարզ և ինտուիտիվ API-ով, որը պահանջում է կաթսայի նվազագույն կոդ:
4. Async աջակցություն. FastAPI-ն աջակցում է ասինխրոն ծրագրավորմանը, որը թույլ է տալիս ստեղծել լայնածավալ և արձագանքող API-ներ, որոնք կարող են կարգավորել մեծ քանակությամբ հարցումներ:
5. Ինտեգրում հանրաճանաչ գրադարանների հետ. FastAPI-ն լավ ինտեգրվում է հայտնի Python գրադարաններին, ինչպիսիք են SQLAlchemy-ը և Tortoise-ORM-ը՝ տվյալների բազայի հասանելիության համար, և ունի ներկառուցված աջակցություն հարցումների տվյալների մշակման, նույնականացման և այլնի համար:

Ահա FastAPI-ում նախագիծ ստեղծելու օրինակ.

• Տեղադրեք FastAPI. Նախ, դուք պետք է տեղադրեք FastAPI ձեր համակարգչում: Դուք կարող եք դա անել՝ գործարկելով հետևյալ հրամանը ձեր տերմինալում կամ հրամանի տողում.

pip install fastapi

• Ստեղծեք FastAPI հավելված. Նոր FastAPI հավելված ստեղծելու համար ստեղծեք նոր Python ֆայլ և ներմուծեք FastAPI դասը: Օրինակ:

from fastapi import FastAPI


app = FastAPI()

• Սահմանեք երթուղի. Հաջորդը, դուք պետք է սահմանեք երթուղի, որին ձեր դիմումը կպատասխանի: Դուք կարող եք դա անել՝ օգտագործելով @app.get կամ @app.post դեկորատորը՝ կախված HTTP մեթոդից, որը ցանկանում եք կարգավորել: Օրինակ:

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

• Գործարկեք զարգացման սերվերը. Ձեր FastAPI հավելվածը գործարկելու համար կարող եք օգտագործել uvicorn հրամանի տող գործիքը: Օրինակ:

uvicorn main:app --reload

Սա կգործարկի FastAPI-ի մշակման սերվերը և ձեր հավելվածը հասանելի կդարձնի http://127.0.0.1:8000/:

• Սահմանել հարցումների տվյալները. FastAPI-ում հարցումի տվյալներ սահմանելու համար կարող եք օգտագործել Python տեսակի հուշումներ և Pydantic մոդելներ: Օրինակ:

from fastapi import FastAPI, Body
from pydantic import BaseModel


app = FastAPI()
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None
@app.post("/items/")
async def create_item(item: Item):
    return item

Tornado-ն Python վեբ շրջանակ է և ասինխրոն ցանցային գրադարան: Այն հարմար է երկարաժամկետ հարցումների և WebSockets հավելվածների համար, ինչը այն դարձնում է իդեալական իրական ժամանակի վեբ հավելվածների համար, ինչպիսիք են չաթի հավելվածները և առցանց խաղերը:

Tornado-ի որոշ հիմնական հատկանիշները ներառում են.

1. Async Աջակցություն. Tornado-ն ստեղծվել է ի սկզբանե ասինխրոն լինելու համար, ինչը հեշտացնում է արագ և մասշտաբային հավելվածների ստեղծումը:
2. Չարգելափակող I/O. Tornado-ն օգտագործում է չարգելափակող I/O՝ մեծ թվով միացումներ արդյունավետ կերպով կարգավորելու համար, նույնիսկ բարձր բեռի դեպքում:
3. Վեբ սերվեր. Tornado-ն ներառում է վեբ սերվեր, որը օպտիմիզացված է կատարողականի համար, ինչը հեշտացնում է ձեր հավելվածների արտադրությունը տեղակայելը:
4. Աջակցություն WebSockets-ին. Tornado-ն ունի ներկառուցված աջակցություն WebSockets-ին, ինչը հեշտացնում է իրական ժամանակում վեբ հավելվածների ստեղծումը:
5. Coroutines. Tornado-ն օգտագործում է կորուտիններ իր ասինխրոն API-ի համար, ինչը հեշտացնում է մաքուր, ընթեռնելի կոդ գրելը:
6. Հեշտ օգտագործման համար. Tornado-ն ունի պարզ API, որը հեշտացնում է վեբ մշակման սկիզբը, նույնիսկ նրանց համար, ովքեր նոր են վեբ ծրագրավորման մեջ:

Tornado-ն լավ հարմարեցված է բարձր արդյունավետությամբ վեբ հավելվածներ ստեղծելու համար, որոնք պահանջում են իրական ժամանակի հաղորդակցություն և լայնածավալության բարձր մակարդակ: Անկախ նրանից, թե դուք զրույցի հավելված եք ստեղծում, թե իրական ժամանակի խաղ, Tornado-ն ապահովում է հզոր գործիքների հավաքածու՝ արագ, մասշտաբային և արդյունավետ վեբ հավելվածներ ստեղծելու համար:

Ահա մի օրինակ, թե ինչպես ստեղծել Tornado նախագիծ.

• Տեղադրեք Tornado. Նախ, դուք պետք է տեղադրեք Tornado-ն ձեր համակարգչում: Դուք կարող եք դա անել՝ գործարկելով հետևյալ հրամանը ձեր տերմինալում կամ հրամանի տողում.

pip install tornado

• Ստեղծեք Tornado հավելված. Նոր Tornado հավելված ստեղծելու համար ստեղծեք նոր Python ֆայլ և ներմուծեք tornado.web և tornado.ioloop մոդուլները: Օրինակ:

import tornado.web
import tornado.ioloop


class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")
def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])
if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

• Գործարկեք հավելվածը. Ձեր Tornado հավելվածը գործարկելու համար պարզապես գործարկեք Python ֆայլը, որը ստեղծել եք քայլ 2-ում: Օրինակ.

python myapp.py

Սա կգործարկի Tornado-ի մշակման սերվերը և ձեր հավելվածը հասանելի կդարձնի http://localhost:8888/:

• Ավելացնել հարցումների մշակիչներ. Տարբեր հարցումներ կարգավորելու համար ձեզ հարկավոր է ստեղծել լրացուցիչ RequestHandlers և ավելացնել դրանք ձեր Tornado հավելվածում: Օրինակ:

class AboutHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("This is the about page")

    def make_app():
        return tornado.web.Application([
            (r"/", MainHandler),
            (r"/about", AboutHandler),
        ])

Python-ի օգտագործման լավագույն շրջանակը կախված է ձեր նախագծի կոնկրետ պահանջներից և նպատակներից:

Եթե ​​դուք կառուցում եք ավանդական, միաձույլ վեբ հավելված՝ հարաբերական տվյալների բազայով, Django-ն կարող է լինել լավագույն ընտրությունը:

Եթե ​​դուք կառուցում եք փոքր, պարզ API, Flask-ը կարող է լավ տարբերակ լինել:

FastAPI-ն համեմատաբար նոր շրջանակ է, որը նախատեսված է բարձր արդյունավետությամբ API-ներ ստեղծելու համար: Այն հիմնված է Starlette-ի վրա՝ վեբ մասերի համար, և Pydantic-ի՝ տվյալների մասերի համար: Դա հիանալի տարբերակ է, եթե ցանկանում եք ստեղծել արագ և ժամանակակից API:

Tornado-ն հասուն, չարգելափակող վեբ շրջանակ է, որը հարմար է իրական ժամանակում հավելվածներ ստեղծելու համար, ինչպիսիք են չաթի հավելվածները և առցանց խաղերը:

Ի վերջո, լավագույն շրջանակը ձեզ համար կախված կլինի ձեր նախագծի կարիքներից և ձեր զարգացման թիմի փորձից: Մտածեք խորությամբ ուսումնասիրել և գնահատել յուրաքանչյուր շրջանակ՝ որոշելու համար, թե որն է լավագույնս համապատասխանում ձեր կոնկրետ օգտագործման դեպքին: