# `json` — Encodage et décodage JSON

Code source : Lib/json/__init__.py

JSON (JavaScript Object Notation), décrit par la RFC 7159 (qui rend la RFC 4627 obsolète) et par le standard ECMA-404, est un format très simple d'échange de données inspiré par la syntaxe des objets littéraux de JavaScript (bien que ce ne soit pas au sens propre un sous-ensemble de Javascript 1 ).

Avertissement

Be cautious when parsing JSON data from untrusted sources. A malicious JSON string may cause the decoder to consume considerable CPU and memory resources. Limiting the size of data to be parsed is recommended.

`json` fournit une API familière aux utilisateurs des modules `marshal` et `pickle` de la bibliothèque standard.

Encodage de quelques objets de base Python :

    >>> import json
    >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
    '["foo", {"bar": ["baz", null, 1.0, 2]}]'
    >>> print(json.dumps("\"foo\bar"))
    "\"foo\bar"
    >>> print(json.dumps('\u1234'))
    "\u1234"
    >>> print(json.dumps('\\'))
    "\\"
    >>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True))
    {"a": 0, "b": 0, "c": 0}
    >>> from io import StringIO
    >>> io = StringIO()
    >>> json.dump(['streaming API'], io)
    >>> io.getvalue()
    '["streaming API"]'

Encodage compact :

    >>> import json
    >>> json.dumps([1, 2, 3, {'4': 5, '6': 7}], separators=(',', ':'))
    '[1,2,3,{"4":5,"6":7}]'

Affichage plus lisible :

    >>> import json
    >>> print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4))
    {
        "4": 5,
        "6": 7
    }

Décodage JSON :

    >>> import json
    >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]')
    ['foo', {'bar': ['baz', None, 1.0, 2]}]
    >>> json.loads('"\\"foo\\bar"')
    '"foo\x08ar'
    >>> from io import StringIO
    >>> io = StringIO('["streaming API"]')
    >>> json.load(io)
    ['streaming API']

Spécialisation du décodage JSON pour un objet :

    >>> import json
    >>> def as_complex(dct):
    ...     if '__complex__' in dct:
    ...         return complex(dct['real'], dct['imag'])
    ...     return dct
    ...
    >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',
    ...     object_hook=as_complex)
    (1+2j)
    >>> import decimal
    >>> json.loads('1.1', parse_float=decimal.Decimal)
    Decimal('1.1')

Extension de la classe `JSONEncoder` :

    >>> import json
    >>> class ComplexEncoder(json.JSONEncoder):
    ...     def default(self, obj):
    ...         if isinstance(obj, complex):
    ...             return [obj.real, obj.imag]
    ...         # Let the base class default method raise the TypeError
    ...         return json.JSONEncoder.default(self, obj)
    ...
    >>> json.dumps(2 + 1j, cls=ComplexEncoder)
    '[2.0, 1.0]'
    >>> ComplexEncoder().encode(2 + 1j)
    '[2.0, 1.0]'
    >>> list(ComplexEncoder().iterencode(2 + 1j))
    ['[2.0', ', 1.0', ']']

Utilisation du module `json.tool` depuis l'invite de commandes pour valider un flux et l'afficher lisiblement :

    $ echo '{"json":"obj"}' | python -m json.tool
    {
        "json": "obj"
    }
    $ echo '{1.2:3.4}' | python -m json.tool
    Expecting property name enclosed in double quotes: line 1 column 2 (char 1)

Voir Interface en ligne de commande pour une documentation détaillée.

Note

JSON est un sous-ensemble de YAML 1.2. Le JSON produit par les paramètres par défaut de ce module (en particulier, la valeur par défaut de separators) est aussi un sous-ensemble de YAML 1.0 et 1.1. Ce module peut alors aussi être utilisé comme sérialiseur YAML.

Note

Les encodeurs et décodeurs de ce module conservent l'ordre d'entrée et de sortie par défaut. L'ordre n'est perdu que si les conteneurs sous-jacents ne sont pas ordonnés.

Avant Python 3.7, `dict` n'était pas garanti d'être ordonné, donc les entrées et sorties étaient généralement mélangées à moins d'utiliser explicitement un `collections.OrderedDict`. À partir de Python 3.7, un `dict` conserve son ordre, il n'est donc plus nécessaire d'utiliser un `collections.OrderedDict` pour générer et analyser du JSON.

## Utilisation de base

`json.``dump`(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

  Sérialise obj en un flux JSON dans fp (un objet compatible fichier prenant en charge `.write()`), en utilisant cette table de conversion.

  Si skipkeys vaut `True` (`False` par défaut), alors les clefs de dictionnaire qui ne sont pas des types de base (`str`, `int`, `float`, `bool`, `None`) sont ignorées. Elles provoquent normalement la levée d'une `TypeError`.

  Le module `json` produit toujours des objets `str`, et non des objets `bytes`. `fp.write()` doit ainsi prendre en charge un objet `str` en entrée.

  Si ensure_ascii vaut `True` (valeur par défaut), il est garanti que les caractères non ASCII soient tous échappés à la sortie. Si ensure_ascii vaut `False`, ces caractères sont écrits tels quels.

  Si check_circular vaut `False` (`True` par défaut), la vérification des références circulaires pour les conteneurs est ignorée, et une référence circulaire résulte en une `OverflowError` (ou pire).

  Si allow_nan vaut `False` (`True` par défaut), une `ValueError` est levée lors de la sérialisation de valeurs `float` extérieures aux bornes (`nan`, `inf`, `-inf`), en respect strict de la spécification JSON. Si allow_nan vaut `True`, leurs équivalents JavaScript (`NaN`, `Infinity`, `-Infinity`) sont utilisés.

  Si indent est un nombre entier positif ou une chaîne de caractères, les éléments de tableaux et les membres d'objets JSON sont affichés élégamment avec ce niveau d'indentation. Un niveau d'indentation de 0, négatif, ou `""` n'insère que des retours à la ligne. `None` (la valeur par défaut) choisit la représentation la plus compacte. Utiliser un entier positif pour indent indente d'autant d'espaces par niveau. Si indent est une chaîne (telle que `"\t"`), cette chaîne est utilisée pour indenter à chaque niveau.

  Modifié dans la version 3.2: Autorise les chaînes en plus des nombres entiers pour indent.

  Si spécifié, separators doit être un n-uplet `(item_separator, key_separator)`. Sa valeur par défaut est `(', ', ': ')` si indent est `None`, et `(',', ': ')` autrement. Pour obtenir la représentation JSON la plus compacte possible, passez `(',', ':')` pour éliminer les espacements.

  Modifié dans la version 3.4: Utilise `(',', ': ')` par défaut si indent n'est pas `None`.

  Si spécifié, default doit être une fonction qui sera appelée pour les objets qui ne peuvent être sérialisés autrement. Elle doit renvoyer une représentation de l'objet sérialisable en JSON ou lever une `TypeError`. Si non spécifié, une `TypeError` est levée pour les types non sérialisables.

  Si sort_keys vaut `True` (`False` par défaut), les dictionnaires sont retranscrits triés selon leurs clés.

  Pour utiliser une sous-classe `JSONEncoder` personnalisée (p. ex. une qui redéfinit la méthode `default()` pour sérialiser des types additionnels), spécifiez-la avec le paramètre nommé cls ; autrement, `JSONEncoder` est utilisée.

  Modifié dans la version 3.6: tous les paramètres optionnels sont maintenant des keyword-only.

  Note

  À l'inverse de `pickle` et `marshal`, JSON n'est pas un protocole par trames, donc essayer de sérialiser plusieurs objets par des appels répétés à `dump()` en utilisant le même fp résulte en un fichier JSON invalide.

`json.``dumps`(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

  Sérialise obj en une `str` formatée en JSON, en utilisant cette table de conversion. Les arguments ont la même signification que ceux de `dump()`.

  Note

  Les clés dans les couples JSON clé-valeur sont toujours de type `str`. Quand un dictionnaire est converti en JSON, toutes les clés du dictionnaire sont transformées en chaînes de caractères. Ce qui fait que si un dictionnaire est converti en JSON et reconverti en dictionnaire, le résultat peut ne pas être égal à l'original. Ainsi, `loads(dumps(x)) != x` si x contient des clés qui ne sont pas des chaînes.

`json.``load`(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

  Déserialise fp (un text file ou un binary file supportant `.read()` et contenant un document JSON) vers un objet Python en utilisant cette table de conversion.

  object_hook est une fonction optionnelle qui est appelée avec le résultat de chaque objet littéral décodé (chaque `dict`). La valeur de retour de object_hook est utilisée à la place du `dict`. Cette fonctionnalité peut être utilisée pour implémenter des décodeurs personnalisés (p. ex. les class hinting de JSON-RPC).

  object_pairs_hook est une fonction optionnelle qui est appelée pour chaque objet littéral décodé, avec une liste ordonnée de couples. La valeur de retour de object_pairs_hook est utilisée à la place du `dict`. Cette fonctionnalité peut être utilisée pour implémenter des décodeurs personnalisés. object_pairs_hook prend la priorité sur object_hook, si cette dernière est aussi définie.

  Modifié dans la version 3.1: ajout du support de object_pairs_hook.

  Si parse_float est définie, elle est appelée avec chaque nombre réel JSON à décoder, sous forme d'une chaîne de caractères, en argument. Par défaut, elle est équivalente à `float(num_str)`. Cela peut servir à utiliser un autre type de données ou un autre analyseur pour les nombres réels JSON (p. ex. `decimal.Decimal`).

  Si parse_int est définie, elle est appelée avec chaque nombre entier JSON à décoder, sous forme d'une chaîne de caractères, en argument. Par défaut, elle est équivalente à `int(num_str)`. Cela peut servir à utiliser un autre type de données ou un autre analyseur pour les nombres entiers JSON (p. ex. `float`).

  Modifié dans la version 3.8.14: The default parse_int of `int()` now limits the maximum length of the integer string via the interpreter's integer string conversion length limitation to help avoid denial of service attacks.

  Si parse_constant est définie, elle est quand l'une des chaînes de caractères suivantes est rencontrée : `'-Infinity'`, `'Infinity'` ou `'NaN'`. Cela peut servir à lever une exception si des nombres JSON invalides sont rencontrés.

  Modifié dans la version 3.1: parse_constant n'est plus appelée pour null, true ou false.

  Pour utiliser une sous-classe `JSONDecoder` personnalisée, spécifiez-la avec l'argument nommé `cls` ; autrement, `JSONDecoder` est utilisée. Les arguments nommés additionnels sont passés au constructeur de cette classe.

  Si les données à désérialiser ne sont pas un document JSON valide, une `JSONDecodeError` est levée.

  Modifié dans la version 3.6: tous les paramètres optionnels sont maintenant des keyword-only.

  Modifié dans la version 3.6: fp peut maintenant être un `binary file`. Son encodage doit être UTF-8, UTF-16 ou UTF-32.

`json.``loads`(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

  Déserialise s (une instance de `str`, `bytes` ou `bytearray` contenant un document JSON) vers un objet Python en utilisant cette table de conversion.

  Les autres arguments ont la même signification que pour `load()`, à l'exception d'encoding qui est ignoré et obsolète depuis Python 3.1.

  Si les données à désérialiser ne sont pas un document JSON valide, une `JSONDecodeError` est levée.

  Deprecated since version 3.1, will be removed in version 3.9: L'argument nommé encodage.

  Modifié dans la version 3.6: s peut maintenant être de type `bytes` ou `bytearray`. L'encodage d'entrée doit être UTF-8, UTF-16 ou UTF-32.

## Encodeurs et décodeurs

class `json.``JSONDecoder`(*, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None)

  Décodeur simple JSON.

  Applique par défaut les conversions suivantes en décodant :

  JSON | Python
  --- | ---
  objet | dict
  array | list
  string | str
  number (nombre entier) | int
  number (nombre réel) | float
  true | True
  false | False
  null | `None`

  Les valeurs `NaN`, `Infinity` et `-Infinity` sont aussi comprises comme leurs valeurs `float` correspondantes, bien que ne faisant pas partie de la spécification JSON.

  Si object_hook est définie, elle sera appelée avec le résultat de chaque objet JSON décodé et sa valeur de retour est utilisée à la place du `dict` donné. Cela est utile pour apporter des déserialisations personnalisées (p. ex. pour supporter les class hinting de JSON-RPC).

  Si object_pairs_hook est donnée, elle sera appelée avec le résultat de chaque objet JSON décodé avec une liste ordonnée de couples. Sa valeur de retour est utilisée à la place du `dict`. Cette fonctionnalité peut être utilisée pour implémenter des décodeurs personnalisés. object_pairs_hook prend la priorité sur object_hook, si cette dernière est aussi définie.

  Modifié dans la version 3.1: ajout du support de object_pairs_hook.

  Si parse_float est définie, elle est appelée avec chaque nombre réel JSON à décoder, sous forme d'une chaîne de caractères, en argument. Par défaut, elle est équivalente à `float(num_str)`. Cela peut servir à utiliser un autre type de données ou un autre analyseur pour les nombres réels JSON (p. ex. `decimal.Decimal`).

  Si parse_int est définie, elle est appelée avec chaque nombre entier JSON à décoder, sous forme d'une chaîne de caractères, en argument. Par défaut, elle est équivalente à `int(num_str)`. Cela peut servir à utiliser un autre type de données ou un autre analyseur pour les nombres entiers JSON (p. ex. `float`).

  Si parse_constant est définie, elle est quand l'une des chaînes de caractères suivantes est rencontrée : `'-Infinity'`, `'Infinity'` ou `'NaN'`. Cela peut servir à lever une exception si des nombres JSON invalides sont rencontrés.

  Si strict vaut `False` (`True` par défaut), alors les caractères de contrôle sont autorisés à l'intérieur des chaînes. Les caractères de contrôle dans ce contexte sont ceux dont les codes sont dans l'intervalle 0--31, incluant `'\t'` (tabulation), `'\n'`, `'\r'` et `'\0'`.

  Si les données à désérialiser ne sont pas un document JSON valide, une `JSONDecodeError` est levée.

  Modifié dans la version 3.6: Tous les paramètres sont maintenant des keyword-only.

  `decode`(s)

    Renvoie la représentation Python de s (une instance `str` contenant un document JSON).

    Une `JSONDecodeError` est levée si le document JSON donné n'est pas valide.

  `raw_decode`(s)

    Décode en document JSON depuis s (une instance `str` débutant par un document JSON) et renvoie un tuple de 2 éléments contenant la représentation Python de l'objet et l'index dans s où le document se terminait.

    Elle peut être utilisée pour décoder un document JSON depuis une chaîne qui peut contenir des données supplémentaires à la fin.

class `json.``JSONEncoder`(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

  Encodeur JSON extensible pour les structures de données Python.

  Prend en charge par défaut les objets et types suivants :

  Python | JSON
  --- | ---
  dict | objet
  list, tuple | array
  str | string
  int, float, et Enums dérivées d'int ou de float | number
  True | true
  False | false
  `None` | null

  Modifié dans la version 3.4: ajout de la prise en charge des classes Enum dérivées d'int ou de float.

  Pour l'étendre afin de reconnaître d'autres types d'objets, il suffit d'en créer une sous-classe et d'implémenter une nouvelle méthode `default()` qui renvoie un objet sérialisable pour `o` si cela est possible, ou bien il convient d'appeler l'implémentation de la classe mère (pour lever une `TypeError`).

  Si skipkeys vaut `False` (valeur par défaut), une `TypeError` est levée lors de l'encodage de clés autres que des `str`, des `int`, des `float` ou `None`. Si skipkeys vaut `True`, ces éléments sont simplement ignorés.

  Si ensure_ascii vaut `True` (valeur par défaut), il est garanti que les caractères non ASCII soient tous échappés à la sortie. Si ensure_ascii vaut `False`, ces caractères sont écrits tels quels.

  Si check_circular vaut `True` (valeur par défaut), une vérification a lieu sur les listes, dictionnaires et objets personnalisés, afin de détecter les références circulaires et éviter les récursions infinies (qui causeraient une `OverflowError`). Autrement, la vérification n'a pas lieu.

  Si allow_nan vaut `True` (valeur par défaut), alors `NaN`, `Infinity` et `-Infinity` sont encodés comme tels. Ce comportement ne respecte pas la spécification JSON, mais est cohérent avec le majorité des encodeurs-décodeurs JavaScript. Autrement, une `ValueError` est levée pour de telles valeurs.

  Si sort_keys vaut `True` (`False` par défaut), alors les dictionnaires sont triés par clés en sortie ; cela est utile lors de tests de régression pour pouvoir comparer les sérialisations JSON au jour le jour.

  Si indent est un nombre entier positif ou une chaîne de caractères, les éléments de tableaux et les membres d'objets JSON sont affichés élégamment avec ce niveau d'indentation. Un niveau d'indentation de 0, négatif, ou `""` n'insère que des retours à la ligne. `None` (la valeur par défaut) choisit la représentation la plus compacte. Utiliser un entier positif pour indent indente d'autant d'espaces par niveau. Si indent est une chaîne (telle que `"\t"`), cette chaîne est utilisée pour indenter à chaque niveau.

  Modifié dans la version 3.2: Autorise les chaînes en plus des nombres entiers pour indent.

  Si spécifié, separators doit être un n-uplet `(item_separator, key_separator)`. Sa valeur par défaut est `(', ', ': ')` si indent est `None`, et `(',', ': ')` autrement. Pour obtenir la représentation JSON la plus compacte possible, passez `(',', ':')` pour éliminer les espacements.

  Modifié dans la version 3.4: Utilise `(',', ': ')` par défaut si indent n'est pas `None`.

  Si spécifié, default doit être une fonction qui sera appelée pour les objets qui ne peuvent être sérialisés autrement. Elle doit renvoyer une représentation de l'objet sérialisable en JSON ou lever une `TypeError`. Si non spécifié, une `TypeError` est levée pour les types non sérialisables.

  Modifié dans la version 3.6: Tous les paramètres sont maintenant des keyword-only.

  `default`(o)

    Implémentez cette méthode dans une sous-classe afin qu'elle renvoie un objet sérialisable pour o, ou appelle l'implémentation de base (qui lèvera une `TypeError`).

    Par exemple, pour supporter des itérateurs arbitraires, vous pouvez implémenter default comme cela :

        def default(self, o):
           try:
               iterable = iter(o)
           except TypeError:
               pass
           else:
               return list(iterable)
           # Let the base class default method raise the TypeError
           return json.JSONEncoder.default(self, o)

  `encode`(o)

    Renvoie une chaîne JSON représentant la structure de données Python o. Par exemple :

        >>> json.JSONEncoder().encode({"foo": ["bar", "baz"]})
        '{"foo": ["bar", "baz"]}'

  `iterencode`(o)

    Encode l'objet o donné, et produit chaque chaîne représentant l'objet selon disponibilité. Par exemple :

        for chunk in json.JSONEncoder().iterencode(bigobject):
            mysocket.write(chunk)

## Exceptions

exception `json.``JSONDecodeError`(msg, doc, pos)

  Sous-classe de `ValueError` avec les attributs additionnels suivants :

  `msg`

    Le message d'erreur non formaté.

  `doc`

    Le document JSON en cours de traitement.

  `pos`

    L'index de doc à partir duquel l'analyse a échoué.

  `lineno`

    La ligne correspondant à pos.

  `colno`

    La colonne correspondant à pos.

  Nouveau dans la version 3.5.

## Conformité au standard et Interopérabilité

Le format JSON est décrit par la RFC 7159 et le standard ECMA-404. Cette section détaille la conformité à la RFC au niveau du module. Pour faire simple, les sous-classes de `JSONEncoder` et `JSONDecoder`, et les paramètres autres que ceux explicitement mentionnés ne sont pas considérés.

Ce module ne se conforme pas strictement à la RFC, implémentant quelques extensions qui sont valides en JavaScript mais pas en JSON. En particulier :

- Les nombres infinis et NaN sont acceptés et retranscrits ;

- Les noms répétés au sein d'un objet sont acceptés, seule la valeur du dernier couple nom-valeur est utilisée.

Comme la RFC permet aux analyseurs conformes d'accepter en entrée des textes non conformes, le désérialiseur de ce module avec ses paramètres par défaut est techniquement conforme à la RFC.

### Encodage des caractères

La RFC requiert que le JSON soit représenté en utilisant l'encodage UTF-8, UTF-16 ou UTF-32, avec UTF-8 recommandé par défaut pour une interopérabilité maximale.

Comme cela est permis par la RFC, bien que non requis, le sérialiseur du module active ensure_ascii=True par défaut, échappant ainsi la sortie de façon à ce que les chaînes résultants ne contiennent que des caractères ASCII.

Outre le paramètre ensure_ascii, les conversions entre objets Python et `chaînes Unicode` de ce module sont strictement définies, et ne résolvent donc pas directement le problème de l'encodage des caractères.

La RFC interdit d'ajouter un octet marqueur d'ordre (byte mark order ou BOM) au début du texte JSON, et le sérialiseur de ce module n'ajoute pas de tel BOM. La RFC permet, mais ne requiert pas, que les désérialiseurs JSON ignorent ces BOM. Le désérialiseur de ce module lève une `ValueError` quand un BOM est présent au début du fichier.

La RFC n'interdit pas explicitement les chaînes JSON contenant des séquences d'octets ne correspondant à aucun caractère Unicode valide (p. ex. les surrogates UTF-16 sans correspondance), mais précise que cela peut causer des problèmes d'interopérabilité. Par défaut, ce module accepte et retranscrit (quand présents dans la `str` originale) les code points de telles séquences.

### Valeurs numériques infinies et NaN

La RFC ne permet pas la représentation des nombres infinis ou des NaN. Néanmoins, par défaut, ce module accepte et retranscrit `Infinity`, `-Infinity` et `NaN` comme s'ils étaient des valeurs numériques littérales JSON valides :

    >>> # Neither of these calls raises an exception, but the results are not valid JSON
    >>> json.dumps(float('-inf'))
    '-Infinity'
    >>> json.dumps(float('nan'))
    'NaN'
    >>> # Same when deserializing
    >>> json.loads('-Infinity')
    -inf
    >>> json.loads('NaN')
    nan

Dans le sérialiseur, le paramètre allow_nan peut être utilisé pour altérer ce comportement. Dans le désérialiseur, le paramètre parse_constant peut être utilisé pour changer ce comportement.

### Noms répétés au sein d'un objet

La RFC précise que les noms au sein d'un objet JSON doivent être uniques, mais ne décrit pas comment les noms répétés doivent être gérés. Par défaut, ce module ne lève pas d'exception ; à la place, il ignore tous les couples nom-valeur sauf le dernier pour un nom donné :

    >>> weird_json = '{"x": 1, "x": 2, "x": 3}'
    >>> json.loads(weird_json)
    {'x': 3}

Le paramètre object_pairs_hook peut être utilisé pour modifier ce comportement.

### Valeurs de plus haut niveau (hors objets ou tableaux)

L'ancienne version de JSON définie par l'obsolète RFC 4627 demandait à ce que la valeur de plus haut niveau du texte JSON soit un objet ou un tableau JSON (`dict` ou `list` Python), et ne soit pas null, un nombre, ou une chaîne de caractères. La RFC 7159 a supprimé cette restriction, jamais implémentée par ce module, que ce soit dans le sérialiseur ou le désérialiseur.

Cependant, pour une interopérabilité maximale, vous pourriez volontairement souhaiter adhérer à cette restriction.

### Limitations de l'implémentation

Certaines implémentations de désérialiseurs JSON peuvent avoir des limites sur :

- la taille des textes JSON acceptés ;

- le niveau maximum d'objets et tableaux JSON imbriqués ;

- l'intervalle et la précision des nombres JSON ;

- le contenu et la longueur maximale des chaînes JSON.

Ce module n'impose pas de telles limites si ce n'est celles inhérentes aux types de données Python ou à l'interpréteur.

Lors d'une sérialisation JSON, faites attention à ces limitations dans les applications qui utilisent votre JSON. En particulier, il est courant pour les nombres JSON d'être désérialisés vers des nombres IEEE 754 à précision double, et donc sujets à l'intervalle et aux limitations sur la précision de cette représentation. Cela est d'autant plus important lors de la sérialisation de grands `int` Python, ou d'instances de types numériques « exotiques » comme `decimal.Decimal`.

## Interface en ligne de commande

Code source : Lib/json/tool.py

Le module `json.tool` fournit une simple interface en ligne de commande pour valider et réécrire élégamment des objets JSON.

Si les arguments optionnels `infile` et `outfile` ne sont pas spécifiés, `sys.stdin` et `sys.stdout` sont utilisés respectivement :

    $ echo '{"json": "obj"}' | python -m json.tool
    {
        "json": "obj"
    }
    $ echo '{1.2:3.4}' | python -m json.tool
    Expecting property name enclosed in double quotes: line 1 column 2 (char 1)

Modifié dans la version 3.5: La sortie conserve maintenant l'ordre des données de l'entrée. Utilisez l'option `--sort-keys` pour sortir des dictionnaires triés alphabétiquement par clés.

### Options de la ligne de commande

`infile```

  Le fichier JSON à valider ou réécrire élégamment :

      $ python -m json.tool mp_films.json
      [
          {
              "title": "And Now for Something Completely Different",
              "year": 1971
          },
          {
              "title": "Monty Python and the Holy Grail",
              "year": 1975
          }
      ]

  Si infile n'est pas spécifié, lit le document depuis `sys.stdin`.

`outfile```

  Écrit la sortie générée par infile vers le fichier outfile donné. Autrement, écrit sur `sys.stdout`.

`--sort-keys```

  Trie alphabétiquement les dictionnaires par clés.

  Nouveau dans la version 3.5.

`--json-lines```

  Transforme chaque ligne d'entrée en un objet JSON individuel.

  Nouveau dans la version 3.8.

`-h````,` `--help```

  Affiche le message d'aide.

Notes

1

  Comme noté dans l'errata de la RFC 7159, JSON autorise les caractères littéraux U+2028 (LINE SEPARATOR) et U+2029 (PARAGRAPH SEPARATOR) dans les chaînes de caractères, alors que Javascript (selon le standard ECMAScript édition 5.1) ne le permet pas.