Топ 5 асинхронни уеб рамки за Python

Асинхронното програмиране е първокласен гражданин в Python. Ако сте уеб програмист, можете да избирате невероятни рамки!


Що се отнася до писането, асинхронната вече не е просто модна дума в общността Python. С пускането на неговото asyncio библиотека във версия 3.5, Python призна влиянието на Node.js върху уеб разработката и въведе две нови ключови думи в езика – async и чакат. Това беше много голяма работа, защото езикът на Python е изключително предпазлив от разширяването на основния синтаксис, освен ако няма належаща нужда, което показва само колко фундаментално важно е разработчиците на Python да са считали за асинхронните възможности.

В резултат на това бяха отворени фасове на асинхронно програмиране: нови и стари библиотеки започнаха да използват функцията coroutines, асинхронните рамки избухнаха по популярност, а нови се пишат и до днес. Производителността, равна на или по-добра от тази на Node.js, не се чува и освен ако моделите ви за зареждане не включват множество задачи, затруднени с процесор, няма причина да не можете да отправите няколко хиляди заявки в секунда.

Но достатъчно мотивация!

Нека разгледаме текущия пейзаж на Python и да разгледаме някои от най-горните асинхронни рамки.

торнадо

учудващо, торнадо изобщо не е нова рамка Първоначалното му издание е през 2009 г. (точно преди десет години, както пише) и оттогава фокусът му е насочен към осигуряване на стабилно асинхронно програмиране с висока съвместимост.

Торнадо не е основна уеб рамка. Това е колекция от асинхронни модули, които също се използват за изграждане на уеб рамков модул. По-конкретно тези модули са:

  • Coroutines и други примитиви (tornado.gen, tornado.locks, tornado.queues и др.)
  • Мрежови модули (tornado.ioloop, tornado.iostream и др.)
  • Асинхронни сървъри и клиенти (tornado.httpserver, tornado.httpclient и т.н.)

Те са комбинирани за получаване на крайните рамкови модули: tornado.web, tornado.routing, tornado.template и т.н..

внос tornado.ioloop
import tornado.web

клас MainHandler (tornado.web.RequestHandler):
дефиниране (самостоятелно):
self.write ("Здравей свят")

дефинирай make_app ():
връщане tornado.web.Application ([
(R"/", MainHandler),
])

ако __name__ == "__main__":
app = make_app ()
app.listen (8888)
tornado.ioloop.IOLoop.current (). започнете ()

Tornado има силни и ангажирани последователи в общността Python и се използва от опитни архитекти за изграждане на високо способни системи. Това е рамка, която отдавна има отговор на проблемите на едновременността, но може би не се превърна в мейнстрийм, тъй като не поддържа стандарта WSGI и беше прекалено голяма стойност (не забравяйте, че по-голямата част от библиотеките на Python все още са синхронни ).

Sanic

Sanic е „модерна“ рамка в истинския смисъл на думата: тя не поддържа Python версия под 3.6, поддържа простия и универсален асинхрон / чака синтаксис извън кутията и в резултат на това не ви кара да четете товари на документацията и пазете крайните случаи в съзнанието си, преди да можете да напишете първия си HTTP обработвач.

В резултат на това полученият синтаксис е доста приятен (според мен поне); прилича на код, който бихте написали с всяка друга микрокадра (Flask, CherryPy, например) само с няколко асинхронизации, поръсени в:

от внос
от sanic.response import json

ап = Саник ()

@ App.route ("/")
async def test (заявка):
връщане json ({"Здравейте": "свят"})

ако __name__ == "__main__":
app.run (хост ="0.0.0.0", порт = 8,000)

Sanic е може би най-популярната и обичана асинхронна рамка в света на Python. Той има почти всички функции, които бихте искали за вашите проекти – маршрутизация, междинен софтуер, бисквитки, версия, чертежи, класови изгледи, статични файлове, стрийминг, сокети и т.н. – и това, което не предлага извън кутията – шаблониране, поддръжка на база данни, входно / изходни файлове, опашки – могат да се добавят, тъй като към днешна дата има достатъчно асинхронни библиотеки.

Vibora

Vibora е близък братовчед на Саник, само че е фиксиран да стане най-бързият Python уеб сървър там. Всъщност, първото посещение на неговия уебсайт Ви посреща с рамково сравнение:

Както можете да видите, Vibora твърди, че е няколко пъти по-бърза от класическите рамки и е повече от два пъти по-бърза от Sanic, най-близкия й конкурент. Разбира се, ориентирите трябва да се вземат със зърно сол. ��

Въпреки че по синтаксис и функции Vibora е сравнима с Sanic (или може би дори малко по-добра, тъй като тя групира популярни библиотеки и неща като шаблони са налични извън кутията), бих считал, че Sanic е по-зрял, тъй като е по-дълъг и има по-голяма общност.

от vibora import Vibora, JsonResponse

ап = Vibora ()

@ App.route ( “/”)
async def home ():
върнете JsonResponse ({‘здравей’: ‘свят’})

ако __name__ == ‘__main__’:
app.run (хост ="0.0.0.0", порт = 8,000)

Ако обаче сте наркоман за изпълнение, Vibora може да плава с лодката ви. Това каза, че при писането Vibora се подлага на цялостно пренаписване, за да стане още по-бързо, и връзка във версията си за изпълнение се казва, че е под „тежко развитие“. Това ще бъде пропуснато за тези, които са взели Vibora по-рано и скоро трябва да се сблъскат с нарушаването на промените, но ей, това са ранни дни в света на асинхронизация на Python и никой не очаква нещата да са стабилни.

кварта

Ако се радвате да се развивате във Flask, но отхвърляте липсата на поддръжка за async, ще се радвате кварта много.

Кварта е съвместим с ASGI стандарт, който е наследник на известния стандарт WSGI и предлага асинхронна поддръжка. Интересното при Quart е, че той не е само подобен на Flask, но всъщност е съвместим с Flask API! Авторът на тази рамка иска да запази усещането на Flask и просто да добави към него поддръжка за async, WebSockets и HTTP 2. В резултат на това можете да научите Quart направо от документацията на колбата, като имате предвид, че функциите в Quart са асинхронни.

от внос на квар. Кварт

app = Квартал (__ име__)

@ App.route ( “/”)
async def hello ():
връщане “здравей”

app.run ()

Чувства се (почти) точно като Flask, нали??!

Тъй като Quart е еволюция на Flask, всички функции в Flask са достъпни: маршрутизация, междинен софтуер, сесии, шаблони, чертежи и т.н. Всъщност можете дори да използвате разширения Flask директно в Quart. Една от уловките е, че Python 3.7+ се поддържа само, но тогава, ако не използвате най-новата версия на Python, може би async не е правилният път. ��

Документацията наистина иска, ако нямате по-ранен опит с Flask, но мога да препоръчам Quart, тъй като това е може би единствената асинхронна рамка, която наближава скорошното издание на 1.0.

FastAPI

Последната (но най-впечатляващата) рамка в този списък е FastAPI. Не, това не е само за API; всъщност FastAPI изглежда е най-богатата на функции и богата на документация рамка, на която попаднах при изследване на асинхронните Python рамки.

Интересно е да се отбележи, че авторът на рамката проучи няколко други рамки задълбочено – от съвременните като Django до модерни като Sanic, както и разгледа технологиите в NestJS (уеб рамка на Node.js, Typescript). Философията им за развитие и широките сравнения могат да бъдат прочетени тук.

Синтаксисът е доста приятен; човек може дори да твърди, че е много по-приятно от другите рамки, на които се натъкваме:

rom fastapi import FastAPI

ап = FastAPI ()

@ App.get ("/ потребители / мен")
async def read_user_me ():
връщане {"user_id": "текущия потребител"}

@ App.get ("/ потребители / {USER_ID}")
async def read_user (user_id: str):
връщане {"user_id": user_id}

И сега, списъкът на функциите на убиеца, които правят FastAPI да затъмнява други рамки:

Автоматично генериране на doc API: Веднага щом вашите крайни точки са написани, можете да играете с API с помощта на стандартен потребителски интерфейс. Поддържат се SwaggerUI, ReDoc и други.

Рамката също прави автоматична документация за модел на данни с JSON Schema.

Съвременно развитие: Да, думата „съвременен“ се хвърля много, но открих FastAPI всъщност да ѝ говори. Инжектиране на зависимостта и подсказване на тип са първокласни граждани, прилагащи не само добри принципи на кодиране, но предотвратяващи грешки и объркване в дългосрочен план.

Обширна документация: Не знам за вас, но аз съм пълна гадост за добра документация. И в тази област FastAPI печели с ръце надолу. Той има страници на страници от документи, обясняващи почти всяка малка тънкост и „внимавайте!“ моменти за разработчици от всички нива. Чувствам ясно „сърце и душа” в документите тук, и единственото сравнение, което мога да намеря, са Django документите (да, FastAPI документите са толкова добри!).

Отвъд основните: FastAPI има поддръжка за WebSockets, Streaming, както и GraphQL, освен че има всички традиционни помощници като CORS, сесии, бисквитки и т.н..

А какво ще кажете за представянето? Е, FastAPI е изграден върху невероятната библиотека Starlette, което води до производителност, която съответства на Node, а в някои случаи дори Go! Като цяло, наистина имам чувството, че FastAPI ще се състезава напред като най-добрата асинхронна рамка за Python.

заключение

Днес в пейзажа на Python async се случва много. Появяват се нови рамки, пренаписват се стари и се развиват библиотеки, за да съответстват на асинхронното поведение. Докато Python има вградена поддръжка за цикъл на събитията и е възможно части от приложението ви да се асинхронизират, можете да изберете да включите all-in и да надградите някоя от рамките тук. Само не забравяйте да имате предвид в дългосрочен план: няколко от асинхронните рамки на Python там са в начален стадий и бързо се развиват, което ще навреди на процеса ви на развитие и ще увеличи бизнес разходите. Вниманието е от ключово значение!

Но всичко казано и направено; Python е готов за производство, за да осигури светлинно изпълнение, когато става въпрос за уеб рамки. Ако толкова дълго време сте мислили да мигрирате към Node, сега няма нужда! ��

Звучи яко? Мастър Пайтън днес!

ЕТИКЕТИ:

  • Питон

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