Python FastHTML: Ein Leitfaden für Anfänger mit Beispielen

Positionsargumente, die an Python-Elementfunktionen übergeben werden, werden als untergeordnete Elemente in der resultierenden HTML-Struktur dargestellt. Zum Beispiel,

Div(
	P("Hello, world!"),
	Ul(Li("one"), Li("two"))
)

wird diese HTML-Ausgabe erzeugen: 

<div>
  <p>Hello, world!</p>
  <ul>
    <li>one</li>
    <li>two</li>
  </ul>
</div>

Schlüsselwortargumente werden zu HTML-Attributen. Zum Beispiel kann der Python-Code

A("Docs", href="/docs", cls="button", hx_get="/info")

wird umgewandelt in

<a href="/docs" class="button" hx-get="/info">Docs</a>

Beachte, dass das Schlüsselwort cls dem Attribut class in HTML entspricht. Unterstriche in Attributnamen (hx_get) werden in Bindestriche (hx-get) umgewandelt. 

FastHTML verzichtet auf die Serialisierung, so dass die Routen Python-Objekte und keine HTML-Strings zurückgeben können. Das Framework wandelt den Python-Objektbaum erst im letzten Schritt, kurz vor dem Senden der Antwort, in HTML um. Dieses Design hält die Logik sauber und frei von manueller Stringmanipulation.

FastHTML bietet die Vorteile von typsicherem Templating und Attribut-Handling, was zu einem klareren und besser wartbaren Code führt. Element-APIs und Attribute erscheinen in den Funktions- oder Klassendefinitionen, sodass der Code selbsterklärend ist. Python-sichere Namen (hx-post bis hx_post) machen die manuelle Manipulation von Zeichenketten überflüssig.

Refactoring ist sicherer und zuverlässiger. Das Umbenennen eines Parameters aktualisiert die Verwendungen automatisch. Außerdem können Unit-Tests Komponentenobjekte direkt instanziieren und validieren, so dass keine Regexes gegen gerendertes HTML verwendet werden müssen.

Integration der asynchronen Server-Gateway-Schnittstelle (ASGI)

FastHTML ist mit ASGI integriert, einem von der Community entwickelten Standard für Python, der eine nicht-blockierende, ereignisgesteuerte Kommunikation zwischen Webservern und Anwendungen ermöglicht. ASGI unterstützt moderne Python-Webframeworks, indem es asynchrone Operationen im Kern des Webstacks unterstützt.

Webserver wie Uvicorn halten sich an die ASGI-Spezifikation, um Kompatibilität und Skalierbarkeit zu gewährleisten. Frameworks wie Starlette und FastHTML bauen auf ASGI auf und bieten robustes Routing, Middleware und High-Level-APIs.

Diese Architektur bietet hohe Gleichzeitigkeit, integrierte Unterstützung für HTTP, WebSocket und vom Server gesendete Ereignisse sowie eine effiziente ereignisgesteuerte Bearbeitung von Anfragen. Durch die Verwendung einer Asyncio-Ereignisschleife vermeiden ASGI-Anwendungen den Overhead eines Betriebssystem-Threads pro Verbindung, wodurch einige wenige Threads Tausende von Clients bedienen können. Das standardisierte Scope-Objekt und das Non-Blocking-Design ermöglichen es den Handlern, für I/Os zu pausieren, ohne andere Anfragen zu verlangsamen.

HTMX-gesteuerte Interaktivität

Mit der HTMX-Bibliothek kannst du Standard-HTML-Attribute mit hx-*-Attributen erweitern. Mit diesen Elementen kannst du HTTP-Anfragen senden und Seiteninhalte dynamisch durch vom Server zurückgegebene Fragmente ersetzen. Du brauchst kein eigenes JavaScript. 

Erste Schritte mit FastHTML

Der Einstieg in FastHTML ist ganz einfach. Wir haben die wichtigsten Schritte in den folgenden Abschnitten beschrieben. 

Installation und Einrichtung

Um FastHTML zu installieren, benutze pip install python-fasthtml.

Erste App

Lass uns eine einfache App bauen, die eine Überschrift und eine Nachricht anzeigt.

from fasthtml.common import FastHTML, serve, Div, H1, P

app = FastHTML()

@app.get("/")
def home():
    return Div(
        H1("Welcome to FastHTML"),
        P("Hello, world!")
    )

if __name__ == "__main__":
    serve()

Führe die Datei aus, indem du python app.py in das Terminal eingibst. 

Klicke auf den Link, um deine App zu öffnen. Du wirst eine Seite sehen:

Festlegen einer Route

Fügen wir eine Info-Seite zu unserer App hinzu. Verwende den folgenden Code:

from fasthtml.common import FastHTML, serve, Div, H1, P, A

app = FastHTML()

@app.get("/")
def home():
    return Div(
        H1("Welcome to FastHTML"),
        P("Hello, world!"),
        A("About", href="/about")
    )

@app.get("/about")
def about():
    return Div(
        H1("About"),
        P("This is the about page."),
        A("Home", href="/")
    )

if __name__ == "__main__":
    serve()

Die Zeile A("About", href="/about") erstellt einen Link von der Startseite zur Info-Seite. Der Dekorator @app.get("/about") definiert die Route für die Info-Seite.

Grundlegende Implementierung

In FastHTML werden wiederverwendbare UI-Muster in einfachen Python-Funktionen gekapselt. Diese Funktionen geben verschachtelte Komponentenobjekte zurück, so dass du Widgets wie Card oder Navbar als aufrufbare Objekte behandeln kannst. 

Die Definition von Markup, Attributen und Styling an einem Ort sorgt für Konsistenz in der gesamten Anwendung. Wenn du diese Funktionen importierst und verwendest, werden alle visuellen oder verhaltensbezogenen Änderungen automatisch übernommen. 

Dieser Ansatz reduziert wiederholten Code und macht dein Frontend so einfach zu testen und zu refaktorisieren wie jedes Python-Modul.

Um das zu demonstrieren, erstellen wir eine Seite, die zwei einfache Karten anzeigt.

from fasthtml.common import *

def Card(title: str, body: str):
    children = [
        H2(title, cls="card-title"),
        P(body, cls="card-body")
    ]
    return Div(
        *children,
        cls="card",
        style="background- border-radius: 0.5rem;"
    )

app = FastHTML()

@app.get("/")
def home():
    return Div(
        Card("Welcome", "A welcome card."),
        P(''),
        Card("A Second Card", "This is another card."),
        cls="page"
    )

Die Funktion Card nimmt einen title und einen body String als Argumente und gibt ein Kartenelement mit grundlegendem Styling zurück. In der Route home wird dieses Widget zweimal verwendet, ohne dass der Code dupliziert wird. Wir definieren die Card einmal und verwenden sie bei Bedarf wieder, um ein einheitliches Markup und Styling in der gesamten App zu gewährleisten.

Die Erstellung von UI-Widgets auf diese Weise hat mehrere Vorteile.

• Reduzierte Vervielfältigung: Lege das Markup und das Styling einmal fest und verwende die Komponente bei Bedarf wieder. Updates oder Fehlerbehebungen werden automatisch verbreitet.
• Konsistentes UI-Design: Jede Instanz deiner Komponente hat die gleiche Struktur, die gleichen Klassen und das gleiche Verhalten. Dadurch wird ein einheitliches Aussehen und Gefühl in der gesamten Anwendung verstärkt.
• Vereinfachte Wartung: Eine kleinere, trockene Codebasis bedeutet, dass weniger Dateien verwaltet werden müssen, es gibt weniger Textbausteine und die Entwicklung ist effizienter.

Erweiterte Nutzung

Dieser Abschnitt befasst sich mit fortgeschrittenen Techniken in FastHTML, einschließlich Formularbearbeitung, Validierung und Fehlerrückmeldungen. Durch den Einsatz von Python-Klassen und strukturierten Komponenten kannst du robuste, benutzerfreundliche Formulare erstellen und gleichzeitig für sauberen und testbaren Code sorgen.

Formularbearbeitung und -validierung

FastHTML vereinfacht die Bearbeitung von Formularen, indem es automatisch HTML-Formulare aus Python-Klassen generiert und eine unkomplizierte Datenbindung für die Verarbeitung von Formularen bereitstellt. 

Betrachte zum Beispiel den folgenden Code.

from fasthtml.common import *
from dataclasses import dataclass

@dataclass
class Profile:
    name:str;
    email:str;
    age:int

profile_form = Form(method="post", action="/profile")(
        Fieldset(
            Label("Name", Input(name="name")),
            Label("Email", Input(name="email")),
            Label("Age", Input(name="age")),
        ),
        Button("Submit", type="submit"),
    )

# Instantiate app
app = FastHTML()

# GET / serves the form (FastHTML will serialize the component to HTML)
@app.get("/")
def home():
    return profile_form

# Simple POST handler to echo back submitted data
@app.post("/profile")
def profile(data: Profile):
    return Div(
        H1("Profile Submitted"),
        P(f"Name: {data.name}"),
        P(f"Email: {data.email}"),
        P(f"Age: {data.age}")
    )

Dieser Code erzeugt den folgenden HTML-Code für das Formular. FastHTML parst die Formulardaten automatisch in das Profile Objekt, wobei kompatible Feldnamen vorausgesetzt werden. Unter der Haube kann dies auf einem Formular-Parsing im Stil von Starlette und einer benutzerdefinierten Validierungsschicht basieren.

<form enctype="multipart/form-data" method="post" action="/profile">
	<fieldset>
	<label>Name<input name="name"></label>
	<label>Email<input name="email"></label>
	<label>Age<input name="age"></label>
</fieldset>

	<button type="submit">Submit</button>
</form>

Sobald das Formular abgeschickt wurde, parst FastHTML die Formulardaten in das Profile Objekt. Die profile Route gibt dann eine Bestätigungsseite zurück, auf der die übermittelten Werte direkt aus dem data Objekt angezeigt werden. Dieser Ansatz vereinfacht die Handhabung von Formularen, reduziert Boilerplate und gewährleistet eine starke Datentypisierung in deiner gesamten Anwendung.

Es ist immer eine gute Idee, Formulareingaben zu validieren. Füge die Validierungslogik hinzu, indem du die /profile Route wie folgt umschreibst.

@app.post("/profile")
def submit_profile(data: Profile):
    # Form validation
    if not data.name.strip():
        raise HTTPException(status_code=400, detail="Name is required")
    if not data.email.strip() or "@" not in data.email:
        raise HTTPException(status_code=400, detail="A valid email is required")
    if data.age < 0:
        raise HTTPException(status_code=400, detail="Age must be non-negative")
    
    # If validation passes, render the result
    return Div(
        H1("Profile Submitted"),
        P(f"Name: {data.name}"),
        P(f"Email: {data.email}"),
        P(f"Age: {data.age}")
    )

Wenn name fehlt, email fehlt oder age negativ ist, erhält der Benutzer eine eindeutige Fehlermeldung. Indem sie eine HTTPException mit einem 400-Statuscode auslöst, teilt die Anwendung den spezifischen Validierungsfehler mit, so dass der Benutzer seine Eingaben korrigieren kann, bevor er das Formular erneut absendet.

Ein robusterer Weg, um mit fehlenden oder ungültigen Daten umzugehen, ist eine explizite Fehlerprüfung und ein benutzerfreundliches Feedback. Schreibe den Code zum Beispiel wie folgt um.

from fasthtml.common import *
from dataclasses import dataclass

@dataclass
class Profile:
    name: str
    email: str
    age: int

def profile_form(data=None, errors=None):
    data   = data   or {}
    errors = errors or {}
    return Form(
        Fieldset(
            Label(
                "Name",
                Input(
                    name="name",
                    value=data.get("name", ""),
                    placeholder="Your name"
                )
            ),
            Small(errors.get("name", ""), cls="error-text"),

            Label(
                "Email",
                Input(
                    name="email",
                    type="email",
                    value=data.get("email", ""),
                    placeholder="you@example.com"
                )
            ),
            Small(errors.get("email", ""), cls="error-text"),

            Label(
                "Age",
                Input(
                    name="age",
                    type="number",
                    value=str(data.get("age", "")),
                    placeholder="Age"
                )
            ),
            Small(errors.get("age", ""), cls="error-text"),
        ),
        Button("Submit", type="submit")
    , method="post", action="/profile", id="profile-form", hx_swap="outerHTML")

app = FastHTML()

@app.get("/")
def home():
    return Div(
        H1("Create Your Profile"),
        profile_form()
    )

@app.post("/profile")
async def submit_profile(request):
    form = await request.form()
    data = {
        "name":  form.get("name", "").strip(),
        "email": form.get("email", "").strip(),
    }
    errors = {}

    # Validate name
    if not data["name"]:
        errors["name"] = "Name is required. "

    # Validate email
    if not data["email"]:
        errors["email"] = "Email is required. "
    elif "@" not in data["email"]:
        errors["email"] = "Enter a valid email address."

    # Validate age
    age_raw = form.get("age", "").strip()
    try:
        age = int(age_raw)
        if age < 0:
            raise ValueError()
        data["age"] = age
    except ValueError:
        errors["age"] = "Age must be a non-negative integer. "

    if errors:
        # re-render form with submitted values and error messages
        return Div(
            H1("Create Your Profile"),
            profile_form(data, errors)
        )

    # Success path
    profile = Profile(**data)
    return Div(
        H1("Profile Submitted"),
        P(f"Name: {profile.name}"),
        P(f"Email: {profile.email}"),
        P(f"Age: {profile.age}")
    )

if __name__ == "__main__":
    serve()

Wenn der/die Nutzer/in ein Pflichtfeld überspringt oder eine ungültige Eingabe macht, wird das Formular mit den eingegebenen Werten und den entsprechenden Fehlermeldungen neben den einzelnen Feldern neu angezeigt. Dieser Ansatz verbessert das Nutzererlebnis, indem er klar anzeigt, was korrigiert werden muss.

Wenn du alle Felder ausgefüllt und abgeschickt hast, erhältst du einen Bildschirm ähnlich dem folgenden.

Authentifizierung und Sitzungsmanagement

Implementierung von Authentifizierungsabläufen

In FastHTML werden die Sitzungsdaten über das request.session Objekt verwaltet, das sich wie ein Python Wörterbuch verhält. Du kannst Daten in der Sitzung speichern, indem du Schlüssel-Wert-Paare festlegst, z. B. session['user_id'] = 123. Um Sitzungsdaten abzurufen, verwendest du read (user_id = session.get('user_id')). To clear all session data, call session.clear().

Hinter den Kulissen serialisiert FastHTML das Sitzungswörterbuch in ein signiertes Cookie, das über Anfragen hinweg bestehen bleibt. Mit diesem Ansatz kannst du die Benutzerauthentifizierung und den Sitzungsstatus mit vertrauten Python-Mustern verwalten.

Überblick über den Aufbau von Authentifizierungsworkflows

Um einen Authentifizierungsworkflow zu erstellen, befolge diese Schritte.

1. Konfiguriere die Sitzungen: Add SessionMiddleware with a strong secret_key. Once configured, the request.session is available in every handler.
2. Benutzermodell und Umgang mit Passwörtern: Definiere ein Benutzerschema (mit Datenklasse, Pydantic-Modell oder ORM), das einen Benutzernamen and password_hash. Use a hashing function (e.g., hashlib, pbkdf2_hmac, bcrypt enthält.) to store and verify passwords.
3. Anmeldevorgang*: Erstelle ein GET /register route to render a signup form. * Verwende POST /register to validate form input, hash the password, save the user record, set the session['user_id'], and redirect to a protected page or dashboard.
4. Login flow*: Erstelle ein GET /login route to display login form. * Verwende POST /login to verify credentials. On success, write session['user_id'] and redirect; on failure, re-render the form with an error message.
5. Schutz der Routen: Erstelle eine Hilfsfunktion oder einen Dekorator, der session.get('user_id') überprüft. If the user is not authenticated, redirect to /login; otherwise, allow access to the requested route.
6. Abmeldevorgang: In der GET /logout route, call session.clear()`, um die Sitzungsdaten zu löschen und den Benutzer zur Login- oder Home-Seite umzuleiten.

Datenbank-Integration

Ein Object-Relational Mapper (ORM) bildet Klassen auf Datenbanktabellen ab und ermöglicht es dir, Daten mit nativen Objekten statt mit Roh-SQL abzufragen. Beliebte Optionen sind SQLAlchemy und das ORM von Django. 

FastHTML hat eine ORM-ähnliche Schnittstelle, die sich mit jeder asynchronen Python ORM- oder Abfragebibliothek verbinden lässt. Standardmäßig wird SQLite verwendet, aber es kann mit jedem Datenbank-Backend integriert werden. Betrachte zum Beispiel den folgenden Code.

# Database setup (SQLite by default, but backend can change)
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker, declarative_base
from sqlalchemy import Column, Integer, String, select
from fasthtml.common import *

DATABASE_URL = "sqlite+aiosqlite:///./test.db"  # Change backend here (e.g., PostgreSQL)

engine = create_async_engine(DATABASE_URL, echo=True)
SessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
Base = declarative_base()

# ORM model
class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String)

# FastHTML app
app = FastHTML()

@app.get("/")
async def list_users():
    async with SessionLocal() as session:
        result = await session.execute(select(User))
        users = result.scalars().all()
    
    return Div(
        H1("Users"),
        Ul(*[Li(user.name) for user in users])
    )

if __name__ == "__main__":
    import asyncio
    async def init_db():
        async with engine.begin() as conn:
            await conn.run_sync(Base.metadata.create_all)
    asyncio.run(init_db())
    serve()

In einer FastHTML-Anwendung fragst du Daten in der von dir gewählten Datenbankebene ab und übergibst die Ergebnisse dann zur Darstellung an FastHTML-Komponenten. Nachdem du z.B. Datensätze aus deiner Datenbank abgerufen hast, kannst du sie in einem Route-Handler in einer Schleife durchlaufen und HTML-Strukturen wie Tabellen, Listen oder eigene Karten erstellen.

Bewährte Verfahren gelten nach wie vor: Wähle nur die notwendigen Felder aus, filtere und sortiere auf Datenbankebene und paginiere große Ergebnismengen. FastHTML hilft dir, dich auf die Entwicklung sauberer, dynamischer Frontends zu konzentrieren, während du die Datenverarbeitung den besten Tools für dein Projekt überlässt.

Strategien zur Leistungsoptimierung

Es gibt mehrere Möglichkeiten, wie du mit FastHTML die besten Ergebnisse erzielen kannst. Im Folgenden haben wir einige dieser Empfehlungen zusammengefasst. 

Caching-Mechanismen

Caching verbessert die Leistung, indem es redundante Arbeit auf verschiedenen Ebenen deiner Anwendung vermeidet. Auf der Ebene des Browsers und des CDN kannst du Cache-Kopfzeilen verwenden, um statische Inhalte wie Bilder, Skripte und Stylesheets zu speichern. 

Du kannst ganze Routenantworten oder kostspielige Teile in deinem Webframework zwischenspeichern. In deiner FastHTML-App kannst du ganze Routenantworten oder teure Komponenten zwischenspeichern und so sicherstellen, dass wiederholte Anfragen schnell zurückkommen, ohne die Datenbank erneut abzufragen oder Vorlagen neu zu erstellen.

In Python kannst du das Caching auf Funktionsebene mit Hilfe von Dekoratoren implementieren. Der eingebaute functools.lru_cache Dekorator kann zum Beispiel eine Hilfsfunktion memoisieren, die Benutzerdaten abruft. Du könntest diesen Dekorator zum Beispiel verwenden, um Datenbankaufrufe zwischenzuspeichern:

from functools import lru_cache

@lru_cache(maxsize=64)
def fetch_user_profile(user_id):
    # simulate an expensive database call
    return db.get_user(user_id)

@app.get("/profile/{user_id}")
def profile(user_id: int):
    profile = fetch_user_profile(user_id)
    return Div(P(profile.name), P(profile.email))

Asynchrone Aufgaben-Warteschlangen

Webanwendungen bleiben reaktionsschnell, indem sie zeitaufwändige Aufgaben aus dem Anfragezyklus auslagern. Anstatt den Server beim Erstellen von Berichten, Versenden von E-Mails oder Verarbeiten von Daten zu blockieren, werden diese Aufgaben in eine Warteschlange gestellt und im Hintergrund ausgeführt. 

Bei diesem Ansatz sendet deine Anwendung eine sofortige Antwort an den Benutzer, während die Worker, die in separaten Prozessen oder Threads laufen, Aufgaben in der Warteschlange asynchron bearbeiten.

FastHTML unterstützt die Ausführung von Aufgaben im Hintergrund, indem es sich in die BackgroundTasks von Starlette integriert. Hier ist ein Beispiel, das zeigt, wie du eine Willkommens-E-Mail nach der Anmeldung eines Nutzers verschickst.

from fasthtml.common import FastHTML, serve, Div, Form, Input, Button
from starlette.background import BackgroundTasks

app = FastHTML()

def send_welcome_email(email: str):
    # expensive or time consuming work
    ...

@app.post("/signup")
def signup(background_tasks: BackgroundTasks, request):
    form = await request.form()
    email = form["email"]
    # schedule the email task
    background_tasks.add_task(send_welcome_email, email)
    return Div("Thanks for signing up! You will receive an email shortly.")

Anwendungen in der realen Welt

FastHTML ist ein vielseitiges Framework, das eine Vielzahl von Webanwendungen unterstützen kann. Schauen wir uns an, wie du mit FastHTML eine E-Commerce-Plattform und ein Daten-Dashboard erstellen kannst.

Entwurf für eine E-Commerce-Plattform

Lass uns eine E-Commerce-Plattform mit FastHTML aufbauen. Beginne damit, deine wichtigsten Daten als ORM-Klassen oder Python-Datenklassen zu modellieren: Produkte, Benutzer und Warenkorbartikel. 

Erstelle eine Produktlistenseite, die in einer Schleife durch deine Produktdatensätze führt. Verwende für jedes Produkt eine wiederverwendbare Python-Komponente, z. B. Card, um das Produkt, das Bild, den Namen, den Preis und eine Schaltfläche "In den Warenkorb" anzuzeigen. Diese Schaltfläche enthält HTMX-Attribute wie hx_post und hx_target, die es ihr ermöglichen, eine Anfrage zu senden, um den Artikel dem Sitzungswarenkorb des Nutzers hinzuzufügen, ohne die gesamte Seite neu zu laden.

Der Einkaufswagen selbst wird im session Wörterbuch des Benutzers auf dem Server gespeichert. Füge in den Header deiner Website eine Komponente für die Warenkorbübersicht ein, die dynamisch mit HTMX aktualisiert wird, wenn Artikel tatsächlich hinzugefügt oder entfernt werden. 

Die Warenkorbseite liest die Sitzungsdaten, um jeden Artikel im Warenkorb zusammen mit einer Gesamtsumme anzuzeigen. Außerdem bietet es ein Kassenformular, das mit einer Python-Klasse zur Validierung verbunden ist. Wenn der/die Nutzer/in das Formular abschickt, erstellt deine App einen Bestelldatensatz und leert den Sitzungskorb.

Implementierung des Daten-Dashboards

Ein Daten-Dashboard in FastHTML kombiniert Python-Komponenten mit deinen Datenquellen und nutzt HTMX für Interaktivität und Echtzeit-Updates. Deine Backend-Logik (z. B. asynchrone Hilfsfunktionen, zwischengespeicherte CRUD-Utilities oder ORM-Abfragen) ruft die erforderlichen Daten ab. 

Von dort aus gestaltest du eine Seite mit wiederverwendbaren Widgets. Dazu gehören Filtersteuerungen (wie Dropdowns, Datumsauswahl oder Suchfelder) zur Verfeinerung von Abfragen, KPI-Karten zur Anzeige von Schlüsselkennzahlen, Tabellen zur Auflistung von Datensätzen oder Diagrammeinbettungen zur Visualisierung von Trends und Vergleichen. 

Jedes Widget ist als nativer Python-Code geschrieben, typischerweise eine Div, Table oder eine benutzerdefinierte Card Komponente. FastHTML wandelt diese Objekte zur Antwortzeit automatisch in HTML um.

Mit HTMX können die Dashboards interaktiv sein. Filter-Widgets können zum Beispiel hx_get und hx_post nutzen, um gefilterte Daten vom Server anzufordern und Tabellen oder Diagramme dynamisch zu aktualisieren, ohne dass die Seite komplett neu geladen werden muss. 

Vergleichende Analyse mit traditionellen Rahmenwerken

FastHTML hebt sich von traditionellen Frameworks wie Django und Flask ab, indem es sowohl die Entwicklung als auch die Leistung rationalisiert. Wir wollen herausfinden, wie sie bei wichtigen Faktoren wie Einrichtungszeit, Code-Effizienz und Leistungsbenchmarks abschneidet.

Geschwindigkeit der Entwicklung

FastHTML hat zwei entscheidende Vorteile gegenüber Frameworks wie Django und Flask: die Einrichtungszeit und die Code-Effizienz.

Einrichtungszeit

Djangos "batteries-included"-Ansatz erfordert mehrere Schritte, bevor du deine erste Seite bereitstellen kannst: Installiere das Paket, führe django-admin startproject aus, konfiguriere die Einstellungen und definiere eine App. Das bedeutet oft, dass du mehrere Dateien und eine Menge Boilerplate-Code schreiben musst, bevor du eine echte Logik schreiben kannst.

Der Flachmann ist schlanker. Nach pip install kannst du mehrere Routen in eine einzige Datei schreiben. Allerdings musst du noch Jinja-Vorlagen und statische Ordner konfigurieren und JavaScript für die Interaktivität hinzufügen.

Mit FastHTML ist die Einrichtung minimal.

1. Führe pip install python-fasthtml uvicorn aus.
2. Definiere Routen und Pythonic HTML-Komponenten. Du kannst dies in einer einzigen Datei tun.
3. Rufe serve() an.

Es ist keine separate Template-Engine oder statische Ordnerkonfiguration erforderlich. Du kannst sofort mit dem Bau beginnen.

Code Effizienz

Mit Django sind selbst für eine einfache "Hello, world"-Seite mehrere Dateien erforderlich: views.py, urls.py, settings.py, templates/hello.html, sowie das ORM- und Admin-Gerüst.

Flask vereinfacht diesen Prozess auf eine einzige Datei, aber du musst immer noch manuell HTML in Jinja-Vorlagen oder Inline-Strings und JavaScript für die Interaktivität schreiben.

Mit FastHTML kannst du deine Benutzeroberfläche als Python-Objekte definieren, sodass du nicht zwischen Dateien oder Sprachen wechseln musst. HTMX handhabt die Interaktivität deklarativ ohne eigene Skripte. Das Ergebnis sind weniger Codezeilen, keine separaten Vorlagen oder statischen Asset-Pipelines und eine einzige testbare Oberfläche für Markup und Verhalten.

Leistungsmaßstäbe