Los 9 mejores marcos web asíncronos para Python

La programación asíncrona es ahora un ciudadano de primera clase en Python. Si usted es un desarrollador web, ¡hay increíbles frameworks entre los que puede elegir!

En el momento de escribir estas líneas, asíncrono ya no es sólo una palabra de moda en la comunidad Python. Con el lanzamiento de su biblioteca asyncio en la versión 3.5, Python reconoció el impacto de Node.js en el desarrollo web e introdujo dos nuevas palabras clave en el lenguaje: async y await.

Esto fue algo muy importante porque el lenguaje Python es extremadamente receloso a la hora de ampliar la sintaxis principal a menos que exista una necesidad apremiante, lo que sólo indica lo fundamentalmente importante que los desarrolladores de Python consideraban las capacidades asíncronas.

Como resultado, se abrieron las compuertas de la programación asíncrona: bibliotecas nuevas y viejas empezaron a hacer uso de la característica coroutines, los frameworks asíncronos explotaron en popularidad, y aún hoy se siguen escribiendo nuevos.

El rendimiento a la par o mejor que el de Node.js no es algo inaudito, y a menos que sus patrones de carga impliquen muchas tareas que consuman mucha CPU, no hay razón por la que no pueda hacer unos cuantos miles de peticiones por segundo.

Pero ¡basta de motivación!

Examinemos el panorama actual de Python y echemos un vistazo a algunos de los principales frameworks asíncronos.

Tornado

Sorprendentemente, Tornado no es un framework nuevo en absoluto. Su lanzamiento inicial fue en 2009 y, desde entonces, se ha centrado en proporcionar una programación asíncrona sólida como una roca con alta concurrencia.

Tornado no es un framework web fundamentalmente. Es una colección de módulos asíncronos, que también se utilizan para construir el módulo web framework. Más concretamente, estos módulos son

• Coroutines y otras primitivas (tornado.gen, tornado.locks, tornado.queues, etc.)
• Módulos de red (tornado.ioloop, tornado .iostream, etc.)
• Servidores y clientes asíncronos (tornado.httpserver, tornado.httpclient, etc.)

Estos se han combinado para producir los módulos finales del marco: tornado.web, tornado.routing, tornado.template, etc.

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
 def get(self):
 self.write("Hola, mundo")

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

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

Tornado tiene un fuerte y comprometido seguimiento en la comunidad Python y es utilizado por arquitectos experimentados para construir sistemas altamente capaces. Es un marco de trabajo que ha tenido durante mucho tiempo la respuesta a los problemas de concurrencia, pero quizás no se convirtió en la corriente principal, ya que no soporta el estándar WSGI y era demasiado exigente (recuerde que la mayor parte de las bibliotecas de Python siguen siendo síncronas).

Sanic

Sanic es un framework “moderno” en el verdadero sentido de la palabra: no soporta versiones de Python por debajo de la 3.6, soporta la simple y universal sintaxis async/await out of the box, y como resultado, no le hace leer montones de documentación y tener casos de borde en su mente antes de que pueda escribir su primer manejador HTTP.

Como resultado, la sintaxis resultante es bastante agradable (en mi opinión, al menos); se parece al código que escribiría con cualquier otro microframework (Flask, CherryPy, por ejemplo) con sólo unos pocos async salpicados:

from sanic import Sanic
from sanic.response import json

app = Sanic()

@app.route("/")
async def test(request):
 return json({"hola": "mundo"})

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

Sanic es posiblemente el framework asíncrono más popular y más querido en el mundo de Python. Tiene casi todas las características que querría para sus proyectos — enrutamiento, middleware, cookies, versionado, blueprints, vistas basadas en clases, archivos estáticos, streaming, sockets, etc. — y lo que no ofrece fuera de la caja — plantillas, soporte de bases de datos, E/S de archivos, colas — se puede añadir ya que hay suficientes bibliotecas async para estos a partir de hoy.

Vibora

Vibora es un primo cercano de Sanic, excepto que está obsesionado en convertirse en el servidor web Python más rápido que hay. De hecho, la primera visita de su página web le saluda con una comparación de frameworks:

Como puede ver, Vibora afirma ser varias veces más rápido que los frameworks clásicos y ser más del doble de rápido que Sanic, su competidor más cercano. Por supuesto, los benchmarks hay que tomarlos con pinzas 🙂

Aunque en sintaxis y características, Vibora es comparable a Sanic (o tal vez incluso un poco mejor, ya que incluye bibliotecas populares y cosas como plantillas están disponibles fuera de la caja), yo consideraría Sanic a ser más maduro, ya que ha sido de alrededor de más tiempo y tiene una comunidad más grande.

from vibora import Vibora, JsonResponse

app = Vibora()

@app.route('/')
async def home():
 return JsonResponse({'hola': 'mundo'})

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

Sin embargo, si usted es un adicto al rendimiento, Vibora podría hacer flotar su barco. Dicho esto, en el momento de escribir esto Vibora se está reescribiendo por completo para ser aún más rápido, y el enlace a su versión de rendimiento dice que está en “fuerte desarrollo” Va a ser una decepción para aquellos que cogieron Vibora antes y pronto deberán enfrentarse a cambios de ruptura, pero oye, es pronto en el mundo asíncrono de Python, y nadie espera que las cosas sean estables.

Quart

Si disfruta desarrollando en Flask pero lamenta la falta de soporte asíncrono, disfrutará mucho con Quart.

Quart cumple el estándar ASGI, sucesor del famoso estándar WSGI, y ofrece soporte asíncrono. Lo interesante de Quart es que no sólo es similar a Flask, ¡sino que de hecho es compatible con la API de Flask! El autor de este framework quiso preservar la sensación de Flask y sólo añadirle soporte async, WebSockets y HTTP 2. Como resultado, puede aprender Quart directamente de la documentación de Flask, sólo teniendo en cuenta que las funciones en Quart son asíncronas.

from quart import Quart

app = Quart(__name__)

@app.route('/')
async def hola():
 return 'hola'

app.run()

Parece (casi) exactamente igual que Flask, ¿verdad?

Dado que Quart es una evolución de Flask, todas las características dentro de Flask están disponibles: enrutamiento, middleware, sesiones, plantillas, blueprints, y así sucesivamente. De hecho, incluso puede utilizar las extensiones de Flask directamente dentro de Quart. Una pega es que Python 3.7 sólo es compatible, pero, entonces, si usted no está ejecutando la última versión de Python, tal vez async no es el camino correcto. 🙂

La documentación es realmente deficiente si no se tiene experiencia previa con Flask, pero puedo recomendar Quart ya que es probablemente el único framework async que se acerca pronto a su versión 1.0.

FastAPI

El último (pero más impresionante) framework de esta lista es FastAPI. No, no es un framework sólo de API; de hecho, FastAPI parece ser el framework más rico en características y documentación con el que me he topado al investigar los frameworks asíncronos de Python.

Es interesante observar que el autor del framework estudió en profundidad varios otros frameworks, desde los contemporáneos como Django a los modernos como Sanic, además de mirar a través de las tecnologías en NestJS (un framework web Node.js, Typescript). Su filosofía de desarrollo y amplias comparaciones pueden leerse aquí.

La sintaxis es bastante agradable; incluso se puede argumentar que es mucho más agradable que otros frameworks con los que nos hemos cruzado:

rom fastapi import FastAPI

app = FastAPI()

@app.get("/users/me")
async def read_user_me():
 return {"user_id": "el usuario actual"}

@app.get("/users/{user_id}")
async def read_user(user_id: str):
 return {"user_id": user_id}

Y ahora, la lista de características asesinas que hacen que FastAPI eclipse a otros frameworks:

Generación automática de documentos de API: En cuanto haya escrito sus puntos finales, podrá jugar con la API utilizando una interfaz de usuario conforme a los estándares. SwaggerUI, ReDoc, y otros son compatibles.

El marco también realiza la documentación automática del modelo de datos con JSON Schema.

Desarrollo moderno: Sí, la palabra “moderno” se lanza alrededor de mucho, pero he encontrado FastAPI realmente a caminar su charla. La inyección de dependencia y la sugerencia de tipos son ciudadanos de primera clase, reforzando no sólo los buenos principios de codificación, sino previniendo errores y confusiones a largo plazo.

Amplia documentación: No sé a usted, pero a mí me encanta la buena documentación. Y en esta área, FastAPI gana ampliamente. Tiene páginas y páginas de documentación que explican casi todas las pequeñas sutilezas y momentos de “¡cuidado!” para desarrolladores de todos los niveles. Percibo un claro “corazón y alma” en los docs aquí, y la única comparación que puedo encontrar son los docs de Django (¡sí, los docs de FastAPI son así de buenos!).

Más allá de lo básico: FastAPI tiene soporte para WebSockets, Streaming, así como GraphQL, además de tener todos los ayudantes tradicionales como CORS, sesiones, cookies, y así sucesivamente.

¿Y qué hay del rendimiento? Bueno, FastAPI está construido sobre la increíble librería Starlette, lo que resulta en un rendimiento que iguala a Node, y en algunos casos, ¡incluso a Go! En definitiva, tengo la sensación de que FastAPI va a imponerse como el mejor framework asíncrono para Python.

BlackSheep

BlackSheep se puede utilizar para crear aplicaciones del lado del servidor o full-stack con un patrón MVC.

Algunas de las características que ofrece BlackSheep son

• Una API de código enriquecido.
• Inyección de dependencias incorporada.
• Generación integrada de documentación OpenAPI.
• Vinculación automática de gestores de peticiones.

Configuración del proyecto

Vamos a crear una aplicación básica del lado del servidor con BlackSheep. Ejecute rápidamente los siguientes comandos uno a uno para configurar el proyecto.

python -m venv basic-app
cd basic-app
source bin/activate
pip install blacksheep uvicorn

Aprenda a instalar el instalador de paquetes PIP en CentOS, Ubuntu y Windows.

Hemos terminado de configurar el proyecto. Creemos un archivo llamado server.py y coloquemos el siguiente código.

from blacksheep import Aplicación

app = Aplicación()

@app.router.get("/")
def home():
 return "¡Hola, Mundo!"

Hemos creado nuestra aplicación de hola mundo más famosa. Por ahora sólo hay una ruta con método HTTP GET, y es /. La función home se llama request handler en BlackSheep.

Hemos utilizado un decorador de rutas de la aplicación. Hay otra manera de crear rutas es decir, ruta. Vamos a utilizar el enrutador en este tutorial. Puede encontrar más información sobre route en los docs.

Vamos a ejecutar la aplicación con el siguiente comando.

uvicorn server:app --port 8000 --reload

Vaya a http://localhost:8000/ en el navegador. Verá hola mundo en el navegador. Hablemos un poco del comando que hemos utilizado para ejecutar la aplicación.

• Hemos utilizado el paquete uvicorn para ejecutar nuestra aplicación.
• El servidor es el nombre de archivo que hemos dado. Si utiliza un nombre de archivo diferente, cámbielo también en el comando de inicio.
• La opción --port es dar el puerto en el que debe ejecutarse nuestra aplicación.
• Finalmente, la opción --reload es para recargar la aplicación en el navegador cada vez que hagamos cambios en el archivo del servidor.

Respuesta JSON

En el mundo real, necesitamos las respuestas de la API en JSON en la mayoría de los casos. Podemos devolver una respuesta JSON desde el método envolviendo el objeto JSON con json del paquete blacksheep. Veamos cómo podemos hacerlo.

from blacksheep import Aplicación, json

app = Aplicación()

@app.router.get("/")
def home():
 return json({"mensaje": "¡Hola, mundo!"})

Hemos importado json del blacksheep y envuelto el objeto JSON con él. Compruébelo en el navegador para ver la respuesta JSON.

Parámetros de ruta

Necesitamos aceptar los parámetros de ruta algunas veces para las peticiones. Podemos hacerlo en BlackSheep definiéndolos dentro del método HTTP. Veámoslo

@app.router.get("/{nombre}")
def home(nombre):
 return json({"saludos": f "¡Hola, {nombre}!"})

Estamos aceptando un parámetro de ruta llamado nombre. Vaya a http://localhost:8000/Geekflare. El método devolverá un saludo con el nombre dado en la ruta.

El decorador de la ruta pasará a la función de inicio el parámetro con el mismo nombre que se le haya dado al decorador. En este caso, será nombre. Si lo cambia en el decorador, cámbielo también en la función de inicio.

Podemos aceptar tantos parámetros de ruta como sea posible de forma similar. Veamos un ejemplo rápido.

@app.router.get("/{nombre}/{info}")
def home(nombre, info):
 return json({"saludos": f "¡Hola, {nombre}! Info {info}"})

Hemos aceptado un parámetro de ruta más llamado info. Vaya a http://localhost:8000/Geekflare/Chandan para comprobarlo.

Parámetros de consulta

No necesitamos hacer nada para aceptar los parámetros de consulta. BlackSheep enviará automáticamente los parámetros de consulta a la función en forma de lista. Veamos el ejemplo.

@app.router.get("/")
def home(nombre):
 print(nombre)
 return json({"saludos": f "¡Hola, {nombre[0]}!"})

Vaya a http://localhost:8000/?name=Geekflare para comprobar la respuesta. Si tiene varios parámetros de consulta con el mismo nombre, BlackSheep los añadirá todos a la lista.

Vaya a http://localhost:8000/?name=Geekflare&name=Chandan y compruebe la salida en el terminal. Verá una lista con Geekflare y Chadan ya que hemos pasado dos parámetros de consulta con el mismo nombre.

Si desea varios parámetros de consulta con diferentes, también puede hacerlo. Sólo tiene que añadir otro argumento a la función con el nombre del parámetro de consulta y hacer lo que quiera con él.

Objeto de petición

Lo único que nos queda en lo básico es comprobar otros métodos HTTP. Antes de entrar en ello, vamos a comprobar el objeto de petición de la API.

Todos los manejadores de peticiones en el BalckSheep tendrán un argumento de petición que contiene toda la información de la petición entrante. Incluye cabeceras de petición, parámetros de ruta, parámetros de consulta, datos, etc..,

Veamos un ejemplo para ver el objeto request.

@app.router.post("/")
def home(request):
 print(request)
 return "¡Hola, mundo!"

Puede ver la siguiente salida en el terminal.

<Solicitud POST /&gt

Podemos acceder a diferentes cosas desde la petición. Puede consultar la documentación al respecto. Aquí, nuestra atención se centra en el cuerpo de la solicitud. Veamos cómo acceder al cuerpo de la petición desde el objeto request.

@app.router.post("/")
async def home(request):
 data = await request.json()
 print(data)
 return "¡Hola, mundo!"

Hay un método llamado json en la petición, que devolverá los datos procedentes de la petición. Pase algunos datos en la solicitud de la API y llámelo. Verá cómo se imprimen en el terminal los datos que ha pasado a la API.

Métodos HTTP

Hemos visto los métodos GET y POST en los ejemplos anteriores. Del mismo modo, puede utilizar los métodos PUT, DELETE, etc., también. Probarlos no será un problema ya que son sencillos.

AIOHTTP

aiohttp es otro framework que viene con las siguientes características clave.

• Soporta WebSockets tanto del lado del servidor como del lado del cliente.
• Soporta el desarrollo de aplicaciones tanto de servidor como de cliente.
• Su servidor web dispone de middleware, señales y enrutamiento conectable.

Configuración del proyecto

Vamos a crear una aplicación básica del lado del servidor con aiohttp. Ejecute rápidamente los siguientes comandos para configurar el proyecto.

python -m venv basic-app
cd basic-app
source bin/activate
pip install aiohttp aiodns

Cree un archivo llamado server.py y coloque en él el siguiente código.

from aiohttp import web

async def home(request):
 return web.Response(text="¡Hola, mundo!")

app = web.Application()
app.add_routes([web.get('/', home)])

web.run_app(app)

La instancia web . Application es nuestra aplicación principal. Hemos añadido el método HTTP GET con la ruta / que devuelve nuestro favorito hola mundo. Para ejecutar la aplicación se utiliza la función web.run_app, que toma como argumento la instancia web. Application.

La función home se llama manejador de peticiones en aiohttp. Y tiene un único argumento llamado request, que contiene toda la información de la solicitud entrante.

Ejecute la aplicación con el siguiente comando. Es lo mismo que ejecutar programas python normales.

python3 servidor.py

Vaya a http://localhost:8080/ en el navegador. Verá hola mundo en el navegador.

Respuesta JSON

Podemos devolver la respuesta en formato JSON utilizando la función web.json_response. Pase los datos JSON a esa función mientras devuelve la respuesta. Veamos el ejemplo.

async def home(request):
 return web.json_response({"mensaje": "¡Hola, mundo!"})

Si entra en http://localhost:8080/ verá el objeto JSON en el navegador.

Parámetros de ruta

Podemos definir los parámetros de ruta mientras añadimos las rutas. Y se puede acceder a ellos desde el argumento request del manejador de peticiones. Veamos un ejemplo.

from aiohttp import web

async def home(request):
 return web.json_response({"message": f "¡Hola, {request.match_info['name']}!"})

app = web.Application()
app.add_routes([web.get('/{name}', home)])

web.run_app(app)

Se puede acceder a todos los parámetros de ruta desde el request.match_info como se muestra en el ejemplo anterior. Visite http://localhost:8080/Geekflare para comprobarlo.

También podemos tener regex para hacer coincidir las rutas. Digamos que tenemos que aceptar sólo /{any_number}. Podemos hacerlo sustituyendo el ‘ /{nombre}' por r'/{número:\d}'. Hemos añadido regex al parámetro path, que aceptará sólo si se pasa el regex.

Veamos un ejemplo

from aiohttp import web

async def home(request):
 return web.json_response({"message": f "¡Hola, {request.match_info['number']}!"})

app = web.Application()
app.add_routes([web.get(r'/{number:\d }', home)])

web.run_app(app)

Vaya a http://localhost:8080/Geekflare, obtendrá un error 404 ya que Geekflare no coincide con el patrón regex que hemos dado. Ahora, vaya a http://localhost:8080/1234567890 verá la respuesta en el navegador.

Parámetros de consulta

No es necesario añadir nada para aceptar parámetros de consulta. Podemos aceptar los parámetros de consulta del objeto request.query. Veamos un ejemplo.

from aiohttp import web

async def home(request):
 return web.json_response({"message": f "Hola, {request.query.get('name')}"})

app = web.Application()
app.add_routes([web.get('/', home)])

web.run_app(app)

Vaya a http://localhost:8080/?name=Geekflare y compruebe el resultado. Verá Geekflare en la respuesta a la que estamos accediendo desde el request.query.

También podemos pasar múltiples parámetros de consulta a los que se puede acceder con sus nombres clave.

Métodos HTTP

Hemos visto cómo crear un método HTTP GET en los ejemplos anteriores. Necesitamos saber cómo acceder a los datos de la petición antes de seguir adelante. Veamos un ejemplo de ello.

from aiohttp import web

async def home(request):
 data = await request.json()
 print(data)
 return web.json_response({"mensaje": f "¡Hola, mundo!"})

app = web.Application()
app.add_routes([web.post('/', home)])

web.run_app(app)

En el ejemplo anterior, hemos cambiado el método API de GET a POST. Hemos accedido a los datos de la solicitud utilizando el método request.json.

Realice una solicitud POST a http://localhost:8080/, verá los datos de la solicitud imprimiéndose en el terminal.

Del mismo modo, puede utilizar los métodos PUT, DELETE, etc., también. Pruébelos usted mismo y diviértase.

Puede seguir explorando más sobre el framework en sus docs.

Falcon

Falcon es un framework ASGI para construir APIs REST y microservicios. Tiene las siguientes características clave.

• Soporta WebSockets.
• Soporta middleware y hooks para el procesamiento de peticiones.
• Manejo de excepciones simple y directo.

Configuración del proyecto

Vamos a configurar un proyecto para aprender los fundamentos del framework falcon. Configure el proyecto con los siguientes comandos.

python -m venv basic-app
cd basic-app
source bin/activate
pip install falcon uvicorn

Cree un archivo llamado server.py y coloque el siguiente código.

from falcon import asgi
import falcon


class Home:
 async def on_get(self, request, response):
 response.status = falcon.HTTP_200 # Este es el estado por defecto
 response.content_type = falcon.MEDIA_TEXT # Por defecto es JSON, así que anula
 response.text = '¡Hola, Mundo!'

app = asgi.App()
app.add_route('/', Home())

Hemos creado una clase con el método on_get que es el método HTTP GET. El método tiene dos argumentos. Uno es la petición y otro la respuesta. Debería haber adivinado cuáles son por sus propios nombres.

El argumento request contiene toda la información de la petición entrante a la que se puede acceder para procesar la petición. Y el argumento respuesta se utiliza para enviar la respuesta estableciendo diferentes cosas.

A diferencia de BlackSheep y AIOHTTP no tenemos que devolver una respuesta. Podemos utilizar la respuesta y establecer cualquier detalle que necesitemos enviar como respuesta. En el ejemplo anterior, hemos establecido el estado a 200, el tipo de contenido a texto y el texto a hola mundo.

Ejecute la aplicación con el siguiente comando

uvicorn server:app --reload

Vaya a http://localhost:8000/, verá el hola mundo como respuesta.

Respuesta JSON

Podemos devolver la respuesta como JSON convirtiendo los datos en JSON utilizando el método json.dumps. Veamos un ejemplo

from falcon import asgi
import falcon
import json

class Home:
 async def on_get(self, request, response):
 response.text = json.dumps({"saludos": "¡Hola, Mundo!"})

app = asgi.App()
app.add_route('/', Home())

Vaya a http://localhost:8000/, verá la respuesta en JSON.

Parámetros de ruta

Los parámetros de petición se pasan a los métodos HTTP como argumentos. Puede ver el siguiente ejemplo para una mejor comprensión.

from falcon import asgi
import falcon
import json

class Home:
 async def on_get(self, request, response, name):
 response.text = json.dumps({"saludos": f "¡Hola, {nombre}!"})

app = asgi.App()
app.add_route('/{nombre}/', Home())

El parámetro de la ruta nombre se pasará al método on_get como argumento. Vaya a http://localhost:8000/Geekflare/ y compruebe la respuesta. Podemos tener tantos parámetros de ruta como queramos.

Parámetros de consulta

Podemos acceder a los parámetros de consulta utilizando el método request.get_param(param_name). Eche un vistazo al siguiente ejemplo.

from falcon import asgi
import falcon
import json

class Home:
 async def on_get(self, request, response):
 response.text = json.dumps({"saludos": f "¡Hola, {request.get_param('nombre')}!"})

app = asgi.App()
app.add_route('/', Home())

Vaya a http://localhost:8000/?name=Geekflare para comprobar la respuesta. Podemos tener tantos parámetros de consulta como queramos.

Métodos HTTP

Hemos visto el método GET en el ejemplo anterior. Lo único que necesitamos saber para otros métodos es cómo acceder a los datos de la petición. Podemos acceder a los datos de la petición utilizando el método request.stream.read. Veamos un ejemplo.

from falcon import asgi
import falcon
import json

class Home:
 async def on_get(self, request, response):
 response.text = json.dumps({"saludos": "¡Hola, Mundo!")

 async def on_post(self, request, response):
 data = await request.stream.read()
 print(json.loads(data))
 response.text = "¡Hola, Mundo!"

app = asgi.App()
app.add_route('/', Home())

Hemos añadido un método POST en el que accedemos a los datos de la petición y los imprimimos en el terminal tras convertirlos a JSON. Realice una petición POST con algunos datos para comprobar la salida.

Intente añadir otros métodos HTTP como DELETE, PUT, etc., por su cuenta. Hemos convertido sólo lo básico del framework Falcon. Pero, hay mucho en él. Vaya y lea la documentación para conocerlo más a fondo.

Starlette

Starlette es un framework ASGI ligero en Python. Tiene similares casi todas las características básicas para construir aplicaciones del lado del servidor.

Configure el proyecto con los siguientes comandos.

python -m venv basic-app
cd basic-app
source bin/activate
pip install starlette uvicorn

La creación de APIs con Starlette es similar a lo que hemos visto en los últimos frameworks. La sintaxis y la forma de crear APIs son diferentes. Todos los conceptos siguen siendo los mismos. Por lo tanto, vamos a incluir todas las cosas en un solo programa.

Cree un archivo llamado server.py y coloque el siguiente código.

from starlette.applications import Starlette
from starlette.responses import PlainTextResponse, JSONResponse
from starlette.routing import Route


def homepage(request):
 return PlainTextResponse('¡Hola, mundo!')

def json_response(request):
 return JSONResponse({'mensaje': '¡Hola, mundo!'})

def path_params(request):
 name = request.path_params['nombre']
 return JSONResponse({'saludos': f'¡Hola, {nombre}!'})

def query_params(request):
 name = request.query_params['nombre']
 return JSONResponse({'saludos': f'¡Hola, {nombre}!'})

async def post_method(request):
 data = await request.json()
 print(data)
 return JSONResponse({'mensaje': f'¡Hola, Mundo!'})

def starlette():
   print('Starlette iniciada')

routes = [
 Route('/', homepage),
 Route('/json', json_response),
 Route('/ruta-parámetros/{nombre}', ruta_parámetros),
   Route('/query-params', query_params),
 Route('/post', post_method, methods=['POST']),
]

app = Starlette(debug=True, routes=routes, on_startup=[startup])

Ejecute la aplicación con el siguiente comando

uvicorn server:app --reload

Pruebe todo lo que hemos visto en los frameworks anteriores. Puede obtener más información sobre el framework Starlette en su documentación.

Conclusión

Mucho está pasando en el paisaje async Python en estos días. Están apareciendo nuevos frameworks, se están reescribiendo los antiguos y las librerías están evolucionando para adaptarse al comportamiento asíncrono. Aunque Python tiene soporte incorporado para un bucle de eventos, y es posible hacer que partes de su aplicación sean asíncronas, puede optar por ir a por todas y construir sobre uno de los frameworks aquí expuestos.

Sólo asegúrese de tener en cuenta el largo plazo: varios de los frameworks asíncronos de Python que existen se encuentran en sus primeras etapas y están evolucionando rápidamente, lo que va a perjudicar su proceso de desarrollo y elevar los costes empresariales.

¡La precaución es la clave!

Pero todo sea dicho; Python está listo para la producción para ofrecer un rendimiento a la luz cuando se trata de frameworks web. Si durante tanto tiempo ha estado pensando en migrar a Node, ¡ahora ya no es necesario! 🙂

¿Le parece genial? ¡ Domine Python hoy mismo!