Geekflare cuenta con el apoyo de nuestra audiencia. Podemos ganar comisiones de afiliados comprando enlaces en este sitio.
Comparte en:

Los 9 mejores marcos web asincrónicos para Python

frameworks web python
Escáner de seguridad de aplicaciones web Invicti – la única solución que ofrece verificación automática de vulnerabilidades con Proof-Based Scanning™.

La programación asincrónica es ahora un ciudadano de primera clase en Python. Si eres un desarrollador web, hay increíbles marcos ¡puedes elegir!

Al momento de escribir, asincrónico ya no es solo una palabra de moda en la comunidad de Python. Con el lanzamiento de su asíncio biblioteca 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.

Esta fue una iniciativa de muy gran cosa porque el lenguaje Python es extremadamente cauteloso a la hora de expandir la sintaxis central a menos que haya una necesidad urgente, lo que solo indica cuán fundamentalmente importantes los desarrolladores de Python consideraron las capacidades asincrónicas.

Como resultado, se abrieron las compuertas de la programación asincrónica: las bibliotecas nuevas y antiguas comenzaron a utilizar la función de rutinas, los marcos asincrónicos explotaron en popularidad y todavía se están escribiendo nuevos en la actualidad.

El rendimiento a la par o mejor que el de Node.js no es inaudito y, a menos que sus patrones de carga impliquen muchas tareas de uso intensivo de la CPU, no hay ninguna razón por la que no pueda realizar unos miles de solicitudes por segundo.

¡Pero suficiente motivación!

Examinemos el panorama actual de Python y echemos un vistazo a algunos de los principales marcos asincrónicos.

Tornado

Asombrosamente, Tornado no es un marco 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 asincrónicos, que también se utilizan para construir el módulo de marco web. Más específicamente, estos módulos son:

  • Corutinas y otras primitivas (tornado.gen, tornado.locks, tornado.queues, Etc.)
  • Módulos de redes (tornado.ioloop, tornado.iostream, Etc.)
  • Servidores y clientes asincrónicos (tornado.httpserver, tornado.httpclient, Etc.)

Estos se han combinado para producir los módulos marco finales: 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 tiene seguidores fuertes y comprometidos en la comunidad de Python y es utilizado por arquitectos experimentados para construir sistemas altamente capaces. Es un marco que durante mucho tiempo ha tenido la respuesta a los problemas de concurrencia, pero tal vez no se convirtió en la corriente principal ya que no es compatible con el estándar WSGI y fue demasiado aceptado (recuerde que la mayor parte de las bibliotecas de Python todavía son síncronas ).

Sanic

Sanic es un marco "moderno" en el verdadero sentido de la palabra: no es compatible con la versión de Python por debajo de 3.6, admite la sintaxis simple y universal async / await lista para usar y, como resultado, no te obliga a leer cargas de documentación y tenga en cuenta los casos extremos antes de poder escribir su primer controlador HTTP.

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

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 es posiblemente el marco asincrónico más popular y querido en el mundo de Python. Tiene casi todas las características que desearía para sus proyectos (enrutamiento, middleware, cookies, control de versiones, planos, vistas basadas en clases, archivos estáticos, transmisión, sockets, etc.) y lo que no ofrece de inmediato. - plantillas, soporte de bases de datos, E / S de archivos, colas - se pueden agregar ya que hay suficientes bibliotecas asincrónicas para estos a partir de hoy.

Vibora

Víbora es un primo cercano de Sanic, excepto que está obsesionado con convertirse en el servidor web Python más rápido que existe. De hecho, la primera visita a su sitio web lo recibe con una comparación de marcos:

Como puede ver, Vibora afirma ser varias veces más rápido que los frameworks clásicos y más del doble de rápido que Sanic, su competidor más cercano. Por supuesto, los puntos de referencia deben tomarse con cautela. 🙂

Aunque en sintaxis y características, Vibora es comparable a Sanic (o tal vez incluso un poco mejor ya que agrupa bibliotecas populares y cosas como plantillas están disponibles de fábrica), consideraría que Sanic es más maduro ya que ha existido por más tiempo y ha una comunidad más grande.

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)

Sin embargo, si eres un adicto al rendimiento, Vibora podría hacer flotar tu bote. Dicho esto, al momento de escribir, Vibora está experimentando una reescritura completa para volverse aún más rápido, y el aquí a su versión de rendimiento dice que está en "gran desarrollo". Será una decepción para aquellos que adquirieron Vibora antes y pronto deberán enfrentar cambios importantes, pero bueno, son los primeros días 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 asincrónico, disfrutará Cuarto de galón .

Quart cumple con la ASGIA estándar, que es un sucesor del famoso estándar WSGI y ofrece soporte asíncrono. Lo interesante de Quart es que no solo es similar a Flask, ¡sino que también cumple con la API de Flask! El autor de este marco quería preservar la sensación de Flask y simplemente agregarle soporte asíncrono, WebSockets y HTTP 2. Como resultado, puede aprender Quart directamente de la documentación de Flask, solo teniendo en cuenta que las funciones en Quart son asincrónicas.

from quart import Quart

app = Quart(__name__)

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

app.run()

Se siente (casi) exactamente como Flask, ¿no?

Dado que Quart es una evolución de Flask, todas las funciones dentro de Flask están disponibles: enrutamiento, middleware, sesiones, plantillas, planos, etc. De hecho, incluso puede usar extensiones de matraces directamente dentro de Quart. Un problema es que Python 3.7+ solo es compatible, pero, entonces, si no está ejecutando la última versión de Python, tal vez async no sea la ruta correcta. 🙂

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

FastAPI

El último marco (pero más impresionante) de esta lista es FastAPI. No, no es un marco solo de API; De hecho, FastAPI parece ser el marco de trabajo más rico en funciones y documentación que encontré al investigar marcos de Python asíncronos.

Es interesante notar que el autor del framework estudió en profundidad varios otros frameworks, desde los contemporáneos como Django hasta los modernos como Sanic, además de analizar las tecnologías en NestJS (un framework web Node.js, Typescript). Se puede leer su filosofía de desarrollo y amplias comparaciones. aquí.

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

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}

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

Generación automática de documentos API: Tan pronto como se hayan escrito sus puntos finales, puede jugar con la API utilizando una interfaz de usuario compatible con los estándares. Se admiten SwaggerUI, ReDoc y otros.

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

Desarrollo moderno: Sí, la palabra “moderno” se usa mucho, pero encontré que FastAPI realmente es lo que dice. La inyección de dependencia y la sugerencia de tipo son ciudadanos de primera clase, que imponen no solo buenos principios de codificación, sino que también evitan errores y confusiones a largo plazo.

Amplia documentación: No sé ustedes, pero soy un fanático total de la buena documentación. Y en esta área, FastAPI gana sin lugar a dudas. Tiene páginas y páginas de documentos que explican casi todas las sutilezas y "¡cuidado!" momentos para desarrolladores de todos los niveles. Siento un claro "corazón y alma" en los documentos aquí, y la única comparación que puedo encontrar son los documentos de Django (sí, ¡los documentos FastAPI son tan buenos!).

Mas 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, etc.

¿Y la actuación? Bueno, FastAPI se basa en la increíble biblioteca Starlette, lo que da como resultado un rendimiento que coincide con Node y, en algunos casos, incluso con Go! Con todo, realmente tengo la sensación de que FastAPI va a competir como el mejor marco asíncrono para Python.

BlackSheep

Oveja Negra se puede usar para crear aplicaciones del lado del servidor o de pila completa con un patrón MVC.

Algunas de las características que ofrece BlackSheep son

  • Una API de código enriquecido.
  • Inyección de dependencia incorporada.
  • Generación incorporada de documentación OpenAPI.
  • Enlace automático de controladores de solicitudes.

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 por uno para configurar el proyecto.

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

Aprender como instalar PIP instalador de paquetes en CentOS, Ubuntu y Windows.

Hemos terminado con la configuración del proyecto. Vamos a crear un archivo llamado server.py y coloque el siguiente código.

from blacksheep import Application

app = Application()

@app.router.get("/")
def home():
    return "Hello, World!"

Hemos creado nuestra aplicación hello world más famosa. Solo hay una ruta con HTTP GET método por ahora, y es /. La función home se llama controlador de solicitudes en BlackSheep.

hemos usado un router decorador de la aplicación. Hay otra forma de crear rutas, es decir, ruta. estaremos usando el router en este tutorial. Puedes encontrar más sobre route en el capítulo respecto a la documentos.

Ejecutemos la aplicación con el siguiente comando.

uvicorn server:app --port 8000 --reload

Visite la http://localhost:8000/ en el navegador. Verás hola mundo en el navegador. Hablemos un poco sobre el comando que usamos para ejecutar la aplicación.

  • Hemos usado uvicorn paquete para ejecutar nuestra aplicación.
  • La server es el nombre del archivo que le hemos dado. Si usa 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 --reload opción es volver a cargar la aplicación en el navegador cada vez que hacemos cambios en el server archivo.

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 del método envolviendo el objeto JSON con json del desplegable blacksheep paquete. Veamos cómo podemos hacerlo.

from blacksheep import Application, json

app = Application()

@app.router.get("/")
def home():
    return json({"message": "Hello, World!"})

hemos importado json del desplegable blacksheep y envolvió el objeto JSON con él. Verifíquelo en el navegador para obtener una respuesta JSON.

Parámetros de ruta

Necesitamos aceptar los parámetros de ruta a veces para las solicitudes. Podemos hacerlo en BlackSheep definiéndolos dentro del método HTTP. Vamos a verlo.

@app.router.get("/{name}")
def home(name):
    return json({"greetings": f"Hello, {name}!"})

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

El decorador del enrutador pasará el parámetro con el mismo nombre al home función como se le da al decorador. Aquí, será name. Si lo cambias en el decorador, cámbialo en el home funcionar también

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

@app.router.get("/{name}/{info}")
def home(name, info):
    return json({"greetings": f"Hello, {name}! 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(name):
    print(name)
    return json({"greetings": f"Hello, {name[0]}!"})

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

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

Si desea múltiples parámetros de consulta con diferentes, también puede hacerlo. Simplemente agregue otro argumento a la función con el nombre del parámetro de consulta y haga lo que quiera con él.

Solicitar objeto

Lo único que queda en nuestros conceptos básicos es verificar otros métodos HTTP. Antes de entrar en él, vamos a comprobar el request objeto para la API.

Todos los controladores de solicitudes en BalckSheep tendrán un argumento de solicitud que contiene toda la información de la próxima solicitud. Incluye encabezados de solicitud, parámetros de ruta, parámetros de consulta, datos, etc.,

Veamos un ejemplo para ver el objeto de solicitud.

@app.router.post("/")
def home(request):
    print(request)
    return "Hello, World!"

Puede ver el siguiente resultado en la terminal.

<Request POST />

Podemos acceder a diferentes cosas desde la solicitud. Puede consultar los documentos para ello. Aquí, nuestro enfoque está en el cuerpo de la solicitud. Veamos cómo acceder al cuerpo de la solicitud desde el objeto de la solicitud.

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

Hay un método llamado json en la solicitud, que devolverá los datos que provienen de la solicitud. Pase algunos datos en la solicitud de API y llámelo. Verás la impresión de datos en la terminal que le has pasado a la API.

Métodos HTTP

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

AIOHTTP

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

  • Admite WebSockets tanto del lado del servidor como del lado del cliente.
  • Es compatible con el desarrollo de aplicaciones de servidor y cliente.
  • Su servidor web tiene 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

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

from aiohttp import web

async def home(request):
    return web.Response(text="Hello, World!")

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

web.run_app(app)

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

La función home se denomina controlador de solicitudes en aiohttp. Y tiene un único argumento llamado solicitud, 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 server.py

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

Respuesta JSON

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

async def home(request):
    return web.json_response({"message": "Hello, World!"})

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

Parámetros de ruta

Podemos definir los parámetros de la ruta mientras agregamos las rutas. Y se puede acceder a ellos desde el request argumento del controlador de solicitudes. Veamos un ejemplo.

from aiohttp import web

async def home(request):
    return web.json_response({"message": f"Hello, {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 la ruta desde el request.match_info como se muestra en el ejemplo anterior. Ir http://localhost:8080/Geekflare para comprobarlo.

También podemos tener expresiones regulares para que coincidan con las rutas. Digamos que tenemos que aceptar solo /{any_number}. Podemos hacerlo reemplazando el '/{name}' a r'/{number:\d+}'. Hemos agregado expresiones regulares al parámetro de ruta, que aceptará solo si se pasa la expresión regular.

Veamos un ejemplo

from aiohttp import web

async def home(request):
    return web.json_response({"message": f"Hello, {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 como Geekflare no coincide con el patrón de expresiones regulares que hemos dado. Ahora, ve a http://localhost:8080/1234567890 verá la respuesta en el navegador.

Parámetros de consulta

No es necesario agregar nada para aceptar los parámetros de consulta. Podemos aceptar los parámetros de consulta de la request.query objeto. Veamos un ejemplo.

from aiohttp import web

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

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

web.run_app(app)

Ve a http://localhost:8080/?name=Geekflare y comprobar el resultado. Ya verás 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 solicitud antes de continuar. Veamos un ejemplo de ello.

from aiohttp import web

async def home(request):
    data = await request.json()
    print(data)
    return web.json_response({"message": f"Hello, World!"})

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 mediante request.json método.

Haz una solicitud de publicación a http://localhost:8080/, verá la impresión de datos de la solicitud en la terminal.

Del mismo modo, también puede utilizar los métodos PUT, DELETE, etc. Pruébalos tú mismo y diviértete.

Puede continuar explorando más sobre el marco en su documentos.

Falcon

halcón es un marco ASGI para crear API REST y microservicios. Tiene las siguientes características clave.

  • Es compatible con WebSockets.
  • Admite middleware y enlaces para el procesamiento de solicitudes.
  • Manejo de excepciones simple y directo.

Configuración del proyecto

Configuremos un proyecto para aprender los conceptos básicos del marco falcon. Configure el proyecto con los siguientes comandos.

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

Crea 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  # This is the default status
        response.content_type = falcon.MEDIA_TEXT  # Default is JSON, so override
        response.text = 'Hello, World!'

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

Hemos creado una clase con on_get método que es el método HTTP GET. El método tiene dos argumentos. Uno es request y otro si response. Deberías haber adivinado cuáles son por sus propios nombres.

La request El argumento contiene toda la información de la solicitud entrante a la que se puede acceder para procesar la solicitud. Y el response El argumento se usa para enviar la respuesta configurando diferentes cosas.

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

Ejecute la aplicación con el siguiente comando

uvicorn server:app --reload

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

Respuesta JSON

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

from falcon import asgi
import falcon
import json

class Home:
    async def on_get(self, request, response):
        response.text = json.dumps({"greetings": "Hello, World!"})

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

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

Parámetros de ruta

Los parámetros de la solicitud se pasan a los métodos HTTP como argumentos. Puedes 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({"greetings": f"Hello, {name}!"})

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

La name el parámetro de ruta se pasará a on_get método como argumento. Ir http://localhost:8000/Geekflare/ y comprobar la respuesta. Podemos tener tantos parámetros de ruta como queramos.

Parámetros de consulta

Podemos acceder a los parámetros de consulta usando request.get_param(param_name) método. Mira el ejemplo a continuación.

from falcon import asgi
import falcon
import json

class Home:
    async def on_get(self, request, response):
        response.text = json.dumps({"greetings": f"Hello, {request.get_param('name')}!"})

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

Ve 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 solicitud. Podemos acceder a los datos de la solicitud usando request.stream.read método. Veamos un ejemplo.

from falcon import asgi
import falcon
import json

class Home:
    async def on_get(self, request, response):
        response.text = json.dumps({"greetings": "Hello, World!"})

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

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

Agregamos un método POST en el que accedimos a los datos de la solicitud y los imprimimos en el terminal después de convertirlos a JSON. Realice una solicitud POST con algunos datos para verificar la salida.

Intente agregar otros métodos HTTP como DELETE, PUT, etc., usted mismo. Hemos convertido solo los conceptos básicos del marco de falcon. Pero, hay mucho en ello. Ve y lee el documentos para conocer más profundamente al respecto.

Starlette

Estrella joven es un marco ASGI ligero en Python. Tiene casi todas las características básicas similares para crear 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

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

Crea 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('Hello, World!')

def json_response(request):
    return JSONResponse({'message': 'Hello, World!'})

def path_params(request):
    name = request.path_params['name']
    return JSONResponse({'greetings': f'Hello, {name}!'})

def query_params(request):
    name = request.query_params['name']
    return JSONResponse({'greetings': f'Hello, {name}!'})

async def post_method(request):
    data = await request.json()
    print(data)
    return JSONResponse({'message': f'Hello, World!'})

def startup():
    print('Starlette started')

routes = [
    Route('/', homepage),
    Route('/json', json_response),
    Route('/path-params/{name}', path_params),
    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 todas las cosas que hemos visto en los marcos anteriores. Puede obtener más información sobre el marco Starlette en su documentos.

Conclusión

Están sucediendo muchas cosas en el panorama asíncrono de Python en estos días. Nuevo marcos están apareciendo, los antiguos se están reescribiendo y las bibliotecas se están desarrollando para que coincidan con el comportamiento asíncrono. Si bien 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 con todo y construir sobre uno de los marcos aquí.

Solo asegúrese de tener en cuenta el largo plazo: varios de los marcos asíncronos de Python que existen se encuentran en las primeras etapas y están evolucionando rápidamente, lo que perjudicará su proceso de desarrollo y aumentará los costos comerciales.

¡La precaución es clave!

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

¿Suena bien? Domina Python hoy!

Gracias a nuestros patrocinadores
Más lecturas interesantes sobre el desarrollo
Impulse su negocio
Algunas de las herramientas y servicios para ayudar a que su negocio crezca.
  • Invicti utiliza Proof-Based Scanning™ para verificar automáticamente las vulnerabilidades identificadas y generar resultados procesables en cuestión de horas.
    Prueba Invicti
  • Web scraping, proxy residencial, administrador de proxy, desbloqueador web, rastreador de motores de búsqueda y todo lo que necesita para recopilar datos web.
    Prueba Brightdata
  • Semrush es una solución de marketing digital todo en uno con más de 50 herramientas en SEO, redes sociales y marketing de contenido.
    Prueba Semrush
  • Intruder es un escáner de vulnerabilidades en línea que encuentra debilidades de ciberseguridad en su infraestructura, para evitar costosas filtraciones de datos.
    Intente Intruder