Bestes Framework zum Erstellen einer API in Python

Dies ist der zweite Artikel einer Serie, die sich mit dem Thema APIs beschäftigt.

Jeder Artikel behandelt ein anderes Thema. Wenn Sie gerade erst anfangen zu verstehen, wie Sie Ihre eigene API schreiben, ist es sinnvoll, alles der Reihe nach zu lesen. Wenn Sie bereits Bescheid wissen und sich für ein bestimmtes Thema interessieren, gehen Sie direkt zu diesem.

1. Einfache Erläuterung der API
2. Bestes Framework für API (dieser Artikel 👇)
3. API mit FastAPI erstellen (bald)
4. API mit ChatGPT erstellen (bald)
5. Tools zum Testen von API (bald)
6. Mit API Geld verdienen (bald)

Los geht’s…

API frameworks

Im vorigen Artikel haben wir herausgefunden, was eine API ist und wie sie funktioniert. Jetzt wollen wir sehen, wie Sie das beste Framework für APIs in Python auswählen. Um ein Tool auszuwählen, mit dem Sie schnell und effizient APIs in Python schreiben können, müssen Sie die folgenden Dinge berücksichtigen:

• Projektgröße. Wenn Ihre API Teil einer vollwertigen Webanwendung sein soll, wählen Sie am besten ein Framework, mit dem Sie sowohl die Webanwendung selbst als auch deren API-Teil erstellen können. Wenn Sie nur die API benötigen, ist jedes der Mikro-Frameworks ausreichend.

• Arbeitslast. Diese wird in der Regel direkt durch die CPU- und Speicheranforderungen des Servers bestimmt. Der offensichtlichste Parameter ist die Anzahl der Client-Server-Anfragen, die der Server verarbeiten kann.

• Assimilationszeit. In der Regel gilt: Je leistungsfähiger ein Framework ist, desto mehr Zeit ist erforderlich, um es zu erlernen. Wenn Sie ein Tool bereits gut beherrschen, können Sie diesen Parameter natürlich außer Acht lassen.

Ein Sonderfall ist ein einfacher Fall, in dem Sie lediglich einen Client zum Abrufen von Daten aus einer bestehenden API benötigen. Um ihn zu erstellen, können Sie embedded module oder eine der beliebten Bibliotheken wie httplib2 oder den allseits beliebten requests verwenden. Auch wenn sie nicht direkt mit dem Thema zu tun haben, werden wir sie uns ansehen, um das Bild zu vervollständigen.

Werfen wir nun einen Blick auf die besten REST-API-Frameworks in Python, die aktiv unterstützt und entwickelt werden, bei Entwicklern beliebt sind und heutzutage weit verbreitet sind. Der Einfachheit halber habe ich sie in drei bedingte Kategorien unterteilt:

• Client-Bibliotheken
• Micro-Frameworks (minimaler Satz von Funktionen)
• Full-Stack-Frameworks (voller Funktionsumfang)

Lassen Sie uns mit einem einfachen beginnen…

Client-Bibliotheken

Requests

Site: https://github.com/psf/requests

Type: Client-Bibliothek

Requests ist eine sehr beliebte HTTP-Client-Bibliothek in Python. Sogar in der offiziellen Python-Dokumentation wird sie empfohlen. Wie der Name schon sagt, wird sie verwendet, um Anfragen an die API zu stellen. Die Bibliothek unterstützt alle HTTP-Methoden und erweiterte Funktionen wie Authentifizierung, Session-Cookies, Arbeit mit SSL und viele andere.

Die Arbeit mit Requests ist sehr einfach. Hier ein Beispiel für einen Python-API-Aufruf, wenn Sie die GET-Methode zur Autorisierung auf einer Website verwenden:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

>>> import requests
>>> URL = 'https://httpbin.org/basic-auth/user/pass'
>>> r = requests.get(URL, auth=('user', 'pass'))
>>> r.status_code
200
>>> r.headers['content-type']
'application/json; charset=utf8'
>>> r.encoding
'utf-8'
>>> r.text
'{"authenticated": true, ...'
>>> r.json()
{'authenticated': True, ...}

Hier finden Sie eine ausführliche Dokumentation zu Requests Bibliothek.

Faster Than Requests

Site: https://github.com/juancarlospaco/faster-than-requests/

Type: Client-Bibliothek

Ein recht interessantes Paket, das aktiv weiterentwickelt wird. Nach Angaben des Entwicklers arbeitet es schneller als Requests :) Vielleicht liegt das daran, dass es hauptsächlich die Sprache Nim verwendet. Es gibt einen Leistungsvergleich auf der GitHub repository. Es wird auch behauptet, dass die Bibliothek in Bezug auf die Anzahl der Codezeilen viel kompakter ist.

Das Praktischste an dieser Bibliothek sind die vielen Hilfsfunktionen, die über die üblichen HTTP-Methoden hinausgehen. Sie bietet mehrere praktische Funktionen für Aufgaben wie das Auffinden von URLs, das Herunterladen von Ressourcen wie Bilddateien oder das Zusammenführen von Anfragen an mehrere URLs und die Rückgabe einer einzigen Antwort.

Hier finden Sie einige Beispiele für Standard-Python-API-Anfragen:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import faster_than_requests as requests

# GET
requests.get("http://httpbin.org/get")

# POST
requests.post("http://httpbin.org/post", "Some Data Here")

# Download a file
requests.download("http://example.com/foo.jpg", "out.jpg")

# Multi-Threaded Web Scraper
requests.scraper(["http://foo.io", "http://bar.io"], threads=True)

# URL-to-SQLite Web Scraper
requests.scraper5("http://foo.io", sqlite_file_path="database.db")

# Regex-powered Web Scraper
requests.scraper6("http://python.org", "(www|http:|https:)+[^s]+[w]")

# CSS Selector Web Scraper
requests.scraper7("http://python.org", "body > div.someclass a#someid")

# WebSockets Binary/Text
requests.websocket_send("ws://echo.websocket.org", "data here")

PycURL

Site: http://pycurl.io/

Type: Client-Bibliothek

PycURL ist lediglich eine Python-Erweiterung für die Bibliothek libcurl, die für die Übertragung von Dateien über verschiedene Protokolle verwendet wird. Sie unterstützt HTTP, FTP, SMTP und viele andere. Wenn Sie cURL- oder libcurl-Bibliotheken mögen, könnte Ihnen auch diese Python-Schnittstelle für die native libcurl-Bibliothek gefallen, die in C/C++ geschrieben wurde.

Sie finden eine Menge interessanter Dinge im offiziellen repository PycURL auf GitHub. Weitere Einzelheiten über die Bibliothek finden Sie auch in der offiziellen Dokumentation.

Nachfolgend finden Sie ein Beispiel für einen HTTP-GET-Aufruf mit PycURL.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import pycurl
from io import BytesIO

buffer = BytesIO()
c = pycurl.Curl()
c.setopt(c.URL, 'http://pycurl.io/')
c.setopt(c.WRITEDATA, buffer)
c.perform()
c.close()
body = buffer.getvalue()
# Body ist eine Byte-Zeichenkette.
# Sie müssen die Kodierung kennen, um sie in eine Textdatei auszugeben,
# zum Beispiel in der Standardausgabe.
print(body.decode('iso-8859-1'))

urllib3

Site: https://urllib3.readthedocs.io/

Type: Client-Bibliothek

Diese Python-Bibliothek verfügt über eine spezielle Klasse zur Verwaltung von Verbindungspools mit Unterstützung für Multithreading, Datei-Uploads, Formulare, Ausnahmebehandlung und mehr. Sie hat eine benutzerfreundliche Oberfläche, eine gute Dokumentation und sogar integrierte Unterstützung für Bibliotheken von Drittanbietern.

urllib3 ist ein leistungsstarker und einfach zu bedienender HTTP-Client für Python. Die Funktionalität der Bibliothek ermöglicht organisieren ein schnelles und zuverlässiges Arbeiten mit nahezu jeder Informationsquelle im Internet.

Der größte Teil des Python-Ökosystems verwendet bereits urllib3, so dass Sie sich diese Bibliothek vielleicht auch einmal näher ansehen sollten.

Beispiele für Python-API-Aufrufe in der urllib3-Bibliothek:

1
2
3
4
5
6
7
8
9

>>> import urllib3
>>> http = urllib3.PoolManager(num_pools=2)
>>> resp = http.request('GET', 'http://yahoo.com/')
>>> resp = http.request('GET', 'http://google.com/')
>>> resp = http.request('GET', 'http://httpbin.org/robots.txt')
>>> resp.status
200
>>> resp.data
b"User-agent: *\nDisallow: /deny\n"

Micro-Frameworks

Flask

Site: https://flask.palletsprojects.com/

Type: Mikro-framework

Das Projekt begann als einfacher Wrapper um Werkzeug und Jinja und ist heute eines der beliebtesten Frameworks für die Entwicklung von Python-Webanwendungen, einschließlich der Erstellung von APIs. Das Projekt-Repository auf GitHub hat bereits über 60.000 Sterne. Flask macht den Einstieg leicht, liefert schnell die ersten Ergebnisse und skaliert Ihre Anwendung schrittweise auf jede Ebene.

Im Laufe der Jahre hat Flask viele Funktionen hinzugefügt, die es fast auf eine Stufe mit Full-Stack-Frameworks stellen. Es ist jedoch sein minimalistischer Ansatz bei der Erstellung von Webanwendungen, der es für viele Entwickler zur bevorzugten Wahl macht.

Flask bietet eine Vielzahl von Optionen, um Ihr Ziel zu erreichen und zwingt Sie nicht dazu, bestimmte Bibliotheken zu verwenden oder einer streng definierten Projektstruktur zu folgen. Sie können die Tools und Bibliotheken, die Sie verwenden möchten, selbst auswählen.

Es gibt viele nützliche Erweiterungen, die von der Community entwickelt und unterstützt werden und mit denen Sie Ihrer Anwendung ganz einfach Funktionen hinzufügen können.

So können Sie eine einfache “Hello World”-Webanwendung in Flask schreiben:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run()

Weitere Informationen und Dokumentationen zu Flask finden Sie auf der Projektwebsite, und eine Liste zusätzlicher Ressourcen und Plugins in diesem Repository auf GitHub.

Ich empfehle auch das offizielle Tutorial von Miguel Grinberg selbst, die ausgezeichnete Artikelserie auf Hackers and Slackers und die Benutzergemeinschaft auf Reddit.

Tornado

Site: https://www.tornadoweb.org/

Type: Mikro-framework

Tornado ist ein Framework und eine asynchrone Netzwerkbibliothek. Sie umfasst auch eine HTTP-Server- und Client-Schnittstelle sowie eine WebSocket-Schnittstelle für die Zwei-Wege-Kommunikation mit Servern, die WebSocket unterstützen.

Tornado unterstützt alle grundlegenden Middleware-Funktionen, die für die Bearbeitung von HTTP-Anfragen und -Antworten, Vorlagen und Routing erforderlich sind.

Es unterstützt auch Coroutines (kooperative Routen) und ist damit ein hervorragendes Werkzeug für die Erstellung von Server-Backends mit langen Datenabrufzyklen und persistenten Verbindungen, insbesondere für WebSockets.

Ein einfaches Backend für die API in Tornado kann wie folgt erstellt werden:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import asyncio
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

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

async def main():
    app = make_app()
    app.listen(8888)
    await asyncio.Event().wait()

if __name__ == "__main__":
    asyncio.run(main())

Tornado gibt es schon seit langem, aber einige seiner Funktionen sind im Vergleich zu modernen REST-Frameworks etwas veraltet. Dennoch ist es sehr beliebt, denn repository auf GitHub hat fast 21 Tausend Sterne.

FastAPI

Site: https://fastapi.tiangolo.com/

Type: Mikro-framework

FastAPI ist eines der neueren Python-Frameworks. Laut den Entwicklern ist es sehr schnell, leistungsstark und unterstützt eine kompakte Codierungsstruktur, was zu einer sehr schnellen Anwendungsentwicklung führt.

FastAPI basiert auf den asyncio Fähigkeiten in Python, die als ASGI-Spezifikation für die Erstellung asynchroner Webanwendungen standardisiert wurden. FastAPI ist fast so leistungsfähig wie Flask und unterstützt integrierte Prozeduren für die Integration mit Datenbanken, die Ausführung von Hintergrundaufgaben, die Anbindung benutzerdefinierter Middleware und vieles mehr.

Mit über 50.000 Sternen unter repository auf GitHub erfreut sich FastAPI zunehmender Beliebtheit in der Python-Community und wird von einer Gruppe aktiver Fachleute mit über 100 Personen ständig weiterentwickelt.

Hier erfahren Sie, wie Sie eine einfache REST-API mit FastAPI erstellen können:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from fastapi import FastAPI

app = 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}

Offizielle Dokumentation: https://fastapi.tiangolo.com

GitHub-Repository: https://github.com/tiangolo/fastapi

Sanic

Site: https://sanic.dev/en/

Type: Mikro-framework

Sanic ist ein weiteres asyncio-basiertes Python-Webframework. Es handelt sich um ein sehr leichtgewichtiges Framework mit Unterstützung für alle grundlegenden HTTP- und Middleware-Anwendungsfunktionen.

Darüber hinaus unterstützt Sanic die Möglichkeit, eigene Protokolle und Middleware-Komponenten zu schreiben, um das Anfrage- und Antwortprotokoll anzupassen. Sanic verfügt über einen eigenen integrierten Webserver, um die Entwicklung zu beschleunigen, und lässt sich für industrielle Anwendungen auch gut mit Nginx integrieren.

Hier sehen Sie, wie Sie eine einfache API in Sanic schreiben:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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)

Weitere Informationen finden Sie unter Sanic repository auf GitHub oder Sanic Getting Started Guide.

Falcon

Site: https://falconframework.org/

Type: Mikro-framework

Falcon ist ein einfaches und robustes Framework für den Aufbau umfangreicher Anwendungs-Backends und Microservices. Es unterstützt den REST-Architekturstil und arbeitet mit WSGI- oder ASGI-kompatiblen Servern.

Falcon verfügt über eine objektorientierte, klassenbasierte Schnittstelle zur Definition von API-Ressourcen. Es unterstützt grundlegende HTTP- und Middleware-Anwendungsfunktionen, einschließlich HTTP-Protokollverarbeitung, Routing, Medienverarbeitung, Cookies und URI-Dienstprogramme.

Im Folgenden erfahren Sie, wie Sie eine REST-API mit dem objektorientierten Ansatz von Falcon erstellen:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class 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 = quote

api = falcon.API()
api.add_route('/quote', QuoteResource())

Weitere Informationen finden Sie im Falcon Repository auf GitHub. Um mit der Entwicklung von Falcon zu beginnen, empfiehlt es sich, die offizielle Dokumentation des Projekts zu lesen.

Bottle

Site: https://bottlepy.org/

Type: Mikro-framework

Bottle ist ein sehr leichtgewichtiges Mikro-Framework. Es ist sehr klein, wird als eine einzige Datei verteilt und hängt nur von der Standard-Python-Bibliothek ab.

Bottle ist ideal für:

• Schnelles Prototyping von Ideen
• Lernen, wie Frameworks aufgebaut sind
• Erstellen und Ausführen einfacher persönlicher Webanwendungen

Gleichzeitig bietet Bottle alle Komponenten, die Sie benötigen, um ein komplettes Backend für eine REST-API zu erstellen, das auf Routing und Templates basiert. Es unterstützt die meisten der üblichen HTTP-bezogenen Funktionen wie Cookies, Header, Metadaten und Datei-Uploads. Außerdem verfügt es über einen integrierten HTTP-Server.

Eine schnelle und einfache Anwendung auf Bottle sieht wie folgt aus:

1
2
3
4
5
6
7

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)

Weitere Informationen finden Sie im repository Bottle auf GitHub. In der offiziellen Dokumentation finden Sie eine Schnellstart-Anleitung, Konfigurationsdetails und eine Sammlung nützlicher Artikel.

Hug

Site: https://www.hug.rest/

Type: Mikro-framework

hug ist eigentlich ein API-Framework mit mehreren Schnittstellen. Es bietet eine großartige Möglichkeit zur Erstellung von REST-APIs, indem es die Geschäftslogik der API von der Schnittstelle selbst trennt und Versionsabhängigkeiten zuordnet.

Da hug sich auf die Erstellung von APIs konzentriert, sind seine Fähigkeiten strikt auf I/O-Verarbeitung, Routing und Typ-Annotationen beschränkt. Es unterstützt jedoch die Möglichkeit, Erweiterungen hinzuzufügen.

Eine der interessanten Funktionen von hug ist die Möglichkeit, API-Logik über CLI, HTTP oder eine lokale Funktion bereitzustellen, so dass Sie hug wie ein Standard-Python-Modul verwenden können.

Hier erfahren Sie, wie Sie eine API in hug schreiben:

1
2
3
4
5
6

import hug

@hug.get('/happy_birthday')
def happy_birthday(name, age:hug.types.number=1):
    """Says happy birthday to a user"""
    return "Happy {age} Birthday {name}!".format(**locals())

👉 Beachten Sie, dass es bei der Verwendung von hug ein Problem geben kann, wenn Sie die empfangenen Anfragen vorverarbeiten müssen. Da der Anfragekörper an den Thread übergeben wird, können Sie ihn nur einmal lesen.

Wenn Sie also den Anfragekörper in einer Methode lesen, die Anfragen vorverarbeitet, bleibt der Thread leer und hug ist nicht in der Lage, Eingabeparameter von ihm zu erhalten. Das Problem wird gelöst, indem vor dem Lesen der Parameter ein zusätzlicher Thread erstellt wird.

Weitere Informationen finden Sie im hug repository auf GitHub sowie in der hug official documentation.

Eve

Site: https://python-eve.org/

Type: Mikro-framework

Eve ist ein Mikroframework für APIs, das auf Flask aufbaut. Das Ziel von Eve ist es, die Entwicklung von REST-APIs extrem schnell und einfach zu machen. Deshalb basiert es auf den Prinzipien von Flask und lässt alle Komponenten von Flask-Webanwendungen beiseite.

Eve unterstützt die am häufigsten verwendeten REST-API-Vorlagen, wie CRUD-Operationen, anpassbare API-Endpunkte, Filterung, Sortierung, mehrseitige, JSON/XML/JSONP-Formate.

Es unterstützt auch erweiterte Funktionen wie Authentifizierung, CORS, Caching, Ratenbegrenzung und mehr. Eve unterstützt auch die Integration mit MongoDB- und SQL-Datenbanken.

Eve kann Konfigurationsdatei im Python-Format verwenden, um Ressourcen und API-Endpunkte zu definieren. So kann die REST-API mit einer deklarativen JSON-Syntax erstellt werden.

Weitere Informationen finden Sie in der Getting Eve up and running guide oder im Eve repository auf GitHub.

Full-Stack-Frameworks

Django

Site: https://www.djangoproject.com/

Type: Fullstack-framework

Django ist ein Python-Webframework mit vollem Funktionsumfang. Es ist eines der ältesten und beliebtesten Web-Frameworks. Das Django Repository hat fast 67 Tausend Sterne auf GitHub.

Das Django-Framework verfügt über eine Vielzahl von Funktionen zur Erstellung vollwertiger Webanwendungen. Es unterstützt nicht nur alle erforderlichen HTTP-Funktionen, einschließlich Middleware-Anwendungen, sondern bietet auch MVC-Muster, Datenansichten, Datenbankverarbeitung, Formulare, Vorlagen, Sicherheit, Caching und vieles mehr.

Natürlich ist es übertrieben, Django nur für die Erstellung eines REST-API-Backends zu verwenden. Deshalb können Sie für diesen Zweck ein spezielles Framework Django REST verwenden, das von der Community unterstützt wird. Es verwendet Django als Basis-Engine und bietet eine einfachere Schnittstelle speziell für die Entwicklung von REST-APIs.

Im offiziellen Django Repository und/oder im offiziellen Django REST Repository finden Sie weitere Informationen zur Arbeit mit diesen Projekten. Und unter diesem Link finden Sie den Django REST Quick Start Guide.

TurboGears

Site: https://turbogears.org/

Type: Fullstack-framework

TurboGears ist ein weiteres Full-Stack-Framework. Die Hauptidee bei der Entwicklung war, die Skalierbarkeit des Projekts von einer einfachen Anwendung (in einer einzigen Datei) zu einer Full-Stack-Anwendung zu ermöglichen. Auf diese Weise kann TurboGears das Gefühl vermitteln, mit einem Microframe zu arbeiten, bietet aber auch alle Tools, die Sie zur Entwicklung einer vollwertigen Webanwendung benötigen.

TurboGears ist wie andere vollwertige Frameworks nach dem MVC-Schema (Model-View-Controller) aufgebaut. Es unterstützt Vorlagen, Seitenverwaltung, Authentifizierung und Autorisierung, Caching und Unterstützung für verschiedene Datenbanken und Schemamigration.

Die einfachste Version ist sehr einfach erstellt. Erstellen Sie eine Datei tgapp.py und deklarieren Sie darin einen Controller:

1
2
3
4
5
6
7
8

class RootController(TGController):
    @expose()
    def index(self):
        return 'Hello World'

    @expose()
    def hello(self, person):
        return 'Hello %s' % person

Damit der Controller funktioniert, müssen Sie eine Anwendung erstellen:

1
2
3
4
5
6
7
8

from tg import MinimalApplicationConfigurator

config = MinimalApplicationConfigurator()
config.update_blueprint({
    'root_controller': RootController()
})

application = config.make_wsgi_app()

Geben Sie schließlich den Befehl zur Ausführung dieser Anwendung ein:

1
2
3
4
5

from wsgiref.simple_server import make_server

print("Serving on port 8080...")
httpd = make_server('', 8080, application)
httpd.serve_forever()

Führen Sie dann die Anwendung mit dem Befehl python tgapp.py aus und sie wird den Server auf Port 8080 starten. Öffnen Sie Ihren Browser, geben Sie die Adresse http://localhost:8080 ein und Sie werden Ihren Text Hallo, Welt sehen.

Und wenn Sie die Abfrage http://localhost:8080/hello?person=MyName senden, sehen Sie die Antwort Hallo MeinName.

Das war’s.

Schauen Sie sich das TurboGears Repository auf GitHub an, um ein besseres Verständnis des Frameworks zu erhalten. Und um loszulegen, studieren Sie die TurgoGears-Dokumentation.

web2py

Site: http://www.web2py.com/

Type: Fullstack-framework

Web2py ist ein Open-Source-Framework, das in Python geschrieben und programmiert wurde. Sein Hauptziel ist die Entwicklung schneller, skalierbarer und sicherer datenbankgestützter Webanwendungen.

Das Herzstück von web2py sind Module für den Umgang mit HTTP und URLs. Außerdem verfügt es über einen integrierten Scheduler für die Ausführung von Hintergrundaufgaben. Darüber hinaus verfügt web2py über eine Datenbankabstraktionsschicht, die Python-Objekte auf Datenbankobjekte wie Tabellen, Abfragen und Datensätze abbildet.

Die Datenbankabstraktionsschicht arbeitet in Verbindung mit einer Reihe von Treibern, die viele gängige Datenbanken wie SQLite, MySQL, PostgreSQL, Oracle, DB2, MSSQL, MongoDB und andere unterstützen.

Außerdem bietet es umfassende Unterstützung für MVC, Formularvalidierung, Sicherheit, Zugriffskontrolle und viele andere Dienstprogramme.

web2py wird in Binärpaketen geliefert, die Sie auf Ihrem Computer ausführen und dann über die Weboberfläche Ihre Webanwendung oder Ihren Dienst erstellen.

Einen detaillierten Einblick erhalten Sie im web2py repository auf GitHub. Das Projekt verfügt auch über eine ausgezeichnete Dokumentation in verschiedenen Sprachen, sowohl offiziell als auch von der Community erstellt, mit Beispielen und Lernvideos.

Pyramid

Site: https://trypyramid.com/

Type: Fullstack-framework

Pyramid ist ein weiteres Python-Webframework mit vollem Funktionsumfang, dessen Grundidee darin besteht, klein anzufangen und bei Bedarf zu einem großen Projekt zu wachsen. Dieser Ansatz ermöglicht es Entwicklern, mit Pyramid als Mikro-Framework zu beginnen.

Darüber hinaus ist Pyramid flexibel genug, um es zu erweitern und neue Komponenten hinzuzufügen, um alle Aufgaben zu bewältigen, die für die Erstellung einer umfangreichen Webanwendung erforderlich sind.

Pyramid enthält alle Standard-Webframework-Funktionen wie MVC-Schema, Routing, Vorlagen, Sicherheit, Sitzungen, Datenbanken und Protokollierung. Es hat auch einen eingebauten Webserver namens pserve, arbeitet aber für ernsthafte Anwendungen nahtlos mit Apache und Nginx zusammen.

Hier ist ein Beispiel für ein einfaches Backend auf Pyramid.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response

def hello_world(request):
    return Response('Hello World!')

if __name__ == '__main__':
    with Configurator() as config:
        config.add_route('hello', '/')
        config.add_view(hello_world, route_name='hello')
        app = config.make_wsgi_app()
    server = make_server('0.0.0.0', 6543, app)
    server.serve_forever()

Wie in früheren Fällen empfehle ich Ihnen, das Pyramid Repository auf GitHub, die Pyramid Schnellstartanleitung und die offizielle Pyramid Dokumentation zu lesen.

Fazit

Der Artikel ist recht lang und Sie müssen verstehen, dass es sich nur um einen kurzen Überblick über einige der beliebtesten Lösungen für die Entwicklung Ihrer API handelt. Sie können sich jederzeit ausführlichere Informationen ansehen und das Produkt auswählen, das Ihnen am besten gefällt, um Ihr eigenes Projekt zu erstellen.

Und ich gebe Ihnen noch einen weiteren Link, den Sie sich ansehen sollten. Es handelt sich um einen Performance-Vergleich vieler Frameworks für Webanwendungen, die grundlegende Aufgaben wie JSON-Serialisierung, Datenbankzugriff und serverseitige Vorlagenverarbeitung übernehmen.

Jedes Framework wird in einer realistischen Konfiguration ausgeführt. Die Ergebnisse werden auf Cloud-Instanzen und auf physischer Hardware erzielt. Die Testimplementierungen wurden größtenteils von der Community erstellt, und der gesamte Quellcode ist auf repository GitHub verfügbar.

Im nächsten Teil sehen wir uns ein praktisches Beispiel dafür an, wie Sie Ihre API schreiben und dann richtig dokumentieren.

Viel Erfolg! 👍