JSON zu Python

Ähnliche Tools

Über JSON zu Python: JSON-Daten in ausführbare Dataclass-Modelle umwandeln

Anwendungsfälle

• REST API-Integration: Konvertieren Sie die vom Backend zurückgegebene JSON-Antwort in Python @dataclass, verwenden Sie sie mit requests + json für stark typisierte HTTP-Anfrageauswertung. Mit mypy oder pyright erhalten Sie in der IDE Echtzeit-Attributvervollständigung und Typprüfung, vermeiden häufige Tippfehler.
• FastAPI Anfrage-/Antwortmodelle: Konvertieren Sie Beispiel-JSON aus der API-Schnittstellendokumentation in Pydantic BaseModel-Vorlagen, vereinheitlichen Sie Frontend-Backend-Modelldefinitionen. Es wird empfohlen, den response_model-Parameter in FastAPI-Projekten zu aktivieren, damit die OpenAPI-Dokumentation automatisch Feldbeispiele und Validierungsregeln generiert.
• Django Ninja / DRF-Serialisierer: Konvertieren Sie die JSON-Antwort in Dataclass und fügen Sie dann manuell DRFs ModelSerializer oder Ninjas Schema-abgeleitete Klassen hinzu. DRFs ModelSerializer kann automatisch Validierungsregeln basierend auf Dataclass generieren, Ninjas Schema kann die Ausgabe dieses Tools ebenfalls direkt wiederverwenden.
• Scraper-Datenmodellierung: Konvertieren Sie von Webseiten extrahierte JSON-Daten in Dataclass, vermeiden Feldfehler und Tippfehler durch dynamischen Zugriff mit dict. Bei asynchronen Scraper-Bibliotheken wie requests-html, playwright reduziert Dataclass auch den Boilerplate-Code für die JSON-Deserialisierung.
• ML-Feature-Definition: Konvertieren Sie das JSON-Schema von scikit-learn / pandas-Trainingsdaten in Dataclass, standardisieren Sie Feature-Feldnamen und -typen. sklearn Pipeline.fit(X, y) akzeptiert Datenstrukturen mit Typannotationen, dataclass + asdict ist eine effiziente Brücke zur Konvertierung mit pandas DataFrame.
• Konfigurationsdatei-Deserialisierung: Konvertieren Sie YAML/JSON-Konfigurationsdateibeispiele in Dataclass, verwenden Sie sie mit Hydra / OmegaConf für stark typisiertes Konfigurationslesen. Mit dem @dataclass-Dekorator von Hydra erhält die Konfiguration automatische Vervollständigung in der IDE, vermeidet häufige Tippfehler und Typinkonsistenzen in YAML-Konfigurationen.
• Jupyter Notebook temporäre Struktur: Konvertieren Sie JSON-Beispiele aus der explorativen Datenanalyse in Dataclass, erleichtern Attributzugriff und IDE-Vervollständigung in Notebook. Das Verpacken von JSON-Antworten mit Dataclass in Notebook verbessert die Lesbarkeit des Codes für explorative Analysen erheblich und erleichtert die spätere Refaktorisierung in Produktionsmodule.
• Microservice-Schnittstellendefinition: Konvertieren Sie Beispiel-JSON für Request-Bodys von gRPC/HTTP-Diensten in Python-Typen, vereinheitlichen Sie serverseitige Modelldefinitionen. Nach der Konvertierung von gRPC-Protobuf in JSON kann die Konvertierung in Dataclass als stark typisiertes Modell für Backend-Dienste dienen, ausgerichtet an Frontend-TypeScript-Typen.
• CLI-Tool-Entwicklung: Konvertieren Sie JSON-Beispiele für Befehlszeilenkonfigurationen in Dataclass, verwenden Sie sie mit argparse für Konfigurationsdeserialisierung und -validierung. Die Konvertierung eines argparse-Namespace in Dataclass erfordert nur eine Zeile dataclass(**vars(args)), sicherer als manuell geschriebene Parsing-Logik.
• Testdatenkonstruktion: Konvertieren Sie echte JSON-Fixtures, die vom Backend zurückgegeben werden, in Python-Typen, verwenden Sie dataclasses.replace in pytest für testdatengesteuerte Tests. Der parametrize-Dekorator von pytest in Kombination mit Dataclass kann typisierte Test-Fixtures konstruieren, mit klareren Fehlermeldungen.
• Strukturierte Protokollanalyse: Konvertieren Sie von ELK / Loki erfasste JSON-Protokolle in Dataclass, erleichtern Filterung und Alarmregeln. Nach der Verpackung durch Dataclass können JSON-Protokolle von ELK präzise Feldfilterung und Aggregationsabfragen durchführen, sicherer als der Zugriff über dict.
• Konfigurationszentrum-Migration: Konvertieren Sie JSON-Konfigurationen von Apollo / Nacos / Consul in Python-Typen für das serverseitige Hot-Reloading von Konfigurationen. JSON-Konfigurationen von Apollo / Nacos können bidirektional mit Dataclass validiert werden, fehlende Felder oder Typinkonsistenzen werden bei Konfigurationsänderungen sofort erkannt.
• Sprachübergreifende Zusammenarbeit: Bei der Integration zwischen Python-Backend und TypeScript-Frontend konvertieren Sie dasselbe JSON jeweils in Python-Dataclass und TS-Interface, um die Konsistenz auf beiden Seiten zu gewährleisten. In sprachübergreifenden Zusammenarbeitsszenarien teilen Python-Backend und TS-Frontend dasselbe JSON-Beispiel und generieren jeweils Dataclass und Interface, um die Konsistenz der Feldnamen zu gewährleisten.
• Datenbankmigration: Konvertieren Sie aus MongoDB / PostgreSQL JSONB-Feldern exportierte JSON-Dokumente in Python-Modelle als Referenz für ORM-Entitätsdefinitionen. Nach dem Export konvertierte MongoDB JSONB-Dokumente in Dataclass dienen als Feldreferenz für ORM-Entitäten, einfacher zu warten als das direkte Lesen von MongoDB-Dokumenten.
• Blockchain/Web3: Konvertieren Sie On-Chain-JSON-RPC-Antworten in Python-Dataclass für die Typkapselung von SDKs wie web3.py. Ethereum-SDKs wie web3.py, eth-brownie unterstützen alle Rückgabewerte im Dataclass-Stil und erleichtern die Sekundärkapselung.
• Data Science ETL: Konvertieren Sie vorgelagerte JSON-Datenquellen in Dataclass und verwenden Sie dann pandas DataFrame.from_records zur Konvertierung in Tabellen für nachgelagerte Analysen. pandas DataFrame.from_records([asdict(d) for d in dataclass_list]) erledigt die Konvertierung verschachtelter Strukturen in Tabellen in einer Zeile.
• OpenAPI-Schema-Validierung: Konvertieren Sie Beispiel-JSON aus OpenAPI-Dokumenten in Python-Modelle und schreiben Sie dann Pydantic-Validierungslogik. Das example-Feld von OpenAPI kann direkt als Eingabe für dieses Tool kopiert werden, das generierte Pydantic-Modell validiert automatisch die Konsistenz der API-Dokumentation.
• Lehrbeispiele: In Python-Kursen konvertieren Sie Beispiel-JSON in Dataclass, um das typing-Modul, Typannotationen, die automatische Generierung von __init__ und andere Konzepte zu erläutern. Beim Erklären des typing-Moduls, der automatischen Generierung von __init__, slots und anderer Konzepte in Python-Kursen ist Dataclass das anschaulichste Demonstrationsmedium.
• Feldnamenskonvertierung: Nach der Konvertierung von snake_case-JSON-API-Antworten in Dataclass ändern Sie die Feldnamen manuell oder konfigurieren Sie die Feldzuordnung über Pydantics alias_generator. Pydantics alias_generator kann in BaseModel für die automatische Zuordnung camelCase ↔ snake_case konfiguriert werden und vermeidet manuell geschriebene Aliase.

Anleitung

1. Fügen Sie JSON-Inhalt in den linken Editor ein oder klicken Sie auf die Schaltfläche zum Hochladen, um eine .json/.txt-Datei auszuwählen
2. Warten Sie 400 ms auf die automatische Konvertierung, der generierte Python-Dataclass-Code wird rechts angezeigt
3. Wenn das JSON-Format falsch ist, klicken Sie auf die Schaltfläche «JSON reparieren», um häufige Syntaxprobleme automatisch zu beheben
4. Klicken Sie auf «Kopieren», um es in das models/-Verzeichnis des Projekts einzufügen, oder klicken Sie auf «Herunterladen», um es als model.py-Datei zu speichern

Funktionen

• Lokale Browser-Konvertierung: JSON-Parsing und Python-Codegenerierung erfolgen vollständig im Browser, keine Daten werden an Server gesendet, auch sensible API-Antworten können sicher verwendet werden
• Dataclass-Annotationsausgabe: Generiert mit @dataclass dekorierte Standard-Python-Klassen, die mit from __future__ import annotations direkt in Python 3.7+-Projekten verwendet werden können
• Automatische Typerkennung: str / int / float / bool / List[T] / Dict[str, Any] / Optional[Any] werden automatisch entsprechend den JSON-Werten zugeordnet, keine manuelle Angabe der Feldtypen erforderlich
• Automatische Aufteilung verschachtelter Objekte: Verschachtelte JSON-Objekte erzeugen unabhängige @dataclass-Klassen, benannt nach Großschreibung des Feldnamens (z.B. address -> Address), vermeidet doppelte Typdefinitionen
• Automatische Auflösung von List-Generics: JSON-Arrays werden automatisch zu List[T] konvertiert, der Elementtyp wird aus dem ersten nicht-null-Element des Arrays abgeleitet, z.B. ["a","b"] -> List[str], [{...},{...}] -> List[Item]
• Optionale Optional-Felder: Null-Felder erzeugen Optional[Any] als Fallback, um sicherzustellen, dass Typannotationen fehlende Felder korrekt ausdrücken
• Automatische Konvertierung mit 400ms Entprellung: Konvertierung wird automatisch nach dem Einfügen ausgelöst, Python-Code-Vorschau in Echtzeit rechts, reduziert Wartezeit und überflüssige Klicks
• JSON-Fehlerbehebung in einem Klick: Behebt automatisch häufige Formatfehler wie abschließende Kommas, einfache Anführungszeichen, fehlende Anführungszeichen, setzt die Codegenerierung nach erfolgreicher Reparatur fort
• Kopieren und Herunterladen: Kopieren Sie den gesamten Python-Code in einem Klick oder laden Sie ihn als model.py-Datei herunter, die direkt im Projektstamm oder im models-Untermodul platziert werden kann
• localStorage-Eingabeverlauf: Speichert automatisch die letzten Eingaben lokal, ermöglicht schnelle Wiederherstellung nach Aktualisierung oder versehentlichem Schließen der Seite
• Responsive Spaltenbearbeitung: JSON links eingeben, Python-Code rechts anzeigen, unterstützt Ziehen zur Größenanpassung der Panels, angepasst an große Bildschirme und Mobilgeräte
• Unterstützt Pydantic/attrs/TypedDict-Nachbearbeitung: Die generierte Dataclass kann in einem Klick mit BaseModel- oder attrs-Dekoratoren für FastAPI, Django Ninja, pydantic-settings und andere Frameworks angepasst werden

Codebeispiele

# requirements.txt
# requests>=2.31

from dataclasses import dataclass
from typing import Any, List, Optional
import json
import requests


@dataclass
class Address:
    city: str
    zip: str


@dataclass
class User:
    id: int
    name: str
    active: bool
    address: Address
    tags: List[str]
    label: Optional[Any] = None


def main() -> None:
    resp = requests.get("https://api.example.com/users/1", timeout=10)
    resp.raise_for_status()

    # JSON-String direkt in Dataclass-Instanz deserialisieren
    user: User = User(**resp.json())

    # Stark typisierter Zugriff: IDE-Vervollständigung, mypy/pyright statische Prüfung
    print(f"{user.name} lives in {user.address.city}")
    print(f"tags: {user.tags}")


if __name__ == "__main__":
    main()

# pip install fastapi 'pydantic>=2'

from typing import List, Optional
from fastapi import FastAPI
from pydantic import BaseModel


class Address(BaseModel):
    city: str
    zip: str


class User(BaseModel):
    id: int
    name: str
    email: str
    active: bool = True
    address: Address
    tags: List[str] = []
    label: Optional[str] = None


app = FastAPI()


@app.post("/users")
async def create_user(user: User) -> dict:
    # FastAPI validiert den Request-Body automatisch mit User, Feldtyp/Pflichtfehler geben 422 zurück
    return {"id": user.id, "name": user.name}


@app.get("/users/{user_id}", response_model=User)
async def get_user(user_id: int) -> User:
    # response_model serialisiert die Antwort automatisch, OpenAPI-Dokumentation automatisch generiert
    return User(
        id=user_id,
        name="Alice",
        email="alice@example.com",
        active=True,
        address=Address(city="Beijing", zip="100000"),
        tags=["fastapi", "pydantic"],
    )

from dataclasses import dataclass, asdict
from typing import List, Optional
import json


@dataclass
class Author:
    id: int
    name: str


@dataclass
class Article:
    id: int
    title: str
    url: str
    author: Author
    score: int
    tags: List[str]
    summary: Optional[str] = None


def parse_articles(raw_json: str) -> List[Article]:
    """Vom Scraper erfasste JSON-Zeichenfolge in Article-Liste deserialisieren."""
    payloads = json.loads(raw_json)
    return [Article(**payload) for payload in payloads]


if __name__ == "__main__":
    raw = '''[
        {
            "id": 1,
            "title": "Hello dataclass",
            "url": "https://example.com/p/1",
            "author": {"id": 10, "name": "Alice"},
            "score": 95,
            "tags": ["python", "typing"],
            "summary": "quick intro"
        }
    ]'''

    articles = parse_articles(raw)
    for art in articles:
        # Automatische IDE-Vervollständigung für author.name, tags, summary
        print(f"[{art.score}] {art.title} - {art.author.name}")
        print(f"  tags: {art.tags}")

        # Bei Bedarf dict-Form (z.B. Schreiben in MongoDB) mit asdict
        doc = asdict(art)
        print(f"  mongo doc: {doc}")

# pip install pandas scikit-learn

from dataclasses import dataclass, field, asdict
from typing import List, Optional
import json
import pandas as pd
from sklearn.ensemble import RandomForestClassifier


@dataclass
class FeatureSchema:
    """Beispiel-Feature-Schema, generiert vom JSON-zu-Python-Tool und dann angepasst."""
    user_id: int
    age: int
    city: str
    plan: str
    monthly_spend: float
    active: bool
    tags: List[str] = field(default_factory=list)
    last_login: Optional[str] = None


def features_to_frame(samples: List[dict]) -> pd.DataFrame:
    """JSON-Liste in DataFrame konvertieren, automatisch Dataclass-Feldnamen als Spaltennamen verwenden."""
    rows = [asdict(FeatureSchema(**row)) for row in samples]
    df = pd.DataFrame(rows)
    # Kategorische Felder One-Hot-Kodierung
    df = pd.get_dummies(df, columns=["city", "plan"], drop_first=True)
    return df


def main() -> None:
    raw = json.loads('''[
        {"user_id": 1, "age": 25, "city": "Beijing", "plan": "pro", "monthly_spend": 99.0, "active": true, "tags": ["new"]},
        {"user_id": 2, "age": 40, "city": "Shanghai", "plan": "free", "monthly_spend": 0.0, "active": false, "tags": []}
    ]''')

    X = features_to_frame(raw)
    y = [1, 0]  # Angenommene Labels: zahlende Benutzer / kostenlose Benutzer

    model = RandomForestClassifier(n_estimators=100, random_state=42)
    model.fit(X, y)

    print("feature_columns:", list(X.columns))
    print("importances:", dict(zip(X.columns, model.feature_importances_)))

Best Practices

Häufig gestellte Fragen

Fehlerbehebung

Glossar

dataclass

Python 3.7+ Standardbibliotheksdekorator (@dataclass), zur automatischen Generierung magischer Methoden wie __init__, __repr__, __eq__. Dieses Tool generiert @dataclass-Klassen, z.B. @dataclass class User: id: int; name: str. Im Wesentlichen entkoppelt es «Datenspeicherung» von «Datenoperationen», lässt die Klasse sich auf die Beschreibung von Datenfeldern konzentrieren, während der Dekorator automatisch Boilerplate-Methoden generiert.

Modul typing

Python-Standardbibliothek für Typannotationen, bietet generische Typen wie List, Dict, Optional, Any, Union. Die von diesem Tool generierten List[T], Optional[Any] stammen alle aus dem typing-Modul. Python 3.9+ kann die integrierten list, dict direkt verwenden. Neben collections.abc, contextlib ist es das Kernmodul in der Python-Standardbibliothek für statische Typeinschränkungen; seit PEP 484 schrittweise zum Standard für große Projekte geworden.

Optional[T]

Optionaler Typ des typing-Moduls, entspricht Union[T, None], bedeutet, dass ein Feld None sein kann. Dieses Tool ordnet JSON-null Optional[Any] zu, kann manuell in Optional[str] oder andere genauere Typen geändert werden. Beachten Sie den Unterschied zwischen Optional[T] und T = None Standardwert: Ersteres ist ein Ausdruck von None auf Typebene, Letzteres eine Standardeinstellung auf Wertebene.

List[T]

Generischer Python-Listentyp. Dieses Tool ordnet JSON-Arrays automatisch List[T] zu, z.B. wird ein Zeichenfolgenarray zu List[str], ein Objektarray zu List[Item]. Python 3.9+ kann list[T] schreiben. Das Tool importiert standardmäßig aus dem typing-Modul, äquivalent zum integrierten list[T] von Python 3.9+; wenn das Team die neue Syntax bevorzugt, kann der Import in einem Klick ersetzt werden.

Any

Spezieller Typ des typing-Moduls, bedeutet, dass jeder Typ akzeptiert wird. Dieses Tool verwendet Any als Standard-Fallback für Null-Werte und leere Arrays, um Typerkennungsfehler zu vermeiden. Häufige Verwendung von Any lässt mypy/pyright ihre Prüffähigkeit verlieren, es wird empfohlen, nach Bestimmung des Feldtyps auf genaue Typen zu ändern, z.B. Optional[str], List[int].

Pydantic BaseModel

Datenmodell-Basisklasse der Pydantic-Bibliothek, bietet Laufzeit-Datenvalidierung, Serialisierung und Deserialisierung. Die von diesem Tool generierte Dataclass kann in einem Klick in BaseModel für die FastAPI-Request-Body-Validierung umgewandelt werden. Pydantic v2 hat die Kernvalidierungslogik in Rust neu geschrieben, mit 5-50-facher Leistungssteigerung gegenüber v1; die von diesem Tool generierte Dataclass kann auch BaseModel erben, um diese Beschleunigung zu genießen.

FastAPI

Modernes Python-Web-Framework, setzt auf Pydantic für automatische Request-Body-Validierung. Die von diesem Tool generierte Dataclass kann als Anfrage-/Antwortmodellvorlage für FastAPI-Routenfunktionen dienen. Basierend auf Starlette + Pydantic, generiert automatisch OpenAPI-Dokumentation, ist eines der de-facto-Standard-Python-Backend-API-Frameworks heute.

PEP 557

Python Enhancement Proposal, der Syntax und Verhalten des Dataclass-Dekorators definiert. Der von diesem Tool generierte Code entspricht vollständig der PEP 557-Norm. Dieser Vorschlag wurde 2017 von Eric V. Smith initiiert und lehnte sich an Designkonzepte bestehender Lösungen wie attrs, Haskell record an.

Typannotation (Type Hint)

Typhinweis, der nach Funktionsparametern und Variablen in Python mit : Type annotiert wird. Alle von diesem Tool generierten Dataclass-Felder verfügen über Typannotationen, die mit mypy/pyright für statische Typprüfungen verwendet werden können. Annotationen selbst beeinflussen das Laufzeitverhalten nicht, sie dienen nur der IDE-Unterstützung, statischen mypy/pyright-Prüfungen und Laufzeitvalidierungsbibliotheken (wie Pydantic).

PEP 484

Vorschlag zur Python-Typannotationsnorm, definiert das typing-Modul und die Generics-Syntax. Die von diesem Tool generierten List[T], Optional[T] folgen PEP 484. Dieser Vorschlag wurde gemeinsam von Guido van Rossum, Jukka Lehtosalo, Łukasz Langa und anderen verfasst und ist das grundlegende Dokument für das Python-Typannotationssystem.

from __future__ import annotations

Anweisung zur verzögerten Annotaitionsauswertung, eingeführt durch PEP 563, die bewirkt, dass alle Annotationen als Zeichenfolgen gespeichert werden, um Vorwärtsreferenzprobleme zu vermeiden. Die von diesem Tool generierte Dataclass kann diese Zeile hinzufügen, um die Referenzreihenfolge der Typannotationen unabhängig zu machen. Nach der Aktivierung werden alle Annotationen verzögert als Zeichenfolgen ausgewertet, vermeiden Vorwärtsreferenzprobleme und entkoppeln die Reihenfolge der Dataclass-Felder von der Referenzreihenfolge.

model.py

Standardmäßiger Dateiname, der von diesem Tool heruntergeladen wird, entspricht den Python-Projektkonventionen. Kann in user.py, schemas.py und andere Namen passend zur Projektstruktur umbenannt werden. Entspricht dem Benennungsstil models.py von Django und Flask; in Multimodell-Projekten kann im models-Paket in Untermodule wie user.py, order.py unterteilt werden.

Schnellreferenztabelle JSON-Typen zu Python-Typen

Das Tool leitet automatisch den entsprechenden Python-Typ entsprechend dem Typ des JSON-Werts ab:

Erklärung der Struktur des generierten Python-Codes

Der von quicktype-core für Python generierte typische Code umfasst die folgenden Teile:

Vergleich von Python-Datenmodellierungslösungen

Das Tool gibt standardmäßig @dataclass aus, aber das Python-Ökosystem bietet mehrere Datenmodellierungslösungen zur Auswahl je nach Projektanforderungen:

Tabelle Python-Versionen und Dataclass-Funktionen

Verschiedene Python-Versionen unterstützen Dataclass, Typing und Pydantic unterschiedlich, wählen Sie je nach Version:

Privacy & Security

Alle Operationen dieses JSON-zu-Python-Tools erfolgen vollständig lokal in Ihrem Browser: JSON-Parsing, Python-Codegenerierung und Dateidownload werden alle clientseitig über Browser-JavaScript ausgeführt, kein JSON-Inhalt, keine hochgeladenen Dateien oder generierter Code werden über das Netzwerk an irgendeinen Server gesendet. Dateiuploads verwenden die native FileReader-API des Browsers, um direkt in den Speicher zu lesen, ohne zwischengeschaltete Dienste. Kein Cookie-Tracking, keine Benutzereingaben oder Nutzungsdaten werden gesammelt. Nach dem Schließen oder Aktualisieren der Seite werden alle Ein- und Ausgaben automatisch aus dem Speicher gelöscht. Geeignet für die Verarbeitung von JSON mit API-Schlüsseln, Tokens, sensiblen Geschäftsdaten.

Authoritative References

• PythonOffizielle Python-Dokumentation - dataclasses
• PythonOffizielle Python-Dokumentation - Modul typing
• PythonPEP 557 - Data Classes
• PydanticOffizielle Pydantic-Dokumentation - Models
• FastAPIOffizielle FastAPI-Dokumentation - Request-Body
• PythonOffizielle Python-Dokumentation - Modul typing
• attrsOffizielle attrs-Dokumentation
• PythonPEP 484 - Type Hints