A legnépszerűbb Python webes keretek 2021-ben

a webes keretek hatékony eszközök. Elvonják a weboldalak és API-k készítésének közös aspektusait, és lehetővé teszik, hogy gazdagabb, stabilabb alkalmazásokat építsünk kevesebb erőfeszítéssel.

a webes keretrendszerek széles skálája áll rendelkezésünkre Pythonban. Néhány bizonyított kedvenc a nagy ökoszisztémákkal és közösségekkel. Mások kiemelkednek a niche felhasználási esetekben vagy bizonyos típusú fejlesztésekhez. Még mindig, mások up-and-comers kényszerítő új okokat kell figyelembe venni. Olvasson tovább, hogy vizsgálja meg a lehetőségeket, és megtalálja, mi fog működni a legjobban az Ön számára.

Ha már tudja, mi érdekli Önt, használja az alábbi linkeket a továbblépéshez:

• Hogyan válasszuk ki a megfelelő keretet az Ön igényeinek
• Full-Stack keretek vs. Microframeworks vs. Asynchronous Frameworks
• Python teljes verem Frameworks
• Microframeworks for Python
• aszinkron Frameworks for Python
• aszinkron Frameworks for Python
• melyik Python Web keretrendszer a legjobb az Ön számára?

Ha segítségre van szüksége a döntés meghozatalában, akkor egyenesen átugorhatja az ajánlások áttekintését is.

Hogyan válasszuk ki a megfelelő keretet az Ön igényeinek

a keretrendszereket úgy tervezték, hogy különböző problémákat oldjanak meg, és kompromisszumokat hozzanak létre a kívánt közönség jobb kiszolgálása érdekében. Ha mindenkinek ugyanazok a céljai lennének, akkor csak egy keretre lenne szükségünk! A keretrendszerek értékelésekor néhány fontos szempont a következő:

• mekkora a valószínű mérete és összetettsége annak, amit épít?
• inkább a saját könyvtárait, konfigurációját és alkalmazásstruktúráját választja, vagy egy előre kiválasztott opciókészletet szeretne?
• mennyire lesz fontos a teljesítmény a projekted számára?
• milyen gyorsan szeretné fejleszteni és telepíteni az alkalmazást?
• mennyi ideig lesz az alkalmazásod, és hány fejlesztő fog dolgozni rajta?

ezenkívül vegye figyelembe a rendelkezésre álló dokumentáció minőségét a lehetséges választásokhoz és a projekt körüli közösség méretét – ez befolyásolja mind a meglévő bővítmények vagy integrációk körét, amelyeket kihasználhat a fejlesztés gyorsabbá tétele érdekében, mind annak valószínűségét, hogy segítséget kaphat, amikor elakad.

tartsa szem előtt ezeket a szempontokat, amikor felfedezi a lehetőségeit – nagyon sok van belőlük! A projekt hosszú élettartamától függően fontolja meg azt is, hogy egy keret valószínűleg növekszik-e veled. Jól illeszkedik-e az alkalmazásához mind most, mind a jövőben?

Full-Stack Frameworks vs.Microframeworks vs. Asynchronous Frameworks

a Python frameworks nagyjából három táborra osztható, full-stack frameworks, microframeworks és aszinkron frameworks.

a Full-stack keretrendszerek általában nagyobb, teljes funkcionalitású alkalmazások építésére összpontosítanak, és sok közös funkciót kínálnak a dobozból. Ha valami komplexet szeretne gyorsan felépíteni, vagy ésszerű alapértelmezéseket szeretne az alkalmazás összerakásához anélkül, hogy maga választaná meg az összes választást, akkor a teljes kötegű keretrendszer jó választás. A Full-stack keretek általában ésszerű alapértelmezéseket biztosítanak az adatbázisokkal való kommunikációhoz, a nézetek sablonozásához, a sorok kezeléséhez, a háttérmunkákhoz és a nagyobb alkalmazások egyéb közös szempontjaihoz.

a Microframeworks általában arra összpontosít, hogy egy kis funkcionalitást biztosítson, és felkéri a fejlesztőt, hogy saját maga döntsön arról, hogy mely könyvtárakat és technológiákat adjon hozzá más funkciókhoz. Ennek az az előnye, hogy sokkal nagyobb ellenőrzést tesz lehetővé az alkalmazástervezés felett, és jobb alkalmazási teljesítményt eredményezhet. Általában megkövetelik a fejlesztőtől, hogy válassza ki saját adatbázis-absztrakciós rétegét és más könyvtárakat. A Microframeworks kiváló választás lehet kisebb, szűkebben fókuszált alkalmazásokhoz, API fejlesztésekhez vagy olyan alkalmazásokhoz, ahol a teljesítmény fontosabb.

az aszinkron keretek a magas szintű teljesítmény biztosítására összpontosítanak, mivel nagyon sok egyidejű kapcsolatot engedélyeznek. Miközben jelentősen növelheti a legtöbb szinkron keretrendszer párhuzamosságát azáltal, hogy párosítja őket aszinkron kiszolgálókkal, például a geventtel, a natív aszinkron keretek egy lépéssel tovább mennek egy teljesen aszinkron veremmel. Általában az aszinkron keretrendszerek nagyobb szigort igényelnek a programozási stílusban, és korlátozottabb bővítménykészlettel rendelkeznek. Az aszinkron keretek nagyszerűek, ha egy adott funkciót nagyon nagy mennyiségben kell biztosítani.

teljes verem Python keretek

Django

Django a legnépszerűbb full-stack keretrendszer Python. Jól megérdemelt hírneve, hogy rendkívül produktív, amikor összetett webes alkalmazásokat épít. A “határidőkkel rendelkező perfekcionisták webes keretrendszere” elnevezésű középpontjában a gyors fejlődés áll, jól dokumentált lehetőségekkel a gyakori esetekre.

a Django több mint egy évtizede létezik (első kiadása 2006-ban), és érett, átfogó, jól dokumentált és nagyon nagy közösséggel rendelkezik. Ez egy véleményes keret, ami azt jelenti, hogy sok döntést hoz a fejlesztő számára. Ennek a megközelítésnek a pozitívumai gyorsabbá teszik a fejlesztés megkezdését, az “áldott” integrációkat, amelyek csak működnek, és több headspace-t, hogy a projekt egyedi igényeire összpontosítson, ahelyett, hogy mely könyvtárakat használja. Ezenkívül a Django projektek általában nagyon hasonlónak tűnnek, ami megkönnyíti a fejlesztők számára, hogy gyorsan felmenjenek a számukra új projektekre, valamint a csapatok számára, hogy következetesen szervezzék erőfeszítéseiket.

a Django sok mindent kínál a dobozból, beleértve a saját objektum-relációs leképezőjét (ORM) az adatbázisok kezeléséhez, a hitelesítés és az engedélyezés szabványos megközelítését, az automatikusan létrehozott adminisztrációs felületet (amely hasznos a gyors prototípus-készítéshez), az integrált gyorsítótárazást és így tovább.

jó projektek kis és nagy, Django lehet méretezni jól ésszerű terhelés és már használják sok nagy forgalmú oldalak, beleértve Instagram, Mozilla, és a Washington Post. A Django aszinkron funkciókkal rendelkezik a 3.0 verzióban, aszinkron nézetekkel és köztes szoftverekkel a 3.1-es verzióban.

míg hagyományosan összpontosított full-stack webes alkalmazások, Django is kiválóan alkalmas a fejlődő API-csak backend alkalmazások. Érett integrációk léteznek mind a REST, mind a GraphQL API-k gyors felépítéséhez a Django-val.

alsó sor: A de-facto szabvány jó okból, Django a domináns full-stack keretrendszer Python. A Django kiválóan alkalmas a gyors kezdéshez és a méretezés bizonyított eredményeivel számos projekthez kiválóan alkalmas. Ha jobban szeretne testreszabni, mint amennyit a Django megenged, fontolja meg a Pyramid and the microframeworks alkalmazást. Ha nagyon magas párhuzamosságra van szüksége, fedezze fel az aszinkron keretrendszereket.

piramis

piramis egy másik népszerű full-stack keretrendszer. A pilons projekt gyökereivel a Django óta fejlesztés alatt áll, és szintén nagyon érett lehetőség.

a Django-val ellentétben a piramis kevésbé véleményes. Útválasztást, renderelőket és parancssori eszközöket biztosít a projekt indításához, de lehetőséget kínál arra, hogy kiválassza saját adatbázisrétegét, sablonrendszerét és még sok más bővítményt.

alapvető rugalmasságával a Pyramid egy szép középút, ha egy teljes verem vagy egy mikrokeret között próbál dönteni. A Pyramid lehetővé teszi, hogy kisebb legyen, mint a Django, és szükség szerint növelje a kódbázis összetettségét. Ez a rugalmasság a könyvtári támogatásban fontos lehet, ha speciális követelményekkel rendelkezik, vagy erősen kapcsolódik olyan rendszerekhez, amelyeket a Django esetleg nem integrál jól (a régi adatbázisok gyakori példa).

a Pyramid elkötelezett rajongótáborral és aktív közösséggel rendelkezik, akik értékelik a növekvő természetét és alapvető rugalmasságát. Ha megy a piramis, számíthat extra munkát választani alkatrészek előre. Ez azonban hosszú távon jól eltöltött idő lehet, ha lehetővé teszi az Ön számára kritikus fejlesztési szempontok végleges felgyorsítását.

lényeg: a rugalmasság és az irányítás erőteljes keveréke teszi a Pyramid-ot a Django kényszerítő alternatívájává egyes projekteknél.

Web2Py

a web2py egy teljes verem keretrendszer, amely a könnyű fejlesztésre összpontosít, saját webalapú IDE – vel, hibakeresővel és telepítési vezérlőkkel. A Ruby on Rails és a Django ihlette, és az MVC (Model View Controller) dizájnt követi.

a projekt oktatási eszközként indult, és hangsúlyt fektet a közös funkcionalitásra, ésszerű alapértékekkel. Sokkal könnyebb tanulási görbével rendelkezik, mint a legtöbb keretrendszer, és rendkívül könnyű telepíteni és elkezdeni. A dokumentáció nagyszerű, és rengeteg funkció van beépítve, beleértve az ütemezőt, a 2FA helpers-t és egy szép jegykezelő rendszert, amelyet automatikusan betöltenek a gyártási hibák.

a web2py kisebb közösséggel rendelkezik, mint a Django és néhány más keretrendszer, de nagyon barátságos. Sok oktató és erőforrás áll rendelkezésre.

alsó sor: A webfejlesztéssel kísérletező újabb programozók vagy fejlesztők számára a legmegfelelőbb. Nem alkalmas új, nagyobb léptékű kereskedelmi projektekhez.

TurboGears

számlázott, mint a “framework, hogy a mérleg veled”, TurboGears lehetővé teszi, hogy indítsa el az alkalmazás olyan egyszerű, mint egy fájl (mint egy microframework), vagy skála egészen egy teljes verem app parancssori eszközök támogatása menedzsment. Ebben az értelemben hasonló a Pyramid-hoz, azzal az előnnyel, hogy több ellenőrzést/testreszabást igényel, mivel több munkát igényel előre, hogy meghatározza, hogyan szeretné strukturálni az alkalmazást, és mely könyvtárakat szeretné integrálni.

Az alapértelmezett ORM TurboGears a kiváló SQLAlchemy. A TurboGears érdekes különbségeket mutat az Útválasztás és az alapértelmezett sablonmegoldás kezelésében. A legtöbb full-stack keretrendszerrel ellentétben az útválasztást objektumhierarchián keresztül kezelik, ahelyett, hogy reguláris kifejezéseket rendelnének a vezérlőkhöz (a leképezés alternatív megoldásként elérhető). A TurboGears alapértelmezett sablonrendszere a Kajiki, egy XSLT-ihlette nyelv.

alsó sor: a TurboGears jól skálázik, sok irányítással, a kis projektektől a nagyobbakig. A Pyramid azonban hasonló rugalmasságot kínál, és valószínűleg jobb választás a legtöbb ember számára.

Masonite

a Masonite egy viszonylag új (2017) keretrendszer, amelynek tervezési filozófiája hasonló a Django-hoz, de célja néhány gyakori fájdalompont javítása. Továbbfejlesztett kódállványokat, útválasztási köztes szoftvert és beépített támogatást kínál az e-mail küldéshez, az S3 feltöltéshez és a sorban álláshoz.

a Masonite architektúrája rendkívül bővíthető, integrált képességei pedig lenyűgözőek. A dokumentáció jó, és van egy aktív Slack csatorna a támogatáshoz. Saját ORM-ot használ, Orator, az ActiveRecord alapján.

újabb keretként a Masonite közössége kicsi, de növekszik. Ez aktívan javult, és van egy csomó, hogy tetszik. Tekintettel a kisebb mindshare-re, nehezebb megtalálni a Masonite-ot ismerő fejlesztőket, de ha a kiegészítő out-of-the-box képességek jól illeszkednek az Ön igényeihez, felgyorsíthatja a fejlődést.

alsó sor: egy újabb versenyző, a Masonite egyszerűvé teszi az olyan általános feladatokat, mint az e-mail kezelés, a fájlok feltöltése a felhőbe, valamint a fizetés feldolgozása.

Microframeworks Python

lombik

a Flask hihetetlenül népszerű megoldás mind a webes alkalmazások, mind a mikroszolgáltatások számára. Eredetileg a Ruby framework Sinatra ihlette, a Flask egy alapvető funkcionalitás biztosítására összpontosít (kéréskezelés, útválasztás, WSGI megfelelés, sablonozás), és moduláris kialakítást kínál minden más szükséges hozzáadásához.

ennek eredményeként az alkalmazás indítása hihetetlenül egyszerű. Meg lehet építeni egy működő webes alkalmazás csak néhány sort:

from flask import Flask, escape, requestapp = Flask(__name__)@app.route('/')def hello(): name = request.args.get("name", "World") return f'Hello, {escape(name)}!'

lombik széles körű elérhető kiterjesztések, amely lehetővé teszi, hogy integrálja a saját választási Tárolás, adatbázis interakció, hitelesítés és engedélyezés, a biztonság és így tovább. Időbe telik a választási lehetőségek integrálása és beállítása, de az alkalmazások fokozatosan építhetők, és nem tartalmaznak könyvtárakat és kódot olyan dolgokhoz, amelyeket az alkalmazás nem használ.

a Lombikalkalmazások általában egyetlen fájlban kezdődnek, de nagyon nagy méretűek lehetnek. Vannak közös minták elrendezése lombik alkalmazások és lombik is kínál tervrajzok, mint egy módja annak, hogy a nagyobb alkalmazások több moduláris és kezelhető.

alsó sor: rendkívül rugalmas, a Flask kiválóan alkalmas a felhasználó felé néző webes alkalmazásokhoz, API-khoz és mikroszolgáltatásokhoz egyaránt. A lombik a legnépszerűbb mikrokeret a Python számára.

Palack

a palack szintaxisa hasonló a lombikhoz (valójában egy évvel megelőzi), de egyetlen fájlként oszlik meg, a python standard könyvtáron kívüli függőségek nélkül. Ez megkönnyíti a futtatást bármilyen környezetben, beleértve azokat a helyeket is, ahol a könyvtárak telepítése nehéz. Ez azt is jelenti, hogy a függőségkezelés triviális lehet, ami nagyszerű lehet kisebb projekteknél.

from bottle import route, run, template@route('/hello/<name>')def index(name): return template('<b>Hello {{name}}</b>!', name=name)run(host='localhost', port=8080)

a funkciókészlet meglehetősen hasonló a lombikhoz, de az aktív közösség sokkal kisebb. A rendelkezésre álló bővítmények szintén korlátozottabbak. Ezenkívül kevesebb oktatóanyag van, és nehezebb lehet kódpéldákat találni vagy segítséget kérni. a

Bottle leginkább a nagyon kicsi kódbázisú alkalmazásokhoz igazodik, és nincs egyértelmű útja a kódszervezés skálázásához, mivel a dolgok összetettebbé válnak. Az egyszerűség a hangsúly. Ha kevesebb függőség van, sokkal egyszerűsítheti a telepítést (csak ragaszkodjon bottle.py a projektkönyvtárban), és gyorsabban eljuthat egy prototípusból egy termelési alkalmazásba.

alsó sor: Nagyszerű személyes projektekhez, kis alkalmazásokhoz vagy telepítési forgatókönyvekhez, ahol az összetett függőségek kezelése nehéz.

H3: CherryPy

a CherryPy egy másik érett mikrokeret (2002 óta) saját rajongókkal. Az egyik fő különbség a lombik és a palack között az, hogy a CherryPy objektum-orientált, és arra összpontosít, hogy a lehető “pitonikus” legyen. Másképp fogalmazva: a CherryPy célja, hogy egy webalkalmazás írása a lehető legjobban hasonlítson az Általános python-kód írásához. Nézzünk egy példát:

import cherrypyclass HelloWorld(object): @cherrypy.expose def index(self): return "Hello World!"cherrypy.quickstart(HelloWorld())

láthatja, hogy az alkalmazás osztályként van definiálva, szemben a lombik funkcióalapú megközelítésével. Maga az Útválasztás is objektum-alapú; a ‘@ cherrypy ‘ dekoratőr jelzi, hogy mely objektummódszereket kell útvonalakká alakítani, ahol a lombikban a dekorátorok maguk határozzák meg az útvonalakat. Egyes fejlesztők inkább az implicit útválasztás ezen formáját részesítik előnyben, míg mások kihívást jelentenek.

a CherryPy egyik erőssége a webszerver, amely a keretrendszerbe van csomagolva. Gyors, gyártásra kész, HTTP/1.1-Kompatibilis, szál-összevont, és lehet használni bármilyen Python WSGI alkalmazás. Valójában egyes fejlesztők a CherryPy webszerverét használják más (nem CherryPy) WSGI alkalmazások futtatására, mert annyira könnyű beállítani és használni.

a CherryPy számos beépített funkciót is tartalmaz, beleértve a munkamenet-kezelést, a hitelesítést, a statikus tartalomkezelőket, a gyorsítótárazást, a profilalkotást stb. Bővítmények állnak rendelkezésre, amelyek gazdag kiterjesztési pontokat tartalmaznak.

a CherryPy közössége sokkal kisebb, mint a Flask-é, ami kisebb plugin-közösséget, kevesebb oktatóanyagot stb.

alsó sor: Érdemes megnézni,ha inkább egy objektum-orientált fejlesztési stílust szeretne.

Sólyom

Falcon egy teljesítményközpontú keretrendszer REST API-k és mikroszolgáltatások építéséhez. Tekintettel arra, hogy a sebességre összpontosít, a Falcon korlátozott funkciókészletet kínál: routing, middleware, hooks, erős hiba/kivétel kezelés és WSGI segítők az egység tesztelésének megkönnyítése érdekében.

a Falcon minden érdeklődést elválaszt a felhasználóbarát alkalmazások iránt, és a JSON kiszolgálására összpontosít a REST végpontokon keresztül. Vegye figyelembe a többi igét (GET) ebben a kódpéldában:

import falconclass QuoteResource: def on_get(self, req, resp): """Handles GET requests""" quote = { 'quote': ( "I've always been more interested in " "the future than in the past." ), 'author': 'Grace Hopper' } resp.media = quoteapi = falcon.API()api.add_route('/quote', QuoteResource())

a hangolás és az egyedi fókusz miatt a Falcon radikálisan gyorsabb (20-75x!), mint a Django és a Flask a nagyon alapvető kérések referenciaértékeiben. A Falcon további erős aspektusai az idiomatikus HTTP hibajelzések (gyakori fájdalompont az API-k készítésekor) és az egyszerű kivételkezelés. Ez fut PyPy és támogatja Cython a CPython, két lehetőség, hogy fontolja meg a maximális teljesítményt.

Ha tetszik a Falcon ötlete, de egy teljes funkcionalitású megoldást szeretne, vessen egy pillantást a Hug-ra, a Falcon tetejére épített keretrendszerre, amely verziókezelést, automatikus dokumentációt és típusvezérelt automatikus érvényesítést tartalmaz.

alsó sor: ha nagy teljesítményű REST/JSON API-kat szeretne építeni, akkor a Falcon lehet az Ön számára.

aszinkron keretek python

Sanic

a Sanic egy viszonylag új (első kiadás 2016-ban) aszinkron webes keretrendszer és szerver, “gyorsan írva”.

míg a listán szereplő full-stack és microframeworks többsége már legalább egy évtizede létezik, az asyncio hozzáadása a Python 3.5+ – ban megnyitotta az ajtókat a nagy teljesítményű aszinkron keretek teljesen új generációja előtt. A Sanic az egyik legelterjedtebb lehetőség ebben az új generációban.

a Sanic szintaxisa meglehetősen hasonló a Flaskhoz, a végpontok közötti aszinkron támogatás hozzáadásával:

from sanic import Sanicfrom sanic.response import jsonapp = Sanic()@app.route("/")async def test(request): return json({"hello": "world"})if __name__ == "__main__": app.run(host="0.0.0.0", port=8000)

erős útválasztási képességekkel, köztes szoftverekkel, streameléssel, WebSocket Támogatással, cookie-k kezelésével, útvonal-verzióval, statikus fájlszolgáltatással és így tovább. A Sanic természetes illeszkedés, ha olyan hosszú életű kapcsolatokat kell kezelnie, mint a WebSockets, vagy magas szintű párhuzamosságra van szüksége az API-n kívül.

egy aszinkron keretrendszerrel az aszinkron programozás köré kell tekerni a fejét a Pythonban, a kapcsolódó figyelmeztetésekkel, összetettséggel és hibakeresési kihívásokkal. Érdemes időt szánni arra, hogy felmérje, valóban szüksége van-e egy teljesen aszinkron API teljesítményére, de ha igen, akkor a Sanic érdemes megnézni!

alsó sor: Érett, megalapozott lehetőség a nagy teljesítményű aszinkron API-k fejlesztésére

FastAPI

a FastAPI újabb, mint a Sanic (első kiadás 2019 elején), de gyorsan lendületet kap. Kiváló a rest vagy a GraphQL API-k építésében, és képes kezelni a szinkron kéréseket, az aszinkron kéréseket, a streaminget és a WebSocket-eket.

beépített támogatással rendelkezik a hitelesítéshez és az engedélyezéshez, az adatok érvényesítéséhez, a JSON sorosításához és az OpenAPI szabványt követő automatikus API dokumentációval rendelkezik.

from fastapi import FastAPIapp = FastAPI()@app.get("/")def read_root(): return {"Hello": "World"}@app.get("/items/{item_id}")def read_item(item_id: int, q: str = None): return {"item_id": item_id, "q": q}

a fastapi funkciókészlet valóban lenyűgöző, és a rugalmasság és a könnyű fejlesztés kombinációjával édes helyet talál. Nagyon elgondolkodva tervezték, és széles körben kihasználja a típusú utalást és a függőségi injekciót a fejlesztés hibáinak csökkentése érdekében. Ezenkívül a fastapi dokumentációja és szerkesztői támogatása kiváló.

a FastAPI szintaxisa meglehetősen hasonló a Flask-hoz, ami jó választás, ha a meglévő lombik kódbázisokat teljesen aszinkron megoldásra kívánja migrálni.

alsó sor: Egyre növekvő keret, a FastAPI érdemes felfedezni a következő aszinkron projektet.

Starlette

a Starlette egy könnyű ASGI keretrendszer és eszközkészlet, amely primitíveket és moduláris integrációt biztosít, hogy az alkalmazást bármilyen szintű vezérléssel építhesse fel.

az ASGI a WSGI utódja, amely szabványos interfészt biztosít az async-képes webszerverek, keretrendszerek és alkalmazások között. Vegye figyelembe, hogy az ASGI támogatja mind a szinkron, mind az aszinkron műveleteket, és az ASGI tartalmaz egy WSGI visszamenőleges kompatibilitási megvalósítást.

keretrendszerként a Starlette összekapcsolja különböző funkcióit az Ön számára, beleértve a WebSocket támogatást, a GraphQL támogatást, a folyamatban lévő háttérfeladatokat, a munkamenet-és cookie-támogatást, a CORS-t, a GZip-et, a statikus fájlokat és így tovább. Az egyes darabokat önállóan is felhasználhatja, az eszközkészlet egyes darabjainak kiválasztásával.

mivel a Starlette először egy eszközkészlet, a keretrendszerként való használat kompozíciósabbnak érezheti magát, külön-külön kitéve:

from starlette.applications import Starlettefrom starlette.responses import JSONResponsefrom starlette.routing import Routeasync def homepage(request): return JSONResponse({'hello': 'world'})app = Starlette(debug=True, routes=)

a FastAPI valójában a Starlette tetejére épül, szintaxis kényelmet és további funkciókat adva hozzá. A legtöbb csapat számára a FastAPI valószínűleg jobb hely a kezdéshez, de a Starlette maximális irányítást és erőteljes primitíveket kínál.

alsó sor: ha azt szeretnénk, hogy a munka közel a fém a saját aszinkron eszközök, Starlette egy fantasztikus hely kezdeni.

Tornado

a Tornado egy régebbi async webes keretrendszer, amelyet jóval az asyncio képességek pythonba sütése előtt hoztak létre. Eredetileg a FriendFeed készítette, és először 2009-ben jelent meg, a Tornado bevált megoldás a Python több tízezer nyitott kapcsolatának méretezésére.

a Tornado magja egy nagymértékben testreszabható alkalmazásmodell, erős mögöttes hálózati könyvtárakkal. Ez magában foglalja az útválasztást, a sablonozást, a munkamenet-és cookie-kezelést, a natív WebSocket támogatást, a biztonsági funkciókat, és a különböző adattárolók számára Érett lehetőségeket kínál. Kevésbé teljes funkcionalitású, mint valami Django, de sokkal több beépített funkcióval rendelkezik, mint egy tipikus mikrokeret. Tornado használ ige-stílusú módszerek kérésre kezelő osztályok, így alkalmas arra, hogy egy objektum-orientált fejlesztési stílus:

import tornado.ioloopimport tornado.webclass MainHandler(tornado.web.RequestHandler): def get(self): self.write("Hello, world")def make_app(): return tornado.web.Application()if __name__ == "__main__": app = make_app() app.listen(8888) tornado.ioloop.IOLoop.current().start()

a Tornado továbbra is aktívan fejlesztésre és karbantartásra kerül, robusztus közösséggel. Ezt a Facebook, a Quora és mások használják termelési architektúrájukban.

a Tornado 6+ asyncio-t használ a motorháztető alatt, és Python 3.5+ – t igényel, de a Tornado 5 használható Python 2.7 és újabb verziókkal. A Python 3.5+ rendszeren futó Tornado aszinkron corutinok a natív ‘async’ ` ‘wait’ szintaxist használják. A korábbi verziókhoz a Tornado generátor szintaxist kínál, amely hasonló képességekkel rendelkezik. Nevezetesen, a Tornado Érett híddal rendelkezik a Twisted számára, amely lehetővé teszi mind a Twisted alkalmazások, mind a könyvtárak futtatását a Tornado tetején.

alsó sor: a Tornado egy bevált megoldás a nagyszámú egyidejű kérés méretezésére, érdemes megvizsgálni, ha egy erős közösséggel rendelkező bevett opciót szeretne, régebbi kódbázisokhoz van kötve, vagy a Python régebbi verzióit kell használnia.

melyik Python webes keretrendszer a legjobb az Ön számára?

amint ebből a listából egyértelműnek kell lennie, sok jó lehetőség van. Valójában sok más keretrendszer is elérhető a Python számára-ezt a cikket szándékosan csak azokra a keretekre korlátoztuk, amelyekről úgy gondoljuk, hogy 2020-ban a leginkább érdemes megfontolni.

jó kiindulópont azok a kritériumok, amelyeket a cikk elején említettünk. Mik a céljaid? Valami újat szeretne kísérletezni, gyorsan építeni valamit bevált technológiával, vagy új készségeket tanulni? Hány ember fog dolgozni a kódbázison,és mennyi ideig lesz? Ezek mind hasznos nyomokat, hogy a helyes választás.

nincs olyan keretrendszer, amely mindenki számára tökéletes lenne, de itt van néhány általános javaslat:

• Ha gyorsan szeretne elindulni egy jól bevált megoldással, ahol az erőforrásokat könnyű megtalálni, használja a Django vagy a lombikot
• Ha szeretne kicsi és megérteni (vagy ellenőrizni) az alkalmazás összes darabját, fedezze fel a piramist, a lombikot vagy a CherryPy-t
• ha olyan API-t vagy microservice-t épít, amely rendkívül hatékonynak kell lennie, nézze meg a Falcon-t, fastapi vagy sanic.
• Ha kezdő programozó vagy, vagy csak webfejlesztést tanulsz, a web2py vagy a Bottle barátságos, egyszerű módja az indulásnak
• ha új ötletekkel és a dolgok elvégzésének módjaival szeretné felfedezni a up-and-comings keretrendszereket, nézd meg a Masonite-ot és a FastAPI-t

hasznosnak találta ezt a cikket, vagy látott valamit, amivel nem ért egyet, vagy úgy gondolja, hogy javítani kell. Kérjük, ossza meg velünk, értékeljük visszajelzését!