Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF for Python
  2. IronPDF für Python Blog
  3. Produktvergleiche
  4. FastAPI Python
PRODUKTVERGLEICHE

FastAPI Python (Wie es für Entwickler funktioniert)

Curtis Chau
Curtis Chau
Aktualisiert:

FastAPI ist ein modernes, leistungsstarkes Web-Framework für die Erstellung von APIs mit Python. Die Software ist so konzipiert, dass sie einfach zu bedienen und zu erlernen ist und gleichzeitig leistungsstarke Funktionen wie automatische Validierung, Serialisierung und automatische interaktive API-Dokumentation bietet. Darüber hinaus funktioniert sie mit jeder Template-Engine und erlaubt Ihnen, jede für Ihr Projekt benötigte Standard-Template-Konfiguration zu verwenden.

Lassen Sie uns in die Details der FastAPI eintauchen, ihre Funktionen und ihre effektive Nutzung. Later in this article, we will also look into IronPDF, a PDF generation Python package from Iron Software.

Schlüsselmerkmale 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: Sie soll intuitiv sein und den Zeitaufwand für das Lesen der Dokumentation reduzieren. Das Framework nutzt Standard-Hinweise vom Typ Python für die Datenvalidierung und Serialisierung.
  3. Automatische interaktive Dokumentation: FastAPI generiert automatisch interaktive API-Dokumentation unter Verwendung von OpenAPI und JSON Schema, die über /docs (Swagger UI) und /redoc (ReDoc) zugänglich ist. Alle Aktualisierungen der API werden automatisch in der Dokumentation berücksichtigt.
  4. Editor-Unterstützung: Hervorragende Unterstützung für Code-Vervollständigung und Typüberprüfung in Editoren wie VS Code, was die Entwicklung beschleunigt und Fehler reduziert.
  5. Standardbasiert: Sie basiert auf (und ist vollständig kompatibel mit) den offenen Standards für APIs: OpenAPI und JSON Schema.

Installation

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

pip install fastapi
pip install "uvicorn[standard]"
pip install fastapi
pip install "uvicorn[standard]"
SHELL

Erstellung Ihrer ersten FastAPI-Anwendung

Hier ist ein einfaches Beispiel für den Einstieg in FastAPI und die Darstellung von Python-Daten über eine Benutzeroberfläche:

from fastapi import FastAPI

# Create a FastAPI 'app' instance
app = FastAPI()

# Root path operation
@app.get("/")
def read_root():
    return {"Hello": "World"}

# Path operation for items including query parameter 'q'
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}
from fastapi import FastAPI

# Create a FastAPI 'app' instance
app = FastAPI()

# Root path operation
@app.get("/")
def read_root():
    return {"Hello": "World"}

# Path operation for items including query parameter 'q'
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}
PYTHON

Um die Anwendung auszuführen, verwenden Sie Uvicorn:

uvicorn main:app --reload
uvicorn main:app --reload
SHELL

Mit diesem Befehl wird ein Entwicklungsserver gestartet und bei Codeänderungen automatisch neu geladen. Sie können die interaktive API-Dokumentation unter http://127.0.0.1:8000/docs aufrufen.

Erweiterte Funktionen

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

  1. Abhängigkeitsinjektion: FastAPI bietet ein leistungsstarkes Dependency Injection System, 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, nützlich für Aufgaben wie das Senden von E-Mails oder die Verarbeitung von Daten.
  3. WebSockets: FastAPI unterstützt WebSockets, die eine Echtzeitkommunikation zwischen Client und Server ermöglichen.
  4. Sicherheit: FastAPI enthält Tools für den Umgang mit Sicherheit, einschließlich OAuth2, JWT-Tokens und mehr.
  5. Datenbank-Integration: FastAPI kann mit Hilfe von Bibliotheken wie SQLAlchemy oder Tortoise-ORM leicht in Datenbanken integriert werden.

Beispiel: Erstellen einer CRUD-API

Lassen Sie uns eine einfache CRUD-API (Create, Read, Update, Delete) für die Verwaltung von Elementen erstellen.

  1. Bestimmen Sie das Datenmodell:
from pydantic import BaseModel

# Define a Pydantic model for the item with default description and tax
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None
from pydantic import BaseModel

# Define a Pydantic model for the item with default description and tax
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None
PYTHON
  1. Erstellen Sie die FastAPI-Anwendung:
from fastapi import FastAPI, HTTPException

# Initialize 'app' instance and an empty 'items' dictionary
app = FastAPI()
items = {}

# Create operation: Add a new item
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item

# Read operation: Retrieve an item by 'item_id'
@app.get("/items/{item_id}")
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]

# Update operation: Replace an existing item
@app.put("/items/{item_id}")
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

# Delete operation: Remove an item by 'item_id'
@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"}
from fastapi import FastAPI, HTTPException

# Initialize 'app' instance and an empty 'items' dictionary
app = FastAPI()
items = {}

# Create operation: Add a new item
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item

# Read operation: Retrieve an item by 'item_id'
@app.get("/items/{item_id}")
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]

# Update operation: Replace an existing item
@app.put("/items/{item_id}")
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

# Delete operation: Remove an item by 'item_id'
@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"}
PYTHON

Einführung in IronPDF

FastAPI Python (How It Works For Developers): Abbildung 1

IronPDF ist eine leistungsstarke Python-Bibliothek zum Erstellen, Bearbeiten und Signieren von PDFs aus HTML, CSS, Bildern und JavaScript. Sie bietet eine kommerzielle Leistung mit geringem Speicherbedarf. Hauptmerkmale sind:

HTML zu PDF Konvertierung

Konvertieren Sie HTML-Dateien, HTML-Zeichenketten und URLs in PDFs. Beispielsweise eine Webseite mithilfe des Chrome-PDF-Renderers als PDF rendern.

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.

Bearbeiten und Signieren

Eigenschaften festlegen, Sicherheit mit Passwörtern und Berechtigungen hinzufügen und digitale Signaturen auf Ihre PDFs anwenden.

Seitenvorlagen und Einstellungen

Passen Sie PDFs mit Kopf- und Fußzeilen, Seitenzahlen und einstellbaren Rändern an. Unterstützt responsive Layouts und benutzerdefinierte Papiergrößen.

Einhaltung von Normen

Hält sich an PDF-Standards wie PDF/A und PDF/UA. Unterstützt UTF-8-Zeichenkodierung und verarbeitet Assets wie Bilder, CSS und Schriftarten.

Erzeugen von PDF-Dokumenten mit IronPDF und FastAPI

pip install fastapi
pip install ironPDF
pip install fastapi
pip install ironPDF
SHELL 
from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import *

# Apply your IronPDF license key
License.LicenseKey = "key"

# Initialize 'app' instance
app = FastAPI()

# Route for simple greeting
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}

# Route that reads items with path and query parameters
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# Route for generating a PDF document
@app.get("/pdf")
async def get_pdf(greet1: str = None, greet2: str = None):
    # Use ChromePdfRenderer to create PDF from HTML
    renderer = ChromePdfRenderer()
    content = "<h1>Document Generated using IronPDF with FastAPI GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs</p>"
    content += f"<p>Greetings from: {greet1}</p>"
    content += f"<p>And Greetings from: {greet2}</p>"
    pdf = renderer.RenderHtmlAsPdf(content)

    # Save the PDF to a file
    pdf.SaveAs("fastapi.pdf")

    # Create a response with the generated PDF
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }
    return FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)
from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import *

# Apply your IronPDF license key
License.LicenseKey = "key"

# Initialize 'app' instance
app = FastAPI()

# Route for simple greeting
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}

# Route that reads items with path and query parameters
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# Route for generating a PDF document
@app.get("/pdf")
async def get_pdf(greet1: str = None, greet2: str = None):
    # Use ChromePdfRenderer to create PDF from HTML
    renderer = ChromePdfRenderer()
    content = "<h1>Document Generated using IronPDF with FastAPI GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs</p>"
    content += f"<p>Greetings from: {greet1}</p>"
    content += f"<p>And Greetings from: {greet2}</p>"
    pdf = renderer.RenderHtmlAsPdf(content)

    # Save the PDF to a file
    pdf.SaveAs("fastapi.pdf")

    # Create a response with the generated PDF
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }
    return FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)
PYTHON

Code-Erläuterung

Dieser Codeschnipsel demonstriert die Integration von IronPDF mit FastAPI, um dynamisch PDF-Dokumente auf der Grundlage von Benutzereingaben zu generieren und sie als herunterladbare Antwort zu liefern.

  1. Lizenzschlüssel festlegen: Wendet den IronPDF-Lizenzschlüssel an, um die Funktionen zu aktivieren.

  2. FastAPI-Initialisierung: Initialisiert eine FastAPI-Instanz (app) zur Bearbeitung von HTTP-Anfragen.

  3. Basic Route Handler:

    • read_root(): Antwortet mit einer einfachen JSON-Meldung mit der Angabe "Hallo IronPDF" beim Zugriff auf die Stamm-URL (/).
    • read_item(): Akzeptiert einen item_id Pfadparameter und einen optionalen q Abfrageparameter. Gibt eine JSON-Antwort mit diesen Parametern zurück.

  4. PDF-Erzeugungsweg (/pdf):

    • get_pdf(): Diese asynchrone Funktion verarbeitet GET-Anfragen an den Endpunkt /pdf mit optionalen Abfrageparametern namens greet1 und greet2.
    • Konstruiert eine HTML-Zeichenkette (Inhalt), die Folgendes enthält:
      • Eine Kopfzeile, die den Ursprung und den Zweck des Dokuments angibt.
      • Ein Absatz zur Demonstration der PDF-Erzeugung anhand von Benutzereingaben (greet1 und greet2).
    • Verwendet ChromePdfRenderer() von IronPDF, um den HTML-Inhalt in ein PDF zu rendern (pdf = renderer.RenderHtmlAsPdf(content)).
    • Speichert das erzeugte PDF als "fastapi.pdf" (pdf.SaveAs("fastapi.pdf")).
  5. Die PDF-Datei bedienen:
    • Konfiguriert die Antwort-Header, um anzugeben, dass die PDF-Datei im Browser inline angezeigt werden soll ("Content-Disposition": "inline; filename=sample.pdf").
    • Erzeugt 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 auf den Endpunkt /pdf zugegriffen wird.

Dieser Codeschnipsel veranschaulicht, wie IronPDF nahtlos in FastAPI integriert werden kann, um dynamisch PDF-Dokumente auf der Grundlage von Benutzereingaben zu generieren und bereitzustellen. Sie zeigt die Fähigkeit, HTML-Inhalte in PDFs zu konvertieren, und eignet sich damit für Anwendungen, die eine sofortige Dokumentenerstellung und -bereitstellung über HTTP erfordern.

Ausgabe

Nachfolgend sehen Sie die aus den APIs generierte Swagger-Ausgabe

FastAPI Python (How It Works For Developers): Abbildung 2

PDF

FastAPI Python (How It Works For Developers): Abbildung 3

IronPDF Lizenz

IronPDF läuft mit dem Lizenzschlüssel für Python. IronPDF for Python bietet einen kostenlosen Testlizenzschlüssel, damit die Benutzer die Funktionen vor dem Kauf testen können.

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

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

Abschluss

FastAPI ist ein leistungsstarkes und benutzerfreundliches Framework zur Erstellung von APIs in Python. FastAPI verfügt über eine hohe Leistung, eine automatische Dokumentation und fortgeschrittene Funktionen, die es sowohl für Anfänger als auch für erfahrene Entwickler zu einer ausgezeichneten Wahl machen. Ganz gleich, ob Sie eine einfache API oder eine komplexe Webanwendung entwickeln, FastAPI bietet Ihnen die Werkzeuge, die Sie für Ihren Erfolg benötigen.

IronPDF ist eine robuste Python-Bibliothek zum Erstellen, Bearbeiten und Rendern von PDF-Dokumenten aus HTML-Inhalten. Es bietet Funktionen wie die Konvertierung von HTML in PDF, die Erstellung interaktiver Formulare, die Bearbeitung von PDF-Dateien (Zusammenführen, Aufteilen) und die Textextraktion. Ideal für die einfache Erstellung dynamischer PDFs und die Integration in verschiedene Python-Anwendungen.

Häufig gestellte Fragen

Wie kann ich HTML-Inhalte in einer Python-Anwendung in ein PDF konvertieren?

Sie können IronPDF's ChromePdfRenderer verwenden, um HTML-, CSS- und JavaScript-Inhalte in eine PDF-Datei zu konvertieren. Dies ermöglicht eine nahtlose Integration in Python-Anwendungen zur Erstellung von PDF-Dokumenten aus Webinhalten.

Was sind die Vorteile der Verwendung von FastAPI zur Erstellung von APIs?

FastAPI bietet hohe Leistung, automatische Validierung, Serialisierung und interaktive API-Dokumentation. Es nutzt Starlette und Pydantic, um Geschwindigkeit und Effizienz zu gewährleisten, vergleichbar mit Node.js und Go, und unterstützt gleichzeitig offene Standards wie OpenAPI.

Wie kann ich ein PDF-Dokument in FastAPI bereitstellen?

Sie können ein PDF-Dokument in FastAPI bereitstellen, indem Sie es mit IronPDF erzeugen und mit FastAPIs FileResponse zurückgeben. Dieser Ansatz ermöglicht es Ihnen, dynamisch PDFs zu erstellen und bereitzustellen, basierend auf Anfragen der Kunden.

Was macht FastAPI für Echtzeitanwendungen geeignet?

FastAPI unterstützt WebSockets, die eine Echtzeit-Kommunikation zwischen dem Client und dem Server ermöglichen, was es zu einer idealen Wahl für Anwendungen macht, die sofortige Datenaktualisierungen oder Live-Interaktionen erfordern.

Wie handhabt FastAPI Datenvalidierung und Serialisierung?

FastAPI verwendet Pydantic-Modelle und standardmäßige Python-Typen-Hinweise zur Handhabung von Datenvalidierung und Serialisierung. Dies stellt sicher, dass Eingabedaten korrekt validiert und in das gewünschte Format konvertiert werden, wodurch die Fehlerwahrscheinlichkeit reduziert wird.

Welche Sicherheitsfunktionen bietet FastAPI?

FastAPI bietet robuste Sicherheitsmerkmale, einschließlich OAuth2, JWT-Authentifizierung und Dependency Injection, wodurch Entwickler sichere Anwendungen mit minimalem Aufwand erstellen können.

Kann IronPDF in plattformübergreifenden Anwendungen verwendet werden?

Ja, IronPDF ist so konzipiert, dass es plattformübergreifend ist und Windows, Linux und macOS unterstützt. Dies macht es zu einer vielseitigen Wahl für Entwickler, die PDF-Generierung in Anwendungen integrieren möchten, die auf verschiedenen Betriebssystemen laufen.

Wie verbessert FastAPI die Produktivität von Entwicklern?

FastAPI verbessert die Produktivität von Entwicklern, indem es automatische API-Dokumentation, Codevervollständigung und Typprüfung bietet. Dies reduziert die Notwendigkeit umfangreicher manueller Dokumentation und hilft dabei, Fehler früh im Entwicklungsprozess zu erkennen.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Testversion