Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF for Python
  2. Blog zu IronPDF for Python
  3. Produktvergleich
  4. FastAPI mit Python
PRODUKTVERGLEICHE

FastAPI Python (Wie es für Entwickler funktioniert)

Curtis Chau
Curtis Chau
Aktualisiert:

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

Lassen Sie uns in die Details von FastAPI eintauchen, seine Funktionen und wie man es effektiv nutzt. Später in diesem Artikel werden wir uns auch IronPDF ansehen, ein PDF-Generierungs-Python-Paket 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 so gestaltet, dass es intuitiv ist und die Zeit für das Lesen der Dokumentation reduziert. Das Framework nutzt standardmäßige Python-Typ-Hinweise für die 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). Alle Aktualisierungen der API werden automatisch in der Dokumentation reflektiert.
  4. Editor-Unterstützung: Hervorragende Unterstützung für die Codevervollständigung und Typüberprüfung in Editoren wie VS Code, was die Entwicklung schneller und fehlerfreier macht.
  5. Standardbasiert: Es basiert auf den offenen Standards für APIs: OpenAPI und JSON Schema und ist vollständig kompatibel damit.

Installation

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]"
SHELL

Erstellen Ihrer ersten FastAPI-Anwendung

Hier ein einfaches Beispiel, um Ihnen den Einstieg mit FastAPI zu erleichtern und Python-Daten über eine Benutzeroberfläche bereitzustellen:

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

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

Erweiterte Funktionen

FastAPI unterstützt eine Vielzahl fortschrittlicher Funktionen, die es für komplexe Anwendungen geeignet machen:

  1. Dependency Injection: FastAPI bietet ein leistungsstarkes Dependency Injection System, das Ihnen das effiziente und saubere Verwaltung von Abhängigkeiten ermöglicht.
  2. Hintergrundaufgaben: Sie können Hintergrundaufgaben definieren, die nach dem Zurückgeben einer Antwort ausgeführt werden sollen, nützlich für Aufgaben wie das Versenden von E-Mails oder die Datenverarbeitung.
  3. WebSockets: FastAPI unterstützt WebSockets, wodurch Echtzeitkommunikation zwischen Client und Server ermöglicht wird.
  4. Sicherheit: FastAPI umfasst Tools zur Handhabung von Sicherheit, einschließlich OAuth2, JWT-Token und mehr.
  5. Datenbankintegration: FastAPI kann leicht mit Datenbanken integriert werden, indem Bibliotheken wie SQLAlchemy oder Tortoise-ORM verwendet werden.

Beispiel: Aufbau einer CRUD-API

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

  1. Datenmodell definieren:
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. FastAPI-Anwendung erstellen:
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 (Wie es für Entwickler funktioniert): Abbildung 1

IronPDF ist eine leistungsstarke Python-Bibliothek, die für das Erstellen, Bearbeiten und Signieren von PDF-Dateien aus HTML, CSS, Bildern und JavaScript entwickelt wurde. Sie bietet kommerzielle Leistung bei 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.

Bearbeitung und Signierung

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

Seitentemplates und Einstellungen

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

Standardkonformität

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.

Generieren von PDF-Dokumenten mithilfe von 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-Erklärung

Dieses Codebeispiel zeigt die Integration von IronPDF mit FastAPI zur dynamischen Generierung von PDF-Dokumenten basierend auf Benutzereingaben und deren Bereitstellung als herunterladbare Antwort.

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

  2. FastAPI-Initialisierung: Initialisiert eine FastAPI-Instanz (app), um HTTP-Anfragen zu bearbeiten.

  3. Basis-Routen-Handler:

    • read_root(): Antwortet mit einer einfachen JSON-Nachricht, die beim Zugriff auf die Root-URL (/) "Hello IronPDF" anzeigt.
    • read_item(): Akzeptiert einen item_id-Pfadparameter und einen optionalen q-Abfrageparameter. Gibt eine JSON-Antwort mit diesen Parametern zurück.

  4. PDF-Generierungsroute (/pdf):

    • get_pdf(): Diese asynchrone Funktion bearbeitet GET-Anfragen an den /pdf-Endpunkt mit optionalen Abfrageparametern namens greet1 und greet2.
    • Konstruktiert einen HTML-String (content), der Folgendes enthält:
      • Eine Überschrift, die den Ursprung und Zweck des Dokuments angibt.
      • Einen Absatz, der die PDF-Generierung 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. Servieren des PDFs:
    • Konfiguriert die Antwortheader, um anzugeben, dass das PDF inline im Browser angezeigt werden soll ("Content-Disposition": "inline; filename=sample.pdf").
    • Erstellt ein FileResponse-Objekt, das auf die erzeugte 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 veranschaulicht, wie IronPDF nahtlos mit FastAPI integriert werden kann, um dynamisch PDF-Dokumente basierend auf Benutzereingaben zu generieren und bereitzustellen. Es zeigt die Fähigkeit, HTML-Inhalte in PDFs zu konvertieren, und macht es für Anwendungen geeignet, die eine dynamische Dokumentgenerierung und Bereitstellung über HTTP erfordern.

Ausgabe

Unten sehen Sie die von den APIs generierte Swagger-Ausgabe

FastAPI Python (Wie es für Entwickler funktioniert): Abbildung 2

PDF

FastAPI Python (Wie es für Entwickler funktioniert): Abbildung 3

IronPDF-Lizenz

IronPDF läuft mit dem Lizenzschlüssel für Python. IronPDF für Python bietet einen kostenlosen Testlizenz Schlüssel, 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"
from ironpdf import *
# Apply your license key
License.LicenseKey = "key"
PYTHON

Abschluss

FastAPI ist ein leistungsstarkes und benutzerfreundliches Framework zum Erstellen von APIs in Python. FastAPI hat hohe Leistung, automatische Dokumentation und fortschrittliche Funktionen, die es zu einer hervorragenden Wahl für sowohl Anfänger als auch erfahrene Entwickler machen. Egal, ob Sie eine einfache API oder eine komplexe Webanwendung aufbauen, FastAPI bietet die Werkzeuge, die Sie benötigen, um erfolgreich zu sein.

IronPDF ist eine robuste Python-Bibliothek zum Erstellen, Bearbeiten und Rendern von PDF-Dokumenten aus HTML-Inhalten. Es bietet Funktionen wie HTML-zu-PDF-Konvertierung, Erstellung interaktiver Formulare, PDF-Manipulation (Zusammenführen, Aufteilen) und Textextraktion. Ideal zum einfachen Erzeugen dynamischer PDFs und zur 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. Gratis testen