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({'6': 7, '4': 5}, sort_keys=True, indent=4))
{
"4": 5,
"6": 7
}
Specializing JSON object encoding:
>>> import json
>>> def custom_json(obj):
... if isinstance(obj, complex):
... return {'__complex__': True, 'real': obj.real, 'imag': obj.imag}
... raise TypeError(f'Cannot serialize object of {type(obj)}')
...
>>> json.dumps(1 + 2j, default=custom_json)
'{"__complex__": true, "real": 1.0, "imag": 2.0}'
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', ']']
Using json
from the shell to validate and pretty-print:
$ echo '{"json":"obj"}' | python -m json
{
"json": "obj"
}
$ echo '{1.2:3.4}' | python -m json
Expecting property name enclosed in double quotes: line 1 column 2 (char 1)
Voir Command-line interface 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)¶
Sérialise obj en un flux JSON dans fp (un objet 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'uneTypeError
.Le module
json
produit toujours des objetsstr
, et non des objetsbytes
.fp.write()
doit ainsi prendre en charge un objetstr
en entrée.Si ensure_ascii vaut
True
(valeur par défaut), les caractères non ASCII sont tous échappés à la sortie. Si ensure_ascii vautFalse
, ils 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 cause uneRecursionError
(ou pire).Si allow_nan vaut
False
(True
par défaut), uneValueError
est levée lors de la sérialisation de valeursfloat
extérieures aux bornes (nan
,inf
,-inf
), en respect avec la spécification JSON. Si allow_nan vautTrue
, les é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 estNone
, 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 pasNone
.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é, uneTypeError
est levée.Si sort_keys vaut
True
(False
par défaut), les dictionnaires sont retranscrits triés selon leurs clés.To use a custom
JSONEncoder
subclass (e.g. one that overrides thedefault()
method to serialize additional types), specify it with the cls kwarg; otherwiseJSONEncoder
is used.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 dedump()
.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 is an optional function that will be called with the result of any object literal decoded (a
dict
). The return value of object_hook will be used instead of thedict
. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting).object_pairs_hook is an optional function that will be called with the result of any object literal 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
).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.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.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
oubytearray
contenant un document JSON) vers un objet Python en utilisant cette table de conversion.Les autres arguments ont la même signification que dans
load()
.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: s peut maintenant être de type
bytes
oubytearray
. 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 (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 valeursfloat
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 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.
To extend this to recognize other objects, subclass and implement a
default()
method with another method that returns a serializable object foro
if possible, otherwise it should call the superclass implementation (to raiseTypeError
).Si skipkeys vaut
False
(valeur par défaut), uneTypeError
est levée si la clé encodée n'est pas de typestr
,int
,float
ouNone
. Si skipkeys vautTrue
, ces éléments sont simplement ignorés.Si ensure_ascii vaut
True
(valeur par défaut), les caractères non ASCII sont tous échappés à la sortie. Si ensure_ascii vautFalse
, 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 uneRecursionError
). Autrement, la vérification n'a pas lieu.Si allow_nan vaut
True
(valeur par défaut), alorsNaN
,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, uneValueError
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 estNone
, 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 pasNone
.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é, uneTypeError
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
.
Command-line interface¶
Code source : Lib/json/tool.py
The json
module can be invoked as a script via python -m json
to validate and pretty-print JSON objects. The json.tool
submodule
implements this interface.
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
{
"json": "obj"
}
$ echo '{1.2:3.4}' | python -m json
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.
Modifié dans la version 3.14: The json
module may now be directly executed as
python -m json
. For backwards compatibility, invoking
the CLI as python -m json.tool
remains supported.
Command-line options¶
- infile¶
Le fichier JSON à valider ou réécrire élégamment :
$ python -m json 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