JSON vers Python

Recommandations connexes

À propos de JSON vers Python : transformer les données JSON en modèles dataclass exécutables

Cas d'utilisation

• Intégration REST API : convertissez la réponse JSON renvoyée par le backend en @dataclass Python, utilisez avec requests + json pour une analyse de requêtes HTTP fortement typée. Avec mypy ou pyright, obtenez la complétion d'attributs et la vérification de type en temps réel dans l'IDE, évitez les fautes de frappe courantes.
• Modèles de requête/réponse FastAPI : convertissez les exemples JSON de la documentation d'API en modèles Pydantic BaseModel, unifiez les définitions de modèles frontend/backend. Il est recommandé d'activer le paramètre response_model dans les projets FastAPI pour que la documentation OpenAPI génère automatiquement des exemples de champs et des règles de validation.
• Sérialiseurs Django Ninja / DRF : convertissez la réponse JSON en dataclass puis ajoutez manuellement ModelSerializer de DRF ou des classes dérivées Schema de Ninja. ModelSerializer de DRF peut générer automatiquement des règles de validation basées sur dataclass, Schema de Ninja peut également réutiliser directement la sortie de cet outil.
• Modélisation de données de scraping : convertissez les données JSON extraites de pages web en dataclass, évitez les oublis de champs et fautes de frappe dus à l'accès dynamique par dict. Avec des bibliothèques de scraping asynchrones comme requests-html, playwright, dataclass réduit également le code boilerplate de désérialisation JSON.
• Définition de caractéristiques ML : convertissez le schéma JSON des données d'entraînement scikit-learn / pandas en dataclass, standardisez les noms et types de champs de caractéristiques. sklearn Pipeline.fit(X, y) accepte des structures de données avec annotations de type, dataclass + asdict est un pont efficace pour la conversion avec pandas DataFrame.
• Désérialisation de fichiers de configuration : convertissez des exemples de fichiers de configuration YAML/JSON en dataclass, utilisez avec Hydra / OmegaConf pour une lecture de configuration fortement typée. Avec le décorateur @dataclass de Hydra, la configuration bénéficie de la complétion automatique dans l'IDE, évitez les fautes de frappe et incohérences de type courantes dans les configurations YAML.
• Structure temporaire Jupyter Notebook : convertissez les échantillons JSON de l'analyse de données exploratoire en dataclass, facilitez l'accès aux attributs et la complétion IDE dans Notebook. Encapsuler les réponses JSON avec dataclass dans Notebook améliore significativement la lisibilité du code d'analyse exploratoire, facilite la refactorisation ultérieure en modules de production.
• Définition d'interfaces de microservices : convertissez les exemples JSON de corps de requête de services gRPC/HTTP en types Python, unifiez les définitions de modèles côté serveur. Après conversion du protobuf gRPC en JSON, la conversion en dataclass peut servir de modèle fortement typé pour les services backend, aligné sur les types TypeScript frontend.
• Développement d'outils CLI : convertissez les exemples JSON de configuration de ligne de commande en dataclass, utilisez avec argparse pour la désérialisation et la validation de configuration. La conversion d'un Namespace argparse en dataclass ne nécessite qu'une ligne dataclass(**vars(args)), plus sûre que l'écriture manuelle de logique d'analyse.
• Construction de données de test : convertissez les fixtures JSON réelles renvoyées par le backend en types Python, utilisez dataclasses.replace dans pytest pour des tests pilotés par données. Le décorateur parametrize de pytest associé à dataclass permet de construire des fixtures de test typées, avec des messages d'échec plus clairs.
• Analyse structurée de journaux : convertissez les journaux JSON collectés par ELK / Loki en dataclass, facilitez le filtrage et les règles d'alerte. Encapsulés par dataclass, les journaux JSON d'ELK permettent un filtrage précis par champ et des requêtes d'agrégation, plus sûrs que l'accès par dict.
• Migration de centre de configuration : convertissez les configurations JSON d'Apollo / Nacos / Consul en types Python, pour le rechargement à chaud des configurations côté serveur. Les configurations JSON d'Apollo / Nacos peuvent être validées bidirectionnellement avec dataclass, les champs manquants ou incohérences de type sont détectés immédiatement lors de changements de configuration.
• Collaboration inter-langages : lors de l'intégration entre backend Python et frontend TypeScript, convertissez le même JSON en dataclass Python et interface TS pour maintenir la cohérence des deux côtés. Dans les scénarios de collaboration inter-langages, le backend Python et le frontend TS partagent le même échantillon JSON, génèrent respectivement dataclass et interface pour maintenir la cohérence des noms de champs.
• Migration de base de données : convertissez les documents JSON exportés depuis des champs MongoDB / PostgreSQL JSONB en modèles Python, comme référence pour la définition d'entités ORM. Les documents JSONB MongoDB exportés puis convertis en dataclass servent de référence de champs pour les entités ORM, plus faciles à maintenir que la lecture directe de documents MongoDB.
• Blockchain/Web3 : convertissez les réponses JSON RPC on-chain en dataclass Python, pour l'encapsulation de types de SDK comme web3.py. Les SDK Ethereum comme web3.py, eth-brownie prennent tous en charge les valeurs de retour de style dataclass, facilitant l'encapsulation secondaire.
• ETL de science des données : convertissez les sources de données JSON en amont en dataclass puis utilisez pandas DataFrame.from_records pour convertir en tableaux en vue d'analyses en aval. pandas DataFrame.from_records([asdict(d) for d in dataclass_list]) effectue en une ligne la conversion de structures imbriquées en tableaux.
• Validation de schéma OpenAPI : convertissez les exemples JSON des documents OpenAPI en modèles Python, puis écrivez la logique de validation pydantic. Le champ example d'OpenAPI peut être directement copié comme entrée de cet outil, le modèle Pydantic généré valide automatiquement la cohérence de la documentation API.
• Exemples pédagogiques : dans les cours Python, convertissez des exemples JSON en dataclass pour enseigner le module typing, les annotations de type, la génération automatique de __init__ et d'autres concepts. dataclass est le support de démonstration le plus direct pour enseigner le module typing, la génération automatique de __init__, slots et autres concepts dans les cours Python.
• Conversion de noms de champs : après conversion de réponses API JSON en snake_case en dataclass, modifiez manuellement les noms de champs, ou utilisez l'alias_generator de Pydantic pour le mappage de champs. L'alias_generator de Pydantic peut être configuré dans BaseModel pour un mappage automatique camelCase ↔ snake_case, évitant l'écriture manuelle d'alias.

Comment utiliser

1. Collez le contenu JSON dans l'éditeur de gauche, ou cliquez sur le bouton de téléchargement pour sélectionner un fichier .json / .txt
2. Attendez 400 ms pour la conversion automatique, le code Python dataclass généré s'affichera à droite
3. Si le format JSON est incorrect, cliquez sur le bouton « Réparer JSON » pour corriger automatiquement les problèmes de syntaxe courants
4. Cliquez sur « Copier » pour coller dans le répertoire models/ du projet, ou cliquez sur « Télécharger » pour sauvegarder en tant que fichier model.py

Fonctionnalités

• Conversion locale dans le navigateur : l'analyse JSON et la génération de code Python s'effectuent entièrement dans le navigateur, aucune donnée n'est envoyée à un serveur, utilisable en toute confiance pour des réponses API sensibles
• Sortie avec annotations dataclass : génère des classes Python standard décorées par @dataclass, utilisables directement dans des projets Python 3.7+ avec from __future__ import annotations
• Inférence de type automatique : str / int / float / bool / List[T] / Dict[str, Any] / Optional[Any] sont mappés automatiquement selon les valeurs JSON, pas besoin de spécifier manuellement les types des champs
• Séparation automatique des objets imbriqués : les objets JSON imbriqués génèrent des classes @dataclass indépendantes, nommées selon la capitalisation du nom de champ (ex. address -> Address), évite les définitions de types dupliquées
• Développement automatique des génériques List : les tableaux JSON sont automatiquement convertis en List[T], le type des éléments est inféré depuis le premier élément non null du tableau, par exemple ["a","b"] -> List[str], [{...},{...}] -> List[Item]
• Champs optionnels Optional : les champs null génèrent Optional[Any] comme solution de repli, garantissant que les annotations de type expriment correctement les cas où un champ peut manquer
• Conversion automatique avec anti-rebond de 400 ms : la conversion se déclenche automatiquement après collage, aperçu du code Python en temps réel à droite, réduit l'attente et les clics inutiles
• Réparation d'erreurs JSON en un clic : corrige automatiquement les erreurs courantes comme les virgules traînantes, guillemets simples, guillemets manquants, continue la génération de code après réparation réussie
• Copie et téléchargement : copiez tout le code Python en un clic, ou téléchargez-le en tant que fichier model.py à placer directement dans la racine du projet ou le sous-module models
• Historique des entrées localStorage : sauvegarde automatiquement les dernières entrées localement, permet une reprise rapide après actualisation ou fermeture accidentelle
• Édition à colonnes réactif : saisissez JSON à gauche, consultez le code Python à droite, prend en charge le redimensionnement des panneaux par glisser-déposer, adapté aux grands écrans et mobiles
• Prise en charge des adaptations secondaires Pydantic / attrs / TypedDict : la dataclass générée peut être adaptée en un clic avec BaseModel ou les décorateurs attrs pour FastAPI, Django Ninja, pydantic-settings et autres frameworks

Exemples de code

# 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()

    # Désérialiser directement la chaîne JSON en instance dataclass
    user: User = User(**resp.json())

    # Accès fortement typé : complétion IDE, vérification statique mypy/pyright
    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 valide automatiquement le corps de requête avec User, erreurs de type/champ obligatoire renvoient 422
    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 sérialise automatiquement la réponse, documentation OpenAPI générée automatiquement
    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]:
    """Désérialiser la chaîne JSON extraite par le scraping en liste d'Article."""
    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:
        # Complétion automatique IDE pour author.name, tags, summary
        print(f"[{art.score}] {art.title} - {art.author.name}")
        print(f"  tags: {art.tags}")

        # Pour une forme dict (comme écriture MongoDB), utilisez 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:
    """Schéma de caractéristiques d'échantillon, généré par l'outil JSON vers Python puis affiné."""
    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:
    """Convertir la liste JSON en DataFrame, utiliser automatiquement les noms de champs dataclass comme noms de colonnes."""
    rows = [asdict(FeatureSchema(**row)) for row in samples]
    df = pd.DataFrame(rows)
    # Encodage one-hot des champs catégoriels
    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]  # Étiquettes supposées : utilisateurs payants / utilisateurs gratuits

    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

FAQ

Dépannage

Glossaire

dataclass

Décorateur de bibliothèque standard Python 3.7+ (@dataclass), utilisé pour générer automatiquement des méthodes magiques comme __init__, __repr__, __eq__. Cet outil génère précisément des classes @dataclass, par exemple @dataclass class User: id: int; name: str. Essentiellement, il découple le « stockage des données » de la « manipulation des données », fait que la classe se concentre sur la description des champs de données, les méthodes boilerplate étant générées automatiquement par le décorateur.

module typing

Bibliothèque standard d'annotations de type Python, fournit des types génériques comme List, Dict, Optional, Any, Union. Les List[T], Optional[Any] générés par cet outil proviennent tous du module typing. Python 3.9+ peut utiliser directement les list, dict natifs. Aux côtés de collections.abc, contextlib, c'est le module central de la bibliothèque standard Python pour les contraintes de types statiques ; progressivement devenu la norme pour les grands projets depuis PEP 484.

Optional[T]

Type optionnel du module typing, équivaut à Union[T, None], indique qu'un champ peut être None. Cet outil mappe le null JSON vers Optional[Any], modifiable manuellement en Optional[str] ou d'autres types plus précis. Notez la différence entre Optional[T] et T = None valeur par défaut : le premier est une expression de None au niveau du type, le second un paramètre par défaut au niveau de la valeur.

List[T]

Type liste générique Python. Cet outil mappe automatiquement les tableaux JSON en List[T], par exemple un tableau de chaînes devient List[str], un tableau d'objets List[Item]. Python 3.9+ peut écrire list[T]. L'outil importe par défaut depuis le module typing, équivaut au list[T] natif de Python 3.9+ ; si l'équipe préfère la nouvelle syntaxe, l'import peut être remplacé en un clic.

Any

Type spécial du module typing, indique qu'il accepte n'importe quel type. Cet outil utilise Any comme solution de repli par défaut pour les valeurs null et les tableaux vides, pour éviter les erreurs d'inférence de type. L'utilisation fréquente d'Any fait perdre à mypy / pyright sa capacité de vérification, il est recommandé de remplacer par des types précis une fois le type du champ déterminé, par exemple Optional[str], List[int].

Pydantic BaseModel

Classe de base de modèle de données de la bibliothèque Pydantic, fournit la validation, sérialisation et désérialisation de données à l'exécution. La dataclass générée par cet outil peut être adaptée en un clic en BaseModel pour la validation du corps de requête FastAPI. Pydantic v2 a réécrit la logique de validation centrale en Rust, avec des performances 5 à 50 fois supérieures à v1 ; la dataclass générée par cet outil peut également hériter de BaseModel pour bénéficier de cette accélération.

FastAPI

Framework Web Python moderne, repose sur Pydantic pour la validation automatique du corps de requête. La dataclass générée par cet outil peut servir de modèle de requête/réponse pour les fonctions de route FastAPI. Basé sur Starlette + Pydantic, génère automatiquement la documentation OpenAPI, c'est l'un des frameworks d'API backend Python de référence aujourd'hui.

PEP 557

Proposition d'amélioration Python qui définit la syntaxe et le comportement du décorateur dataclass. Le code généré par cet outil est entièrement conforme à la norme PEP 557. Cette proposition a été initiée en 2017 par Eric V. Smith, s'inspirant des concepts de conception de solutions existantes comme attrs, Haskell record.

Annotation de type (Type Hint)

Indication de type annotée par : Type après les paramètres de fonction et variables Python. Tous les champs dataclass générés par cet outil comportent des annotations de type, utilisables avec mypy / pyright pour la vérification de type statique. Les annotations elles-mêmes n'affectent pas le comportement à l'exécution, elles servent uniquement à l'aide IDE, la vérification statique mypy / pyright, et aux bibliothèques de validation à l'exécution (comme Pydantic).

PEP 484

Proposition de norme d'annotations de type Python, définit le module typing et la syntaxe des génériques. Les List[T], Optional[T] générés par cet outil suivent PEP 484. Cette proposition a été rédigée conjointement par Guido van Rossum, Jukka Lehtosalo, Łukasz Langa et autres, c'est le document fondateur du système d'annotations de type Python.

from __future__ import annotations

Instruction d'évaluation différée des annotations introduite par PEP 563, fait que toutes les annotations sont stockées sous forme de chaînes, évitant les problèmes de référence avant. La dataclass générée par cet outil peut ajouter cette ligne pour rendre l'ordre de référence des annotations de type indifférent. Une fois activée, toutes les annotations sont évaluées paresseusement sous forme de chaînes, évitant les problèmes de référence avant (forward reference) et découplant l'ordre des champs dataclass de l'ordre des références.

model.py

Nom de fichier par défaut téléchargé par cet outil, conforme aux conventions des projets Python. Peut être renommé en user.py, schemas.py et autres noms adaptés à la structure du projet. Cohérent avec le style de nommage models.py de Django et Flask ; dans les projets multi-modèles, peut être divisé en sous-modules comme user.py, order.py dans le paquet models.

Tableau de correspondance rapide JSON vers types Python

L'outil infère automatiquement le type Python correspondant selon le type de valeur JSON :

Explication de la structure du code Python généré

Le code typique généré par quicktype-core pour Python comprend les parties suivantes :

Comparaison des solutions de modélisation de données Python

L'outil produit @dataclass par défaut, mais l'écosystème Python propose plusieurs solutions de modélisation de données, à choisir selon les besoins du projet :

Tableau de correspondance versions Python et fonctionnalités dataclass

Différentes versions Python prennent en charge différemment dataclass, typing et Pydantic, choisissez selon la version :

Privacy & Security

Toutes les opérations de cet outil JSON vers Python s'effectuent entièrement localement dans votre navigateur : l'analyse JSON, la génération de code Python et le téléchargement de fichiers sont tous exécutés côté client via JavaScript du navigateur, aucun contenu JSON, fichier téléchargé ou code généré n'est envoyé sur le réseau à un serveur quelconque. Le téléchargement de fichiers utilise l'API native FileReader du navigateur pour lire directement en mémoire, sans passer par aucun service intermédiaire. Pas de suivi par Cookie, aucune saisie utilisateur ou donnée d'utilisation n'est collectée. Après fermeture ou actualisation de la page, tous les contenus d'entrée et de sortie sont automatiquement effacés de la mémoire. Convient au traitement de JSON contenant des clés API, tokens, données métier sensibles.

Authoritative References

• PythonDocumentation officielle Python - dataclasses
• PythonDocumentation officielle Python - module typing
• PythonPEP 557 - Data Classes
• PydanticDocumentation officielle Pydantic - Models
• FastAPIDocumentation officielle FastAPI - Corps de requête
• PythonDocumentation officielle Python - module typing
• attrsDocumentation officielle attrs
• PythonPEP 484 - Type Hints