FastAPI Python (Wie es für Entwickler funktioniert)

Einführung

FastAPI ist ein modernes, leistungsstarkes Web-Framework zum Erstellen von APIs mit Python. Es ist so konzipiert, dass es einfach zu verwenden und zu erlernen ist, während es leistungsstarke Funktionen wie automatische Validierung, Serialisierung und automatische interaktive API-Dokumentation bietet. Darüber hinaus funktioniert es mit jeder Template-Engine und ermöglicht es Ihnen, jede Standard-Template-Konfiguration zu verwenden, die für Ihr Projekt benötigt wird.

Lasst uns in die Details von FastAPI, seine Funktionen und die effektive Nutzung eintauchen. Später in diesem Artikel werden wir uns auch IronPDF ansehen, ein PDF-Generierungspaket für Python von Iron Software.

Hauptmerkmale von FastAPI

1. Hohe Leistung: FastAPI ist eines der schnellsten verfügbaren Python-Frameworks, vergleichbar mit Node.js und Go, dank der Verwendung von Starlette für die Webteile und Pydantic für die Datenteile.

2. Benutzerfreundlichkeit: Es ist darauf ausgelegt, intuitiv zu sein und die Zeit für das Lesen der Dokumentation zu verkürzen. Das Framework nutzt standardmäßige Python-Typ-Hinweise für Datenvalidierung und Serialisierung.

3. Automatische interaktive Dokumentation: FastAPI generiert automatisch interaktive API-Dokumentation mithilfe von OpenAPI und JSON Schema, zugänglich über /docs (Swagger UI) und /redoc (ReDoc), und das Upgrade der interaktiven API-Dokumentation bedeutet, dass sich diese Dokumentation automatisch aktualisiert. Das alternative API-Dokumentations-Upgrade wird dies ebenfalls widerspiegeln.

4. Editor-Support: Hervorragende Unterstützung für die Codevervollständigung und Typüberprüfung in Editoren wie VS Code, was die Entwicklung beschleunigt und Fehler reduziert.

5. Standardsbasiert: Es basiert auf den offengelegten Standards für APIs und ist vollständig kompatibel mit diesen: OpenAPI und JSON Schema.

Einrichtung

Sie können FastAPI und Uvicorn (einen ASGI-Server) mit pip installieren:

pip install fastapi
pip install "uvicorn[standard]"

pip install fastapi
pip install "uvicorn[standard]"

Erstellen Ihrer ersten FastAPI-Anwendung

Hier ist ein einfaches Beispiel, um Sie mit FastAPI zu beginnen und Python-Daten über eine Benutzeroberfläche bereitzustellen:

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

py

Um die Anwendung auszuführen, verwenden Sie Uvicorn:

uvicorn main:app --reload

py

Dieser Befehl startet einen Entwicklungsserver und lädt automatisch bei Codeänderungen neu. Sie können auf die interaktive API-Dokumentation unter http://127.0.0.1:8000/docs zugreifen.

Erweiterte Funktionen

FastAPI unterstützt eine Vielzahl fortschrittlicher Funktionen und eignet sich daher für komplexe Anwendungen:

1. Dependency Injection: FastAPI stellt ein leistungsstarkes Abhängigkeitsinjektionssystem bereit, mit dem Sie Abhängigkeiten sauber und effizient verwalten können.

2. Hintergrundaufgaben: Sie können Hintergrundaufgaben definieren, die nach der Rückgabe einer Antwort ausgeführt werden, was nützlich für Aufgaben wie das Senden von E-Mails oder die Datenverarbeitung ist.

3. WebSockets: FastAPI unterstützt WebSockets und ermöglicht dadurch die Echtzeitkommunikation zwischen dem Client und dem Server.

4. Sicherheit: FastAPI enthält Tools zur Handhabung von Sicherheit, einschließlich OAuth2, JWT-Tokens und mehr.

5. Datenbankintegration: FastAPI kann einfach mit Datenbanken integriert werden, indem Bibliotheken wie SQLAlchemy oder Tortoise-ORM verwendet werden.

Beispiel: Erstellen einer CRUD-API

Lassen Sie uns eine einfache CRUD-API (Create, Read, Update, Delete) zum Verwalten von Objekten erstellen.

1. Definieren Sie das Datenmodell:

from pydantic import BaseModel
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

py

1. Erstellen Sie die FastAPI-Anwendung:

from fastapi import FastAPI, HTTPException
app = FastAPI()
items = {}
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item
@app.get("/items/{item_id}") # optional str query parameter
def read_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[item_id]
@app.put("/items/{item_id}") # with path parameters
def update_item(item_id: int, item: Item):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[item_id] = item
    return item
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[item_id]
    return {"message": "Item deleted"}

py

Einführung in IronPDF

IronPDF ist eine leistungsstarke Python-Bibliothek, die für das Erstellen, Bearbeiten und Signieren von PDFs aus HTML, CSS, Bildern und JavaScript entwickelt wurde. Sie bietet kommerzielle Leistung bei geringem Speicherbedarf. Die wichtigsten Merkmale sind:

Konvertierung von HTML in PDF

Konvertieren Sie HTML-Dateien, HTML-Strings und URLs in PDFs. Sie können zum Beispiel eine Webseite mit dem Chrome PDF-Renderer als PDF wiedergeben.

Plattformübergreifende Unterstützung

Kompatibel mit verschiedenen .NET-Plattformen, einschließlich .NET Core, .NET Standard und .NET-Framework. Es unterstützt Windows, Linux und macOS.

Bearbeitung und Unterzeichnung

Legen Sie Eigenschaften fest, fügen Sie Sicherheit mit Passwörtern und Berechtigungen hinzu, und wenden Sie digitale Signaturen auf Ihre PDFs an.

Seitenvorlagen und Einstellungen

PDFs mit Kopf- und Fußzeilen, Seitenzahlen und einstellbaren Rändern anpassen. Unterstützt responsive Layouts und benutzerdefinierte Papierformate.

Einhaltung von Normen

Einhaltung von PDF-Standards wie PDF/A und PDF/UA. Unterstützt UTF-8-Zeichencodierung und verarbeitet Assets wie Bilder, CSS und Schriftarten.

Generieren Sie PDF-Dokumente mit IronPDF und FastAPI

pip install fastapi
pip install ironPDF

pip install fastapi
pip install ironPDF

from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"
app = FastAPI()
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}
@app.get("/items/{item_id}") # with query parameters
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}
@app.get("/pdf")
async def get_pdf(greet1: str = None,greet2: str = None):
    renderer = ChromePdfRenderer()
# Create a PDF from a HTML string using Python
    content = "<h1>Document Generated using IronPDF with fastapi GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs"+"</p>"
    content += "<p>"+f"Greetings from: {greet1}"+"</p>"
    content += "<p>"+f"And Greetings from: {greet2}"+"</p>"
    pdf = renderer.RenderHtmlAsPdf(content)
    # Export to a file or Stream
    pdf.SaveAs("fastapi.pdf") 
    # To view the file in the browser, use "inline" for the media_type
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }  
    # Create a FileResponse object with the file path, media type and headers
    response = FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)
    # Return the FileResponse object
    return response

py

Code Erläuterung

Dieses Code-Snippet zeigt die Integration von IronPDF mit FastAPI, um dynamisch PDF-Dokumente basierend auf Benutzereingaben zu erzeugen und sie als herunterladbare Antwort bereitzustellen.

1. Festlegen des Lizenzschlüssels: Wendet den IronPDF-Lizenzschlüssel an, um seine Funktionen freizuschalten.

2. FastAPI-Initialisierung: Initialisiert eine FastAPI-Instanz (app), um HTTP-Anfragen zu bearbeiten.3. Einfache Routen-Handler: read_root(): Antwortet mit einer einfachen JSON-Nachricht, die "Hello IronPDF" anzeigt, wenn die Root-URL (/) aufgerufen wird. `read_item()`: Akzeptiert einen `item_id` Pfadparameter und einen optionalen `q` Abfrageparameter. Gibt eine JSON-Antwort mit diesen Funktionsparametern zurück.

3. PDF-Erstellungsroute (`/pdf`): `get_pdf()`:

   • Diese asynchrone Funktion verarbeitet GET-Anfragen an den `/pdf`-Endpunkt mit optionalen Abfrageparametern namens (`greet1` und `greet2`).
   • Konstruiert einen HTML-String (`content`), der Folgendes enthält: Eine Kopfzeile, die den Ursprung und Zweck des Dokuments angibt. Ein Absatz, der die PDF-Erstellung unter Verwendung von Benutzereingaben (greet1 und greet2) demonstriert. Verwendet `ChromePdfRenderer()` von IronPDF, um den HTML-Inhalt in ein PDF zu rendern (`pdf = renderer.RenderHtmlAsPdf(content)`).
   • Speichert das generierte PDF als "fastapi.pdf" (pdf.SaveAs("fastapi.pdf")).5. Bereitstellung des PDFs:
   • Konfiguriert Antwort-Header, um anzugeben, dass das PDF inline im Browser angezeigt werden soll (`"Content-Disposition": "inline; filename=sample.pdf"`).
   • Erstellt ein `FileResponse`-Objekt, das auf die generierte PDF-Datei mit dem entsprechenden Medientyp (`"application/pdf"`) verweist.
   • Gibt das `FileResponse`-Objekt zurück, das den Download des PDF-Dokuments auslöst, wenn der `/pdf`-Endpunkt aufgerufen wird.

   Dieses Codebeispiel zeigt, wie IronPDF nahtlos mit FastAPI integriert werden kann, um PDF-Dokumente basierend auf Benutzereingaben dynamisch zu generieren und bereitzustellen. Es zeigt die Fähigkeit, HTML-Inhalte in PDFs zu konvertieren, was es für Anwendungen geeignet macht, die eine sofortige Dokumentenerstellung und -lieferung über HTTP erfordern.

Ausgabe

Nachfolgend wird die Swagger-Ausgabe angezeigt, die von den APIs generiert wurde.

PDF

IronPDF-Lizenz

IronPDF verwendet den Lizenzschlüssel für Python. IronPDF for Python bietet einen kostenlosen Testlizenzschlüssel an, damit Benutzer die Funktionen vor dem Kauf ausprobieren können.

Platzieren Sie den Lizenzschlüssel am Anfang des Skripts, bevor Sie das IronPDF-Paket verwenden:

from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"

py

Schlussfolgerung

FastAPI ist ein leistungsstarkes und benutzerfreundliches Framework zur Erstellung von APIs in Python. FastAPI bietet hohe Leistung, automatische Dokumentation und erweiterte Funktionen, was es zu einer ausgezeichneten Wahl für sowohl Anfänger als auch erfahrene Entwickler macht. Egal, ob Sie eine einfache API oder eine komplexe Webanwendung erstellen, FastAPI bietet Ihnen die Werkzeuge, die Sie für den Erfolg benötigen.

IronPDF ist eine robuste Python-Bibliothek zur Erstellung, Bearbeitung und Darstellung von PDF-Dokumenten aus HTML-Inhalten. Es bietet Funktionen wie die HTML-zu-PDF-Konvertierung, die Erstellung interaktiver Formulare, die PDF-Bearbeitung (Zusammenführen, Aufteilen) und die Textextraktion. Ideal zur einfachen Erstellung dynamischer PDFs und Integration in verschiedene Python-Anwendungen.