"json" --- JSON encoder and decoder
***********************************

**Code source :** Lib/json/__init__.py

======================================================================

JSON (JavaScript Object Notation), specified by **RFC 7159** (which
obsoletes **RFC 4627**) and by ECMA-404, is a lightweight data
interchange format inspired by JavaScript object literal syntax
(although it is not a strict subset of 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 super().default(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 is a subset of YAML 1.2.  The JSON produced by this module's
  default settings (in particular, the default *separators* value) is
  also a subset of YAML 1.0 and 1.1.  This module can thus also be
  used as a YAML serializer.

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.


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)

   Serialize *obj* as a JSON formatted stream to *fp* (a
   ".write()"-supporting *file-like object*) using this Python-to-JSON
   conversion table.

   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.

   Paramètres:
      * **obj** (*object*) -- The Python object to be serialized.

      * **fp** (*file-like object*) -- The file-like object *obj* will
        be serialized to. The "json" module always produces "str"
        objects, not "bytes" objects, therefore "fp.write()" must
        support "str" input.

      * **skipkeys** (*bool*) -- If "True", keys that are not of a
        basic type ("str", "int", "float", "bool", "None") will be
        skipped instead of raising a "TypeError". Default "False".

      * **ensure_ascii** (*bool*) -- If "True" (the default), the
        output is guaranteed to have all incoming non-ASCII characters
        escaped. If "False", these characters will be outputted as-is.

      * **check_circular** (*bool*) -- If "False", the circular
        reference check for container types is skipped and a circular
        reference will result in a "RecursionError" (or worse).
        Default "True".

      * **allow_nan** (*bool*) -- If "False", serialization of out-of-
        range "float" values ("nan", "inf", "-inf") will result in a
        "ValueError", in strict compliance with the JSON
        specification. If "True" (the default), their JavaScript
        equivalents ("NaN", "Infinity", "-Infinity") are used.

      * **cls** (a "JSONEncoder" subclass) -- If set, a custom JSON
        encoder with the "default()" method overridden, for
        serializing into custom datatypes. If "None" (the default),
        "JSONEncoder" is used.

      * **indent** (*int** | **str** | **None*) -- If a positive
        integer or string, JSON array elements and object members will
        be pretty-printed with that indent level. A positive integer
        indents that many spaces per level; a string (such as ""\t"")
        is used to indent each level. If zero, negative, or """" (the
        empty string), only newlines are inserted. If "None" (the
        default), the most compact representation is used.

      * **separators** (*tuple** | **None*) -- A two-tuple:
        "(item_separator, key_separator)". If "None" (the default),
        *separators* defaults to "(', ', ': ')" if *indent* is "None",
        and "(',', ': ')" otherwise. For the most compact JSON,
        specify "(',', ':')" to eliminate whitespace.

      * **default** (*callable* | None) -- A function that is called
        for objects that can't otherwise be serialized. It should
        return a JSON encodable version of the object or raise a
        "TypeError". If "None" (the default), "TypeError" is raised.

      * **sort_keys** (*bool*) -- If "True", dictionaries will be
        outputted sorted by key. Default "False".

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

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

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

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)

   Deserialize *fp* to a Python object using the JSON-to-Python
   conversion table.

   Paramètres:
      * **fp** (*file-like object*) -- A ".read()"-supporting *text
        file* or *binary file* containing the JSON document to be
        deserialized.

      * **cls** (a "JSONDecoder" subclass) -- If set, a custom JSON
        decoder. Additional keyword arguments to "load()" will be
        passed to the constructor of *cls*. If "None" (the default),
        "JSONDecoder" is used.

      * **object_hook** (*callable* | None) -- If set, a function that
        is called with the result of any object literal decoded (a
        "dict"). The return value of this function will be used
        instead of the "dict". This feature can be used to implement
        custom decoders, for example JSON-RPC class hinting. Default
        "None".

      * **object_pairs_hook** (*callable* | None) -- If set, a
        function that is called with the result of any object literal
        decoded with an ordered list of pairs. The return value of
        this function will be used instead of the "dict". This feature
        can be used to implement custom decoders. If *object_hook* is
        also set, *object_pairs_hook* takes priority. Default "None".

      * **parse_float** (*callable* | None) -- If set, a function that
        is called with the string of every JSON float to be decoded.
        If "None" (the default), it is equivalent to "float(num_str)".
        This can be used to parse JSON floats into custom datatypes,
        for example "decimal.Decimal".

      * **parse_int** (*callable* | None) -- If set, a function that
        is called with the string of every JSON int to be decoded. If
        "None" (the default), it is equivalent to "int(num_str)". This
        can be used to parse JSON integers into custom datatypes, for
        example "float".

      * **parse_constant** (*callable* | None) -- If set, a function
        that is called with one of the following strings:
        "'-Infinity'", "'Infinity'", or "'NaN'". This can be used to
        raise an exception if invalid JSON numbers are encountered.
        Default "None".

   Lève:
      * **JSONDecodeError** -- When the data being deserialized is not
        a valid JSON document.

      * **UnicodeDecodeError** -- When the data being deserialized
        does not contain UTF-8, UTF-16 or UTF-32 encoded data.

   Modifié dans la version 3.1:

   * Added the optional *object_pairs_hook* parameter.

   * *parse_constant* n'est plus appelée pour *null*, *true* ou
     *false*.

   Modifié dans la version 3.6:

   * tous les paramètres optionnels sont maintenant des keyword-only.

   * *fp* peut maintenant être un "binary file". Son encodage doit
     être UTF-8, UTF-16 ou UTF-32.

   Modifié dans la version 3.11: 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.

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

   Identical to "load()", but instead of a file-like object,
   deserialize *s* (a "str", "bytes" or "bytearray" instance
   containing a JSON document) to a Python object using this
   conversion table.

   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.

   Modifié dans la version 3.9: suppression de l’argument nommé
   *encoding*.


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*        | *int*               |
   | (nombre entier) |                     |
   +-----------------+---------------------+
   | *number*        | *float*             |
   | (nombre réel)   |                     |
   +-----------------+---------------------+
   | *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.

   *object_hook* is an optional function that will be called with the
   result of every JSON object decoded and its return value will be
   used in place of the given "dict".  This can be used to provide
   custom deserializations (e.g. to support JSON-RPC class hinting).

   *object_pairs_hook* is an optional function that will be called
   with the result of every JSON object decoded with an ordered list
   of pairs.  The return value of *object_pairs_hook* will be used
   instead of the "dict".  This feature can be used to implement
   custom decoders.  If *object_hook* is also defined, the
   *object_pairs_hook* takes priority.

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

   *parse_float* is an optional function that will be called with the
   string of every JSON float to be decoded.  By default, this is
   equivalent to "float(num_str)".  This can be used to use another
   datatype or parser for JSON floats (e.g. "decimal.Decimal").

   *parse_int* is an optional function that will be called with the
   string of every JSON int to be decoded.  By default, this is
   equivalent to "int(num_str)".  This can be used to use another
   datatype or parser for JSON integers (e.g. "float").

   *parse_constant* is an optional function that will be called with
   one of the following strings: "'-Infinity'", "'Infinity'", "'NaN'".
   This can be used to raise an exception if invalid JSON numbers are
   encountered.

   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 *n*-uplet 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      | *number*        |
   | d'*int* ou de *float*                    |                 |
   +------------------------------------------+-----------------+
   | *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*.

   To extend this to recognize other objects, subclass and implement a
   "default()" method with another method that returns a serializable
   object for "o" if possible, otherwise it should call the superclass
   implementation (to raise "TypeError").

   If *skipkeys* is false (the default), a "TypeError" will be raised
   when trying to encode keys that are not "str", "int", "float",
   "bool" or "None".  If *skipkeys* is true, such items are simply
   skipped.

   Si *ensure_ascii* vaut "True" (valeur par défaut), les caractères
   non ASCII sont tous échappés à la sortie. Si *ensure_ascii* vaut
   "False", ils 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
   "RecursionError"). 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 espaces.

   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 composée d'objets Python sérialisable
   en JSON ou lever une "TypeError". Si non spécifié, une "TypeError"
   est levée.

   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").

      For example, to support arbitrary iterators, you could implement
      "default()" like this:

         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 super().default(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*.

   Ajouté dans la version 3.5.


Conformité au standard et Interopérabilité
==========================================

The JSON format is specified by **RFC 7159** and by ECMA-404. This
section details this module's level of compliance with the RFC. For
simplicity, "JSONEncoder" and "JSONDecoder" subclasses, and parameters
other than those explicitly mentioned, are not considered.

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.

If the optional "infile" and "outfile" arguments are not specified,
"sys.stdin" and "sys.stdout" will be used respectively:

   $ 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
          }
      ]

   If *infile* is not specified, read from "sys.stdin".

outfile

   Write the output of the *infile* to the given *outfile*. Otherwise,
   write it to "sys.stdout".

--sort-keys

   Trie alphabétiquement les dictionnaires par clés.

   Ajouté dans la version 3.5.

--no-ensure-ascii

   Désactive l’échappement des caractères non ASCII, voir
   "json.dumps()" pour plus d'informations.

   Ajouté dans la version 3.9.

--json-lines

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

   Ajouté dans la version 3.8.

--indent, --tab, --no-indent, --compact

   Options mutuellement exclusives de contrôle des espaces.

   Ajouté dans la version 3.9.

-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.
