Asynkron programmering er en førsteklasses borger i Python nå. Hvis du er en nettutvikler, er det fantastiske rammer du kan velge mellom!
I skrivende stund er ikke asynkron lenger bare et buzzword i Python-fellesskapet. Med utgivelsen av sin asyncio bibliotek i 3.5-versjon, Python anerkjente virkningen av Node.js på nettutvikling og introduserte to nye nøkkelord i språket – asynkron og avvent. Dette var en veldig stor sak fordi Python-språket er ekstremt forsiktig med å utvide kjernesyntaksen med mindre det er et presserende behov, noe som bare indikerer hvor fundamentalt viktig Python-utviklerne vurderte de asynkrone egenskapene.
Som et resultat ble sluser for asynkron programmering åpnet: nye og gamle biblioteker begynte å bruke coroutines-funksjonen, asynkrone rammeverk eksploderte i popularitet, og nye blir fortsatt skrevet i dag. Ytelse på nivå med eller bedre enn Node.js er ikke uhørt, og med mindre lastingsmønstrene dine involverer mange CPU-tunge oppgaver, er det ingen grunn til at du ikke kan gjøre noen tusen forespørsler per sekund.
Men nok motivasjon!
La oss undersøke det nåværende Python-landskapet og sjekke ut noen av de beste asynkrone rammeverkene.
Innholdsfortegnelse
Tornado
Overraskende, Tornado er ikke et nytt rammeverk i det hele tatt. Den første utgivelsen var i 2009 (nøyaktig ti år siden, i skrivende stund) og siden den gang har fokuset vært på å tilby bunnsolid asynkron programmering med høy samtidighet.
Tornado er i utgangspunktet ikke et nettrammeverk. Det er en samling av asynkrone moduler, som også brukes til å bygge nettrammemodulen. Mer spesifikt er disse modulene:
- Coroutiner og andre primitiver (tornado.gen, tornado.locks, tornado.queues, etc.)
- Nettverksmoduler (tornado.ioloop, tornado.iostream, etc.)
- Asynkrone servere og klienter (tornado.httpserver, tornado.httpclient, etc.)
Disse er kombinert for å produsere de endelige rammeverksmodulene: tornado.web, tornado.routing, tornado.template, etc.
import tornado.ioloop
import tornado.web
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 har en sterk og engasjert tilhengerskare i Python-fellesskapet og brukes av erfarne arkitekter til å bygge svært dyktige systemer. Det er et rammeverk som lenge har hatt svaret på problemene med samtidighet, men som kanskje ikke ble mainstream siden det ikke støtter WSGI-standarden og var for mye av en buy-in (husk at hoveddelen av Python-bibliotekene fortsatt er synkrone ).
Sanic
Sanic er et «moderne» rammeverk i ordets rette forstand: det støtter ikke Python-versjon under 3.6, støtter den enkle og universelle async/vent-syntaksen ut av esken, og får deg som et resultat ikke til å lese mye av dokumentasjon og ha kantsaker i tankene dine før du kan skrive din første HTTP-behandler.
Som et resultat er den resulterende syntaksen ganske behagelig (etter min mening i det minste); den ligner kode du ville skrevet med et hvilket som helst annet mikrorammeverk (Flask, CherryPy, for eksempel) med bare noen få asynkrone drysset inn:
from sanic import Sanic
from sanic.response import json
app = Sanic()
@app.route("/")
async def test(request):
return json({"hello": "world"})
if __name__ == "__main__":
app.run(host="0.0.0.0", port=8000)
Sanic er uten tvil det mest populære og mest elskede asynkrone rammeverket i Python-verdenen. Den har nesten alle funksjonene du ønsker for prosjektene dine – ruting, mellomvare, informasjonskapsler, versjonering, tegninger, klassebaserte visninger, statiske filer, streaming, sockets osv. – og hva den ikke tilbyr rett ut av esken. — maling, databasestøtte, fil-I/O, køer — kan legges til da det er akkurat nok asynkrone biblioteker for disse per i dag.
Vibora
Vibora er en nær fetter av Sanic, bortsett fra at den er fiksert på å bli den raskeste Python-nettserveren der ute. Faktisk hilser det aller første besøket på nettsiden deg med en rammesammenligning:
Som du kan se, hevder Vibora å være flere ganger raskere enn de klassiske rammeverkene og å være mer enn dobbelt så rask som Sanic, dens nærmeste konkurrent. Selvsagt skal benchmarks tas med en klype salt. 🙂
Selv om Vibora i syntaks og funksjoner er sammenlignbar med Sanic (eller kanskje til og med litt bedre ettersom den samler populære biblioteker og ting som maler er tilgjengelig ut av esken), vil jeg vurdere Sanic for å være mer moden ettersom den har eksistert lenger og har et større fellesskap.
from vibora import Vibora, JsonResponse
app = Vibora()
@app.route('/')
async def home():
return JsonResponse({'hello': 'world'})
if __name__ == '__main__':
app.run(host="0.0.0.0", port=8000)
Hvis du er en ytelsesjunkie, kan det hende at Vibora flyter båten din. Når det er sagt, i skrivende stund undergår Vibora en fullstendig omskriving for å bli enda raskere, og den link til ytelsesversjonen står det at den er under «tung utvikling.» Det kommer til å være en skuffelse for de som plukket opp Vibora tidligere og snart må møte brytende endringer, men hei, det er tidlig i Python async-verdenen, og ingen forventer at ting skal være stabile.
Quart
Hvis du liker å utvikle i Flask, men beklager mangelen på async-støtte, vil du glede deg Quart mye.
Quart er i samsvar med ASGI standard, som er en etterfølger til den berømte WSGI-standarden og tilbyr async-støtte. Det interessante med Quart er at det ikke bare ligner Flask, men faktisk er kompatibelt med Flask API! Forfatteren av dette rammeverket ønsket å bevare Flask-følelsen og bare legge til async, WebSockets og HTTP 2-støtte til den. Som et resultat kan du lære Quart rett fra Flask-dokumentasjonen, bare husk at funksjoner i Quart er asynkrone.
from quart import Quart
app = Quart(__name__)
@app.route('/')
async def hello():
return 'hello'
app.run()
Føles (nesten) akkurat som Flask, ikke sant?!
Siden Quart er en videreutvikling av Flask, er alle funksjonene i Flask tilgjengelig: ruting, mellomvare, økter, maler, tegninger og så videre. Faktisk kan du til og med bruke Flask-utvidelser direkte inne i Quart. En hake er at Python 3.7+ bare støttes, men hvis du ikke kjører den nyeste versjonen av Python, er kanskje ikke asynkronisering den rette veien. 🙂
Dokumentasjonen er virkelig ettertraktet hvis du ikke har tidligere erfaring med Flask, men jeg kan anbefale Quart siden det sannsynligvis er det eneste asynkrone rammeverket som snart nærmer seg 1.0-utgivelsen.
FastAPI
Det siste (men mest imponerende) rammeverket på denne listen er FastAPI. Nei, det er ikke bare et API-rammeverk; Faktisk ser FastAPI ut til å være det mest funksjonsrike og dokumentasjonsrike rammeverket jeg kom over da jeg undersøkte asynkrone Python-rammeverk.
Det er interessant å merke seg at rammeverksforfatteren studerte flere andre rammeverk i dybden, fra moderne som Django til moderne som Sanic, i tillegg til å se på tvers av teknologier inn i NestJS (et Node.js, Typescript nettrammeverk). Deres utviklingsfilosofi og omfattende sammenligninger kan leses her.
Syntaksen er ganske behagelig; man kan til og med hevde at det er mye morsommere enn de andre rammene vi har vært borti:
rom fastapi import FastAPI
app = FastAPI()
@app.get("/users/me")
async def read_user_me():
return {"user_id": "the current user"}
@app.get("/users/{user_id}")
async def read_user(user_id: str):
return {"user_id": user_id}
Og nå, listen over mordere funksjoner som får FastAPI til å overgå andre rammer:
Automatisk generering av API-dokumenter: Så snart endepunktene dine er skrevet, kan du leke med API ved å bruke et standardkompatibelt brukergrensesnitt. SwaggerUI, ReDoc og andre støttes.
Rammeverket gjør også automatisk datamodelldokumentasjon med JSON Schema.
Moderne utvikling: Ja, ordet «moderne» blir slengt mye rundt, men jeg fant at FastAPI faktisk snakket. Dependency Injection og type hint er førsteklasses borgere, og håndhever ikke bare gode kodingsprinsipper, men forhindrer feil og forvirring i det lange løp.
Omfattende dokumentasjon: Jeg vet ikke med deg, men jeg er en total suger på god dokumentasjon. Og på dette området vinner FastAPI hands-down. Den har sider på sider med dokumenter som forklarer nesten alle små finesser og «pass på!» øyeblikk for utviklere på alle nivåer. Jeg fornemmer et klart «hjerte og sjel» i dokumentene her, og den eneste sammenligningen jeg kan finne er Django-dokumentene (ja, FastAPI-dokumentene er så gode!).
Utover det grunnleggende: FastAPI har støtte for WebSockets, Streaming, samt GraphQL, i tillegg til å ha alle de tradisjonelle hjelperne som CORS, økter, informasjonskapsler og så videre.
Og hva med ytelsen? Vel, FastAPI er bygget på det fantastiske Starlette-biblioteket, noe som resulterer i ytelse som matcher Node, og i noen tilfeller til og med Go! Alt i alt har jeg virkelig følelsen av at FastAPI kommer til å kjøre videre som det beste asynkrone rammeverket for Python.
Konklusjon
Mye skjer i Python async-landskapet i disse dager. Nye rammer dukker opp, gamle blir skrevet om, og biblioteker utvikles for å matche asynkron atferd. Mens Python har innebygd støtte for en eventloop og det er mulig å gjøre deler av applikasjonen din asynkron, kan du velge å gå all-in og bygge på et av rammeverkene her. Bare husk å ha det langsiktige i tankene: flere av Python async-rammeverket der ute er i tidlige stadier og utvikles raskt, noe som kommer til å skade utviklingsprosessen din og øke forretningskostnadene. Forsiktighet er nøkkelen!
Men alt sagt og gjort; Python er produksjonsklar for å levere lett ytelse når det kommer til nettrammeverk. Hvis du så lenge har tenkt på å migrere til Node, trenger du ikke det nå! 🙂
Høres kult ut? Mester Python i dag!