Shulou(Shulou.com)06/01 Report--

This article mainly introduces what asynchronous Python framework has, has a certain reference value, interested friends can refer to, I hope you have a lot of gains after reading this article, let Xiaobian take you to understand.

Tornado Tornado is not a new framework at all, it was originally released by FriendFeed (later acquired by Facebook) in 2009. Asynchronous programming functionality has been provided from the beginning.

Tornado is not only a Web framework, but it also has a lot of asynchronous modules built in, which can be used to build asynchronous applications. These modules include: coroutines and other primitives (tornado.gen, tornado.locks, tornado.queues, etc.) network modules (tornado.ioloop, tornado.iostream) asynchronous servers and clients (tornado.httpserver, httpclient, etc.)

From these modules, Tornado builds its own asynchronous Web framework modules. 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 has a large following in the Python community, and experienced architects use them to build powerful systems. This framework has long addressed concurrency issues, but since it doesn't support the WSGI standard (most Python libraries are still in sync) it hasn't gone mainstream. It is said that the domestic knowledge is based on Torando. SnaicSanic is a three-year-old framework: it only supports Python versions above 3.6, supports the common async / await syntax, and works out of the box, so you can write your HTTP processor without reading a lot of documentation. Syntactically, there is no difference from flask except for the async keyword. 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 ="0.0.0.0", port=8000)Sanic is arguably the most popular and popular asynchronous framework in the Python world. It has all the features you need in your project: routing, middleware, cookies, version control, blueprints, class-based views, static files, streams, sockets, in addition you can integrate templates, database drivers, file I / O, queues, etc. Vibora Vibora and Sanic are very similar and aim to be the fastest Python Web server. The front page of their website has a frame comparison chart:

Vibora claims to be several times faster than other frameworks and more than twice as fast as competitor Sanic. Of course, this benchmark should be viewed skeptically. Although Vibora is comparable to Sanic in syntax and functionality, I think Sanic is more mature because it has been around for a long time and has a larger community. from vibora import Vibora, JsonResponse

app = Vibora()

@app.route('/')

async def home():

return JsonResponse({'hello': 'world'})

if __name__ == '__main__':

app.run ="0.0.0.0", port=8000)4, Quart If you like Flask, but also support asynchronous, then Quart you will love

Quart complies with ASGI standards, which are the successor to WSGI standards and provide asynchronous support. Quart is not only similar to Flask, but also compatible with Flask API! The authors of the framework wanted to keep the Flask style and just add asynchronous, WebSocket, and HTTP2 support to it. Therefore, you can learn Quart usage from Flask documentation, just remember that functions in Quart are asynchronous. from quart import Quart

app = Quart(__name__)

@app.route('/')

async def hello():

return 'hello'

app.run () Almost exactly like Flask Since Quart evolved from Flask, all Flask features are available: routing, middleware, sessions, templates, blueprints, etc. In fact, you can even use Flask extensions directly inside Quart. However, one problem is that it only supports Python 3.7+. FastAPIFastAPI seems to be the most feature-rich and document-rich framework among asynchronous Python frameworks. The authors of this framework delved into several other frameworks, from modern frameworks such as Django to Sanic, as well as NestJS (Node.js, Typescript Web Framework). Grammar can even say that it is more interesting than other frameworks we encounter: 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}FastAPI trumps other frameworks by automatically generating API documentation: After writing the API interface, you can use standard UI such as SwaggerUI, ReDoc, etc. to use the API.

What about performance? FastAPI is built on the Starlette library and its performance matches Node and in some cases even Go. All in all, I really have a feeling FastAPI is going to be Python's top asynchronous framework. Thank you for reading this article carefully. I hope that the article "What are the asynchronous Python frameworks" shared by Xiaobian will be helpful to everyone. At the same time, I hope that everyone will support you a lot and pay attention to the industry information channel. More relevant knowledge is waiting for you to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.