I 5 migliori frame web asincroni per Python

La programmazione asincrona è ora un cittadino di prima classe in Python. Se sei uno sviluppatore web, puoi scegliere tra fantastici framework!


Al momento della scrittura, asincrono non è più solo una parola d’ordine nella comunità Python. Con il rilascio del suo asyncio libreria nella versione 3.5, Python ha riconosciuto l’impatto di Node.js sullo sviluppo web e ha introdotto due nuove parole chiave nel linguaggio: asincrono e attendi. Questo è stato un grosso problema perché il linguaggio Python è estremamente diffidente nell’espandere la sintassi principale a meno che non vi sia una necessità urgente, il che indica solo quanto gli sviluppatori Python abbiano un’importanza fondamentale considerando le capacità asincrone.

Di conseguenza, sono state aperte le porte della programmazione asincrona: nuove e vecchie biblioteche hanno iniziato a fare uso della funzione coroutine, i quadri asincroni sono esplosi in popolarità e ne sono ancora in fase di scrittura nuovi. Le prestazioni alla pari o migliori di quelle di Node.js non sono inaudite e, a meno che i tuoi schemi di caricamento non comportino molte attività pesanti per la CPU, non c’è motivo per cui non puoi effettuare alcune migliaia di richieste al secondo.

Ma abbastanza motivazione!

Esaminiamo l’attuale panorama di Python e analizziamo alcuni dei migliori framework asincroni.

Tornado

sorprendentemente, Tornado non è affatto un nuovo framework. La sua versione iniziale è stata nel 2009 (esattamente dieci anni fa, al momento della stesura) e da allora, il suo obiettivo è stato quello di fornire una solida programmazione asincrona con elevata concorrenza.

Il tornado non è fondamentalmente un framework web. È una raccolta di moduli asincroni, che vengono anche utilizzati per creare il modulo web framework. Più specificamente, questi moduli sono:

  • Coroutine e altri primitivi (tornado.gen, tornado.locks, tornado.queues, ecc.)
  • Moduli di rete (tornado.ioloop, tornado.iostream, ecc.)
  • Server e client asincroni (tornado.httpserver, tornado.httpclient, ecc.)

Questi sono stati combinati per produrre i moduli finali del framework: tornado.web, tornado.routing, tornado.template, ecc..

import tornado.ioloop
import tornado.web

classe MainHandler (tornado.web.RequestHandler):
def get (self):
self.write ("Ciao mondo")

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

se __name__ == "__principale__":
app = make_app ()
app.listen (8888)
tornado.ioloop.IOLoop.current (). start ()

Tornado ha un seguito forte e impegnato nella comunità Python ed è utilizzato da architetti esperti per costruire sistemi altamente capaci. È un framework che ha da tempo la risposta ai problemi della concorrenza, ma forse non è diventato mainstream in quanto non supporta lo standard WSGI ed era troppo un buy-in (ricorda che la maggior parte delle librerie Python sono ancora sincrone ).

Sanic

Sanic è un framework “moderno” nel vero senso della parola: non supporta la versione Python sotto 3.6, supporta la sintassi asincrona / attende semplice e universale pronta all’uso e, di conseguenza, non ti fa leggere carichi di documentazione e tieni a mente i casi limite prima di poter scrivere il tuo primo gestore HTTP.

Di conseguenza, la sintassi risultante è abbastanza piacevole (almeno secondo me); assomiglia al codice che scriveresti con qualsiasi altro microframework (Flask, CherryPy, per esempio) con solo alcuni asincroni sparsi in:

da Sanic import Sanic
da sanic.response import json

app = Sanic ()

@ App.route ("/")
test def asincrono (richiesta):
return json ({"Ciao": "mondo"})

se __name__ == "__principale__":
app.run (host ="0.0.0.0", port = 8000)

Sanic è senza dubbio il framework asincrono più popolare e più amato nel mondo Python. Ha quasi tutte le funzionalità che vorresti per i tuoi progetti – routing, middleware, cookie, versioning, progetti, viste basate su classi, file statici, streaming, socket, ecc. – e ciò che non offre immediatamente – templating, supporto database, I / O file, code – possono essere aggiunti in quanto ci sono abbastanza librerie asincrone per questi ad oggi.

Vibora

Vibora è un cugino stretto di Sanic, tranne per il fatto che è fissato per diventare il web server Python più veloce in circolazione. In effetti, la prima visita del suo sito Web ti saluta con un confronto quadro:

Come puoi vedere, Vibora afferma di essere molte volte più veloce dei framework classici e di essere due volte più veloce di Sanic, il suo concorrente più vicino. Naturalmente, i parametri di riferimento devono essere presi con un granello di sale. ��

Sebbene nella sintassi e nelle funzionalità, Vibora è paragonabile a Sanic (o forse anche leggermente meglio in quanto raggruppa librerie popolari e cose come il modello sono disponibili fuori dalla scatola), considererei Sanic più maturo poiché è in circolazione da più tempo e ha una comunità più grande.

da Vibora import Vibora, JsonResponse

app = Vibora ()

@ App.route ( ‘/’)
async def home ():
return JsonResponse ({‘hello’: ‘world’})

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

Se sei un drogato di prestazioni, però, Vibora potrebbe far galleggiare la tua barca. Detto questo, al momento di scrivere Vibora sta subendo una completa riscrittura per diventare ancora più veloce, e il collegamento alla sua versione delle prestazioni dice che è in “sviluppo pesante”. Sarà una delusione per coloro che hanno raccolto Vibora prima e presto dovranno affrontare cambiamenti inaspettati, ma ehi, sono i primi giorni nel mondo asincrono di Python e nessuno si aspetta che le cose siano stabili.

quarto di gallone

Se ti piace sviluppare in Flask ma non riesci a trovare il supporto asincrono, ti divertirai quarto di gallone Un sacco.

Quart è conforme al ASGI standard, che è il successore del famoso standard WSGI e offre supporto asincrono. La cosa interessante di Quart è che non è solo simile a Flask ma in realtà è conforme all’API Flask! L’autore di questo framework ha voluto preservare l’atmosfera di Flask e aggiungere semplicemente supporto asincrono, WebSocket e HTTP 2. Di conseguenza, puoi imparare Quart direttamente dalla documentazione di Flask, tenendo presente che le funzioni in Quart sono asincrone.

da quart import Quart

app = Quart (__ nome__)

@ App.route ( ‘/’)
async def hello ():
ritorna “ciao”

app.run ()

Sembra (quasi) esattamente come Flask, no?!

Poiché Quart è un’evoluzione di Flask, sono disponibili tutte le funzionalità all’interno di Flask: routing, middleware, sessioni, templating, progetti e così via. In effetti, puoi persino usare le estensioni Flask direttamente all’interno di Quart. Un problema è che Python 3.7+ è supportato solo, ma, quindi, se non si esegue l’ultima versione di Python, forse async non è la strada giusta. ��

La documentazione è davvero carente se non hai precedenti esperienze con Flask, ma posso consigliare Quart in quanto è probabilmente l’unico framework asincrono che si avvicina presto alla sua versione 1.0.

FastAPI

L’ultimo (ma il più impressionante) quadro in questo elenco è FastAPI. No, non è un framework solo API; infatti, FastAPI sembra essere il framework più ricco di funzionalità e documentazione che mi sono imbattuto durante la ricerca di framework Python asincroni.

È interessante notare che l’autore del framework ha studiato a fondo molti altri framework, da quelli contemporanei come Django a quelli moderni come Sanic, oltre a esaminare le tecnologie in NestJS (un framework web Node.js, Typescript). È possibile leggere la loro filosofia di sviluppo e ampi confronti Qui.

La sintassi è abbastanza piacevole; si può persino sostenere che sia molto più divertente rispetto agli altri framework in cui ci siamo imbattuti:

rom fastapi import FastAPI

app = FastAPI ()

@ App.get ("/ utenti / me")
async def read_user_me ():
ritorno {"ID utente": "l’utente corrente"}

@ App.get ("/ utenti / {} user_id")
async def read_user (user_id: str):
ritorno {"ID utente": ID utente}

E ora, l’elenco delle funzionalità killer che rendono FastAPI eclissare altri framework:

Generazione automatica di documenti API: Non appena i tuoi endpoint sono stati scritti, puoi giocare con l’API usando un’interfaccia utente conforme agli standard. SwaggerUI, ReDoc e altri sono supportati.

Il framework esegue inoltre la documentazione automatica del modello di dati con JSON Schema.

Sviluppo moderno: Sì, la parola “moderno” viene lanciata molto, ma ho trovato FastAPI in realtà a parlare. L’iniezione di dipendenza e il suggerimento sul tipo sono cittadini di prima classe, applicando non solo buoni principi di codifica ma prevenendo a lungo termine bug e confusione.

Ampia documentazione: Non so te, ma sono un vero sfigato per una buona documentazione. E in quest’area, FastAPI vince a mani basse. Ha pagine su pagine di documenti che spiegano quasi ogni piccola sottigliezza e “attenzione!” momenti per sviluppatori di tutti i livelli. Sento un chiaro “cuore e anima” nei documenti qui, e l’unico confronto che posso trovare sono i documenti Django (sì, i documenti FastAPI sono così buoni!).

Oltre le basi: FastAPI ha supporto per WebSocket, Streaming e GraphQL, oltre ad avere tutti gli helper tradizionali come CORS, sessioni, cookie e così via.

E la performance? Bene, FastAPI è costruito sulla straordinaria libreria Starlette, con prestazioni che corrispondono a Node e, in alcuni casi, anche Go! Tutto sommato, ho davvero la sensazione che FastAPI stia andando avanti come il miglior framework asincrono per Python.

Conclusione

Oggigiorno stanno accadendo molte cose nel panorama asincrono di Python. Nuovi framework stanno spuntando, quelli vecchi vengono riscritti e le librerie si stanno evolvendo per adattarsi al comportamento asincrono. Mentre Python ha il supporto integrato per un loop di eventi ed è possibile rendere asincrone alcune parti dell’applicazione, puoi scegliere di andare all-in e costruire su uno dei framework qui. Assicurati solo di tenere a mente il lungo termine: molti dei framework asincroni Python disponibili sono nelle prime fasi e si stanno evolvendo rapidamente, il che danneggerà il tuo processo di sviluppo e aumenterà i costi aziendali. La cautela è la chiave!

Ma tutto detto e fatto; Python è pronto per la produzione per offrire prestazioni eccezionali quando si tratta di framework Web. Se per così tanto tempo hai pensato di migrare su Node, ora non è necessario! ��

Sembra fantastico? Padrone oggi!

TAGS:

  • Pitone

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