FastAPI Python (Wie es für Entwickler funktioniert)

Einführung

FastAPIist ein modernes, leistungsstarkes Web-Framework zur Erstellung 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.

Tauchen wir in die Details ein von FastAPI, seine Funktionen und wie man es effektiv nutzt. Später in diesem Artikel werden wir uns auch mit folgenden Themen befassenIronPDFein PDF-Erstellungs-Python-Paket von Iron Software.

Hauptmerkmale von FastAPI

1. Hohe Leistung: FastAPI ist eines der schnellsten verfügbaren Python-Frameworks und 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, die für das Lesen der Dokumentation aufgewendet wird, 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 unter Verwendung von OpenAPI und JSON Schema, zugänglich über /docs(Swagger UI)und /redoc(ReDoc)und interaktive API-Dokumentationsaktualisierung bedeutet, dass diese Dokumentation automatisch aktualisiert wird. Das alternative API-Dokumentations-Upgrade wird dies ebenfalls widerspiegeln.

4. Editorunterstützung: Hervorragende Unterstützung für Codevervollständigung und Typüberprüfung in Editoren wie VS Code, wodurch die Entwicklung schneller wird und Fehler reduziert werden.

5. Standardsbasiert: Es basiert auf(und vollständig kompatibel mit)die offenen Standards für APIs: OpenAPI und JSON Schema.

Einrichtung

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

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}

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}

Um die Anwendung auszuführen, verwenden Sie Uvicorn:

uvicorn main:app --reload

uvicorn main:app --reload

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 Dependency-Injection-System bereit, das Ihnen ermöglicht, Abhängigkeiten sauber und effizient zu verwalten.

2. Hintergrundaufgaben: Sie können Hintergrundaufgaben definieren, die nach der Rückgabe einer Antwort ausgeführt werden sollen, 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 die Echtzeitkommunikation zwischen Client und Server.

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

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

Beispiel: Erstellen einer CRUD-API

Lassen Sie uns ein einfaches CRUD erstellen(Erstellen, Lesen, Aktualisieren, Löschen)API zur Verwaltung von Elementen.

1. Definieren Sie das Datenmodell:

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

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

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"}

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"}

Einführung in IronPDF

IronPDFist eine leistungsstarke Python-Bibliothek, die zum 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

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

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

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. Lizenzschlüssel festlegen: Wendet den IronPDF-Lizenzschlüssel an, um seine Funktionen zu aktivieren.

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

2. Einfache Routen-Handler: `read_root()`: Antwortet mit einer einfachen JSON-Nachricht, die "Hello IronPDF" angibt, wenn auf die Stamm-URL zugegriffen wird.(/). `read_item()`: Akzeptiert einen `item_id`-Pfadparameter und einen optionalen `q`-Abfrageparameter. Gibt eine JSON-Antwort mit diesen Funktionsparametern zurück.

3. **PDF-Generierungsroute(/pdf):`get_pdf()It seems that your input might be incomplete. Could you please provide the rest of the content you want translated?

   • Diese asynchrone Funktion bearbeitet GET-Anfragen an den Endpunkt /pdf mit optionalem Abfrageparameter namens(greet1 und greet2).
   • Konstruiert eine HTML-Zeichenkette(\"Inhalt)die Folgendes umfasst: Eine Kopfzeile, die den Ursprung und Zweck des Dokuments angibt. Ein Absatz, der die PDF-Erstellung unter Verwendung von Benutzereingaben demonstriert(greet1 und greet2). Verwendet `ChromePdfRenderer()` von IronPDF, um den HTML-Inhalt in ein PDF zu rendern(`pdf = renderer.RenderHtmlAsPdf(inhalt)`).
   • Speichert das generierte PDF als "fastapi.pdf" ab.(`pdf.SaveAs("fastapi.pdf")`).5. Bereitstellung des PDF:
   • Konfiguriert die Antwort-Header so, dass das PDF im Browser inline angezeigt werden soll.(`"Content-Disposition": "inline; filename=sample.pdf"`).
   • Erstellt ein `FileResponse`-Objekt, das auf die generierte PDF-Datei mit dem entsprechenden Medientyp verweist.(`"application/pdf"`).
   • 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 läuft mit dem Lizenzschlüssel für Python. IronPDF for Python bietet einekostenloser TestLizenzschlüssel, damit Benutzer 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"

Schlussfolgerung

FastAPIist ein leistungsstarkes und benutzerfreundliches Framework zum Erstellen 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.

IronPDFist eine robuste Python-Bibliothek zur Erstellung, Bearbeitung und Darstellung von PDF-Dokumenten aus HTML-Inhalten. Es bietet Funktionen wie die Umwandlung von HTML in PDF, interaktive Formularerstellung, PDF-Manipulation.(zusammenführen, Aufteilen), und Textextraktion. Ideal zur einfachen Erstellung dynamischer PDFs und Integration in verschiedene Python-Anwendungen.