Ce didacticiel explique en détail comment gérer les données JSON en Python, en particulier lorsque la valeur d'un champ JSON doit être une autre cha?ne JSON complète et correctement échappée. En résolvant les problèmes spécifiques rencontrés lors de l'importation de données GeoJSON dans BigQuery SIG, l'article montre comment utiliser json.dumps pour une sérialisation étape par étape afin d'éviter les doubles échappements et de garantir la génération de fichiers JSON répondant aux exigences du format cible.

Comprendre les besoins et les défis des cha?nes JSON imbriquées

Lors du traitement des données, nous rencontrons parfois un besoin particulier : intégrer une structure JSON complète sous forme de cha?ne dans la valeur d'un autre champ JSON. Par exemple, lors de l'importation de données GeoJSON dans Google BigQuery SIG, BigQuery exige que le type de données du champ géométrique soit GEOGRAPHY, mais son contenu doit être une cha?ne et la cha?ne elle-même est un objet JSON conforme à la spécification GeoJSON, et les guillemets doubles internes doivent être correctement échappés.

Considérez le format JSON cible suivant?:

 {
  "geometry": "{\"type\": \"LineString\", \"coordonnées\": [[25.4907, 35.29833], [25.49187, 35.28897]]}"
}

Ici, la valeur du champ de géométrie est une cha?ne Python qui contient un objet GeoJSON LineString échappé en JSON.

Malentendus et problèmes courants

1. Dictionnaires directement imbriqués?: si la structure du dictionnaire Python est {"geometry": {"type": "LineString", ...}}, puis directement sérialisée à l'aide de json.dumps(), la sortie sera un objet JSON imbriqué au lieu d'une cha?ne?:

    {
     "géométrie": {
       "type": "Cha?neLigne",
       "coordonnées": [[25.4907, 35.29833], [25.49187, 35.28897]]
     }
   }

   Cela n'est pas conforme à la spécification BigQuery SIG selon laquelle les champs géométriques doivent être des cha?nes.

2. Remplacement manuel de cha?ne?: après avoir essayé de convertir le dictionnaire de géométrie en cha?ne, remplacez manuellement les guillemets doubles par une barre oblique inverse, telle que str(obj['geometry']).replace('"', '\\"'). Cette approche entra?ne souvent un double échappement, puisque json.dumps() échappera à nouveau aux barres obliques inverses existantes lors de la sérialisation finale, produisant \\?:

    {
     "geometry": "{\\\"type\\\": \\\"LineString\\\", \\\"coordonnées\\\": ...}"
   }

   Ce n'est évidemment pas ce que nous voulons, car BigQuery ou d'autres analyseurs l'interpréteront comme le \" littéral au lieu de ".

Le c?ur du problème est que la fonction json.dumps() de Python gère automatiquement l'échappement nécessaire (comme la conversion de " en \") lors de la sérialisation d'une cha?ne Python en cha?ne JSON. Nous devons profiter de cette fonctionnalité, mais veiller à ce que l'évasion ne se produise qu'une seule fois et au bon endroit.

Solution principale?: sérialisation JSON étape par étape

La clé pour résoudre ce problème est de comprendre le comportement de json.dumps() et d'effectuer une sérialisation étape par étape. Nous sérialisons d'abord la structure JSON interne (telle que le dictionnaire de géométrie) dans une cha?ne Python normale, qui contient déjà le JSON correct qui s'échappe en interne. Ensuite, nous utilisons cette cha?ne Python échappée comme valeur du champ JSON externe et la sérialisons à nouveau dans son ensemble.

Explication détaillée des étapes

1. Identifiez la structure JSON interne?: déterminez quel dictionnaire ou quelle liste doit être intégré sous forme de cha?ne.
2. Première sérialisation?: utilisez json.dumps() pour convertir cette structure JSON interne en cha?ne Python. à ce stade, json.dumps() échappera automatiquement les guillemets internes sous la forme \" pour générer une représentation sous forme de cha?ne conforme à la spécification JSON.
3. Construisez la structure externe?: utilisez la cha?ne Python générée à l'étape 2 comme valeur du champ correspondant dans le dictionnaire externe.
4. Sérialisation finale?: utilisez json.dumps() pour sérialiser le dictionnaire externe contenant les cha?nes traitées dans son intégralité. à ce stade, le json.dumps() externe traitera la cha?ne générée à l'étape 2 dans son ensemble et y ajoutera des guillemets externes sans échapper à nouveau au \" existant.

Exercice pratique : traiter les données GeoJSON

Ci-dessous, nous utiliserons un exemple GeoJSON FeatureCollection pour montrer comment appliquer la solution ci-dessus pour convertir le dictionnaire de géométrie de chaque entité en une cha?ne JSON correctement échappée.

Exemples de données

Supposons que nous ayons les données GeoJSON suivantes (version simplifiée, la structure réelle des données peut être trouvée dans l'exemple complet dans la description du problème)?:

 {
  "type": "Collection de fonctionnalités",
  "caractéristiques": [
    {
      "type": "Fonctionnalité",
      "géométrie": {
        "type": "Cha?neLigne",
        "coordonnées": [
          [121.51749976660096, 25.04609631049641],
          [121.51870845722954, 25.045781689873138]
        ]
      },
      "propriétés": {
        "modèle": {
          "ClasseRoute": "3",
          "RoadName": "Ligne 1 de Taiwan"
        }
      }
    }
    // ... plus de fonctionnalités
  ]
}

Implémentation du code Python

 importer json
à partir du chemin d'importation pathlib

# Simuler les données GeoJSON originales # Dans les applications réelles, cela peut provenir de la lecture de fichiers, d'une réponse API, etc. original_geojson_data = {
    "type": "Collection de fonctionnalités",
    "caractéristiques": [
        {
            "type": "Fonctionnalité",
            "géométrie": {
                "type": "Cha?neLigne",
                "coordonnées": [
                    [121.51749976660096, 25.04609631049641],
                    [121.51870845722954, 25.045781689873138]
                ]
            },
            "propriétés": {
                "modèle": {
                    "ClasseRoute": "3",
                    "RoadClassName": "Route générale provinciale",
                    "IDRoute": "300010",
                    "RoadName": "Ligne Taiwan 1",
                    "IDNomRoute": "10",
                    "InfoDate": "2015-04-01T00:00:00"
                }
            }
        },
        {
            "type": "Fonctionnalité",
            "géométrie": {
                "type": "Cha?neLigne",
                "coordonnées": [
                    [121.51913536000893, 25.045696164346566],
                    [121.51938079578713, 25.045646605406546]
                ]
            },
            "propriétés": {
                "modèle": {
                    "ClasseRoute": "3",
                    "RoadClassName": "Route générale provinciale",
                    "IDRoute": "300010",
                    "RoadName": "Ligne Taiwan 1",
                    "IDNomRoute": "10",
                    "InfoDate": "2015-04-01T00:00:00"
                }
            }
        }
    ]
}

# Chemin du fichier de sortie cible output_filepath = Path("processed_geojson_for_bigquery.json")

#Créer une liste pour stocker les fonctionnalités traitées
traits_traités = []

# Parcourez chaque fonctionnalité dans les données d'origine
pour la fonctionnalité dans original_geojson_data["features"]?:
    # 1. Extraire le dictionnaire de géométrie actuel Geometry_dict = feature["geometry"]

    # 2. Sérialisez le dictionnaire de géométrie dans une cha?ne JSON # Cette étape est clé, elle échappera correctement les guillemets doubles du dictionnaire vers \"
    geometry_as_string = json.dumps(geometry_dict)

    # 3. Réaffectez la cha?ne sérialisée à feature['geometry']
    # à l'heure actuelle, la valeur de feature['geometry'] est une cha?ne Python dont le contenu est échappé JSON
    feature["geometry"] = géométrie_as_string

    # Ajouter les fonctionnalités traitées à la liste Processed_features.append(feature)

# Construire la structure finale du dictionnaire de sortie # Réassembler le "type" et les "fonctionnalités" d'origine output_data = {
    "type": original_geojson_data["type"],
    "features": traitées_features
}

# écrivez les données finales dans le fichier JSON # indent=2 est utilisé pour embellir la sortie, Ensure_ascii=False garantit que les caractères non-ASCII (comme le chinois) sont affichés normalement avec output_filepath.open(mode="w", encoding="utf-8") comme fp?:
    json.dump(output_data, fp, indent=2, Ensure_ascii=False)

print(f"Le GeoJSON traité a été enregistré avec succès dans?: {output_filepath.resolve()}")

# Vérifiez le contenu du fichier de sortie (facultatif, vous pouvez ouvrir manuellement le fichier pour le visualiser)
# avec output_filepath.open(mode="r", encoding="utf-8") comme fp?:
# print("\n---Exemple de contenu du fichier de sortie---")
# print(fp.read())

Exemple de résultats de sortie

Après avoir exécuté le code ci-dessus, le contenu du fichier Processed_geojson_for_bigquery.json ressemblera à ceci (seule la partie géométrique de la première entité est affichée)?:

 {
  "type": "Collection de fonctionnalités",
  "caractéristiques": [
    {
      "type": "Fonctionnalité",
      "geometry": "{\"type\": \"LineString\", \"coordonnées\": [[121.51749976660096, 25.04609631049641], [121.51870845722954, 25.045781689873138]]}",
      "propriétés": {
        "modèle": {
          "ClasseRoute": "3",
          "RoadClassName": "Route générale provinciale",
          "IDRoute": "300010",
          "RoadName": "Ligne Taiwan 1",
          "IDNomRoute": "10",
          "InfoDate": "2015-04-01T00:00:00"
        }
      }
    },
    {
      "type": "Fonctionnalité",
      "geometry": "{\"type\": \"LineString\", \"coordonnées\": [[121.51913536000893, 25.045696164346566], [121.51938079578713, 25.045646605406546]]}",
      "propriétés": {
        "modèle": {
          "ClasseRoute": "3",
          "RoadClassName": "Route générale provinciale",
          "IDRoute": "300010",
          "RoadName": "Ligne Taiwan 1",
          "IDNomRoute": "10",
          "InfoDate": "2015-04-01T00:00:00"
        }
      }
    }
  ]
}

Comme vous pouvez le voir, la valeur du champ de géométrie est désormais une cha?ne entourée de guillemets doubles, et les guillemets doubles dans la structure JSON interne sont correctement échappés comme \", répondant aux exigences du format cible.

Notes et résumé

• Les fonctions de json.dumps() et json.loads()?:
  • json.dumps()?: sérialise les objets Python (tels que les dictionnaires, les listes) en cha?nes au format JSON.
  • json.loads()?: désérialise les cha?nes au format JSON en objets Python.
  • Comprendre le comportement de ces deux fonctions dans la gestion des échappements de cha?nes est essentiel pour résoudre des problèmes comme celui-ci.
• évitez l'échappement manuel?: n'essayez jamais d'ajouter manuellement des barres obliques inverses à une cha?ne pour vous échapper. Le module json de Python gère déjà ces détails pour vous, une intervention manuelle n'entra?nera qu'un double échappement ou d'autres erreurs.
• Ensure_ascii=False?: l'utilisation du paramètre Ensure_ascii=False dans json.dump() ou json.dumps() peut garantir que les caractères non-ASCII (tels que le chinois) ne sont pas échappés sous la forme \uXXXX lors de la sortie, mais sont affichés dans leur forme de caractère d'origine pour améliorer la lisibilité.
• Scénarios d'application?: cette méthode de sérialisation étape par étape s'applique non seulement aux scénarios dans lesquels GeoJSON est importé dans BigQuery SIG, mais également à toute situation dans laquelle une structure JSON doit être intégrée sous forme de cha?ne dans un autre champ JSON, comme les paramètres de certaines requêtes API, les champs de la base de données qui stockent les cha?nes JSON, etc.
• Vérification des données?: après avoir traité les données, il est recommandé d'effectuer une vérification des données pour s'assurer que le fichier généré répond aux exigences du système cible. Par exemple, vous pouvez utiliser json.loads() pour essayer de charger le fichier JSON généré afin de vérifier si la structure est correcte.

Grace à ce didacticiel, nous avons appris à utiliser intelligemment la fonction json.dumps() du module Python json pour générer des structures JSON complexes contenant des cha?nes JSON correctement échappées grace à une sérialisation étape par étape. Cette méthode évite la pénibilité et les erreurs liées à l'échappement manuel et garantit que les données de sortie répondent aux exigences strictes du système spécifique.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!