Nangungunang 5 Asynchronous Web Frameworks para sa Python

Ang Asynchronous programming ay isang first-class na mamamayan sa Python ngayon. Kung ikaw ay isang developer ng web, may mga kamangha-manghang mga balangkas na maaari mong piliin!


Tulad ng pagsulat, ang asynchronous ay hindi lamang isang buzzword sa pamayanan ng Python. Sa pagpapakawala nito asyncio library sa bersyon na 3.5, kinilala ni Python ang epekto ng Node.js sa pagbuo ng web at ipinakilala ang dalawang bagong keyword sa wika – async at naghihintay. Napakahusay nito sapagkat ang wika ng Python ay lubos na nag-iingat sa pagpapalawak ng pangunahing syntax maliban kung mayroong isang kinakailangang pagpindot, na nagpapahiwatig lamang kung gaano kahalaga ang itinuturing ng mga tagagawa ng Python na mga hindi nakakasamang kakayahan.

Dahil dito, binuksan ang mga baha ng programa ng walang tulay: ang mga aklatan na bago at luma ay nagsimulang gumamit ng tampok na coroutines, ang mga asynchronous frameworks ay sumabog sa katanyagan, at ang mga bago ay sinusulat pa rin. Hindi naririnig ang pagganap ng pagganap o mas mahusay kaysa sa Node.js, at maliban kung ang iyong mga pattern sa paglo-load ay nagsasangkot ng maraming mga gawain na mabigat sa CPU, walang dahilan kung bakit hindi ka makagawa ng ilang libong kahilingan sa bawat segundo.

Ngunit sapat na pagganyak!

Suriin natin ang kasalukuyang tanawin ng Python at suriin ang ilan sa mga nangungunang mga pabrika ng tuling.

Tornado

Nakakagulat, Tornado ay hindi isang bagong balangkas. Ang paunang paglabas nito ay noong 2009 (eksaktong sampung taon na ang nakalilipas, tulad ng pagsulat) at mula noon, ang pokus nito ay sa pagbibigay ng rock-solid asynchronous programming na may mataas na kasabay.

Tornado ay hindi isang balangkas sa web sa panimula. Ito ay isang koleksyon ng mga asynchronous module, na ginagamit din upang bumuo ng module ng web framework. Mas partikular, ang mga modyul na ito ay:

  • Ang Coroutines at iba pang mga primitibo (tornado.gen, tornado.locks, tornado.queues, atbp.)
  • Mga module sa network (buhawi.ioloop, buhawi.iostream, atbp.)
  • Asynchronous server at kliyente (tornado.httpserver, buhawi.httpclient, atbp.)

Ang mga ito ay pinagsama upang makagawa ng pangwakas na mga module ng balangkas: buhawi.web, buhawi.routing, tornado.template, atbp.

import ng buhawi.ioloop
import ng buhawi.web

klase MainHandler (buhawi.web.RequestHandler):
def makakuha ng (sarili):
self.write ("Kumusta, mundo")

def make_app ():
bumalik buhawi.web.Application ([
(r"/", MainHandler),
])

kung __name__ == "__main__":
app = make_app ()
app.listen (8888)
buhawi.ioloop.IOLoop.current () magsimula ()

Ang Tornado ay may isang malakas at nakatuon na sumusunod sa komunidad ng Python at ginagamit ng mga nakaranas na arkitekto upang makabuo ng lubos na may kakayahang mga sistema. Ito ay isang balangkas na matagal nang nagkaroon ng sagot sa mga problema ng pag-iipon ngunit marahil ay hindi naging mainstream dahil hindi nito suportado ang pamantayang WSGI at labis na pagbili (tandaan na ang bulk ng mga aklatan ng Python ay magkasabay pa rin ).

Sanic

Sanic ay isang “moderno” na balangkas sa totoong kahulugan ng salita: hindi nito suportado ang bersyon ng Python sa ibaba 3.6, ay sumusuporta sa simple at unibersal na async / hinihintay na syntax sa labas ng kahon, at bilang isang resulta, hindi ka nagbabasa ng naglo-load ng dokumentasyon at panatilihin sa iyong isip ang mga kaso ng gilid bago mo maisulat ang iyong unang tagahawak ng HTTP.

Bilang isang resulta, ang nagresultang syntax ay medyo kaaya-aya (sa aking opinyon, hindi bababa sa); ito ay kahawig ng code na naisulat mo sa anumang iba pang mga microframework (Flask, CherryPy, halimbawa) na may ilan lamang na async na naihiwalay sa:

mula sa sanic import na Sanic
mula sa sanic.response import json

app = Sanic ()

@ app.route ("/")
async def test (kahilingan):
bumalik json ({"Kamusta": "mundo"})

kung __name__ == "__main__":
app.run (host ="0.0.0.0", port = 8000)

Ang Sanic ay arguably ang pinakatanyag at pinaka-mahal na async framework sa Python world. Ito ay halos lahat ng mga tampok na nais mo para sa iyong mga proyekto – pagruruta, middleware, cookies, pag-bersyon, blueprints, pananaw na nakabase sa klase, static file, streaming, socket, atbp – at kung ano ang hindi nag-aalok sa labas ng kahon – Ang templating, suporta sa database, file I / O, mga pila – maaaring maidagdag dahil may mga sapat na aklatan ng async para sa mga ngayon.

Vibora

Vibora ay isang malapit na pinsan ni Sanic, maliban kung naayos ito sa pagiging pinakamabilis na server ng Python web doon. Sa katunayan, ang pinakaunang pagbisita sa website nito ay nagbibigay sa iyo ng isang paghahambing sa balangkas:

Tulad ng nakikita mo, inaangkin ng Vibora na maraming beses nang mas mabilis kaysa sa mga klasikong frameworks at higit pa sa dalawang beses nang mas mabilis sa Sanic, ang pinakamalapit na katunggali nito. Siyempre, ang mga benchmark ay dapat kunin ng isang butil ng asin. ��

Bagaman sa syntax at mga tampok, ang Vibora ay maihahambing sa Sanic (o marahil kahit na mas mahusay kaysa sa pag-bundle nito ng mga sikat na aklatan at mga bagay tulad ng pag-template ay magagamit sa labas ng kahon), nais kong isaalang-alang ang Sanic na maging mas mature dahil ito ay mas mahaba at mayroon isang mas malaking komunidad.

mula sa vibora import Vibora, JsonResponse

app = Vibora ()

@ app.route (‘/’)
async def home ():
bumalik JsonResponse ({‘hello’: ‘mundo’})

kung __name__ == ‘__main__’:
app.run (host ="0.0.0.0", port = 8000)

Kung ikaw ay isang junkie ng pagganap, bagaman, maaaring lumutang si Vibora ng iyong bangka. Iyon ay sinabi, tulad ng pagsulat ng Vibora ay isinasagawa ang isang kumpletong pagsulat upang maging mas mabilis, at ang link sa bersyon ng pagganap nito ay nagsasaad ito sa ilalim ng “mabigat na pag-unlad.” Ito ay magiging isang pabayaan para sa mga nakakakuha ng Vibora nang mas maaga at sa lalong madaling panahon ay dapat na harapin ang mga pagbagsak, ngunit hey, ito ay mga unang araw sa Python async mundo, at walang inaasahan na maging matatag ang mga bagay..

Quart

Kung masiyahan ka sa pag-unlad sa Flask ngunit ibinaon ang kakulangan ng suporta ng async, masisiyahan ka Quart marami.

Ang Quart ay sumusunod sa ASGI pamantayan, na kung saan ay isang kahalili sa sikat na pamantayang WSGI at nag-aalok ng suporta sa async. Ang kagiliw-giliw na bagay tungkol sa Quart ay hindi lamang katulad ng Flask ngunit talagang sumunod sa Flask API! Ang may-akda ng balangkas na ito ay nais na mapanatili ang pakiramdam ng Flask at magdagdag lamang ng async, WebSockets, at suporta sa HTTP 2. Bilang isang resulta, maaari mong malaman ang Quart mula mismo sa dokumentasyon ng Flask, na tandaan lamang na ang mga pag-andar sa Quart ay asynchronous.

mula sa quart import Quart

app = Quart (__ pangalan__)

@ app.route (‘/’)
hello async def hello ():
bumalik ‘hello’

app.run ()

Ang mga pakiramdam (halos) eksaktong katulad ng Flask, ay hindi?!

Dahil ang Quart ay isang ebolusyon ng Flask, ang lahat ng mga tampok sa loob ng Flask ay magagamit: ruta, middleware, session, templating, blueprints, at iba pa. Sa katunayan, maaari mo ring gamitin ang mga extension ng Flask nang direkta sa loob ng Quart. Ang isang catch ay ang Python 3.7+ ay sinusuportahan lamang, ngunit, kung hindi, hindi ka nagpapatakbo ng pinakabagong bersyon ng Python, marahil ang async ay hindi ang tamang landas. ��

Nais ng dokumentasyon kung wala kang mas maagang karanasan sa Flask, ngunit maaari kong inirerekumenda ang Quart dahil marahil ito ang tanging balangkas ng async na papalapit sa 1.0 na paglabas nito sa lalong madaling panahon.

FastAPI

Ang huling (ngunit pinaka-kahanga-hanga) na balangkas sa listahang ito ay FastAPI. Hindi, hindi ito isang balangkas ng API lamang; sa katunayan, ang FastAPI ay tila ang pinaka-tampok na mayaman at mayaman na papeles na mayaman sa dokumentasyon na napulot ko nang magsaliksik ng mga async Python frameworks.

Kapansin-pansin na pinag-aralan ng may-akda ng balangkas ang maraming iba pang mga frameworks, mula sa mga kontemporaryong tulad ng Django hanggang sa mga modernong katulad ng Sanic, pati na rin ang pagtingin sa mga teknolohiya sa NestJS (isang Node.js, Mga balangkas ng Mga webcript ng web). Ang kanilang pilosopiya sa pag-unlad at malawak na paghahambing ay mababasa dito.

Ang syntax ay medyo kaaya-aya; maaari pa ring talakayin ng isang tao na ito ay higit na kasiya-siya kaysa sa iba pang mga balangkas na ating natagpuan:

rom fastapi import ang FastAPI

app = FastAPI ()

@ app.get ("/ mga gumagamit / ako")
async def read_user_me ():
bumalik {"user_id": "ang kasalukuyang gumagamit"}

@ app.get ("/ mga gumagamit / {user_id}")
async def read_user (user_id: str):
bumalik {"user_id": user_id}

At ngayon, ang listahan ng mga tampok ng killer na gumagawa ng mga outpaper ng FastAPI na iba pang mga frameworks:

Mga henerasyon ng awtomatikong API: Sa sandaling nakasulat ang iyong mga pagtatapos, maaari kang maglaro sa API gamit ang isang pagsunod sa pamantayan ng UI. Ang SwaggerUI, ReDoc, at iba pa ay suportado.

Gumagawa din ang balangkas ng awtomatikong dokumentasyon ng modelo ng data sa JSON Schema.

Makabagong kaunlaran: Oo, ang salitang “moderno” ay natatapon ng maraming, ngunit natagpuan ko ang FastAPI na talagang lumakad sa pahayag nito. Ang Dependency Injection at type hinting ay mga first class na mamamayan, na nagpapatupad hindi lamang magandang mga prinsipyo ng coding ngunit pinipigilan ang mga bug at pagkalito sa katagalan.

Malawak na dokumentasyon: Hindi ko alam ang tungkol sa iyo, ngunit ako ay isang kabuuang pagsuso para sa mabuting dokumentasyon. At sa lugar na ito, ang FastAPI ay nanalo ng hands-down. Mayroon itong mga pahina sa mga pahina ng mga dokumento na nagpapaliwanag halos bawat maliit na kahusayan at “bantayan!” sandali para sa mga developer ng lahat ng mga antas. Nararamdaman ko ang isang malinaw na “puso at kaluluwa” sa mga dokumento dito, at ang tanging paghahambing na mahahanap ko ay ang mga Django doc (oo, ang mga dokumentong FastAPI ay mabuti!).

Higit pa sa mga pangunahing kaalaman: Ang FastAPI ay mayroong suporta para sa WebSockets, Streaming, pati na rin ang GraphQL, bukod sa pagkakaroon ng lahat ng mga tradisyunal na katulong tulad ng CORS, session, cookies, at iba pa.

At ano ang tungkol sa pagganap? Well, ang FastAPI ay itinayo sa kamangha-manghang library ng Starlette, na nagreresulta sa pagganap na tumutugma sa Node, at sa ilang mga kaso, kahit na Go! Lahat sa lahat, talagang mayroon akong pakiramdam na ang FastAPI ay magpapatakbo nang maaga bilang tuktok na balangkas ng async para sa Python.

Konklusyon

Marami ang nangyayari sa tanawin ng Python async sa mga araw na ito. Ang mga bagong frameworks ay lumalabas, ang mga luma ay muling isinusulat, at ang mga aklatan ay nabuo upang tumugma sa pag-uugali ng async. Habang ang suporta ng Python para sa isang loop ng kaganapan at posible na gawin ang mga bahagi ng iyong application async, maaari mong piliin na pumunta nang buo at bumuo sa isa sa mga frameworks dito. Siguraduhing tandaan ang pangmatagalang: sa ilan sa mga balangkas ng Python async ay mayroong mga unang yugto at mabilis na umuusbong, na sasaktan ang iyong proseso ng pag-unlad at itaas ang mga gastos sa negosyo. Ang pag-iingat ay susi!

Ngunit sinabi ng lahat at nagawa; Ang Python ay handa na sa paghahatid ng light-out na pagganap pagdating sa mga web frameworks. Kung matagal na mong iniisip ang paglipat sa Node, hindi mo na kailangan! ��

Tunog na cool? Master Python ngayon!

TAGS:

  • Python

Jeffrey Wilson Administrator
Sorry! The Author has not filled his profile.
follow me
    Like this post? Please share to your friends:
    Adblock
    detector
    map