Python json encoding using json.dump and dumps(): write json into file and string

Custom Memory Allocation¶

By default, Jansson uses malloc() and free() for
memory allocation. These functions can be overridden if custom
behavior is needed.

json_malloc_t

A typedef for a function pointer with malloc()‘s
signature:

typedef void *(*json_malloc_t)(size_t);

json_free_t

A typedef for a function pointer with free()‘s
signature:

typedef void (*json_free_t)(void *);

void json_set_alloc_funcs( malloc_fn,  free_fn)

Use malloc_fn instead of malloc() and free_fn instead
of free(). This function has to be called before any other
Jansson’s API functions to ensure that all memory operations use
the same functions.

Examples:

Use the Boehm’s conservative garbage collector for memory
operations:

json_set_alloc_funcs(GC_malloc, GC_free);

Allow storing sensitive data (e.g. passwords or encryption keys) in
JSON structures by zeroing all memory when freed:

static void *secure_malloc(size_t size)
{
    /* Store the memory area size in the beginning of the block */
    void *ptr = malloc(size + 8);
    *((size_t *)ptr) = size;
    return ptr + 8;
}

static void secure_free(void *ptr)
{
    size_t size;

    ptr -= 8;
    size = *((size_t *)ptr);

    guaranteed_memset(ptr, , size);
    free(ptr);
}

int main()
{
    json_set_alloc_funcs(secure_malloc, secure_free);
    /* ... */
}

For more information about the issues of storing sensitive data in
memory, see
http://www.dwheeler.com/secure-programs/Secure-Programs-HOWTO/protect-secrets.html.
The page also explains the guaranteed_memset() function used
in the example and gives a sample implementation for it.

Encoders and Decoders¶

class (*, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None)

Руководство по работе с http в python. библиотека requests

Simple JSON decoder.

Performs the following translations in decoding by default:

JSON	Python
object	dict
array	list
string	str
number (int)	int
number (real)	float
true	True
false	False
null	None

It also understands , , and as their
corresponding values, which is outside the JSON spec.

object_hook, if specified, will be called with the result of every JSON
object decoded and its return value will be used in place of the given
. This can be used to provide custom deserializations (e.g. to
support JSON-RPC class hinting).

object_pairs_hook, if specified 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 . This
feature can be used to implement custom decoders. If object_hook is also
defined, the object_pairs_hook takes priority.

Changed in version 3.1: Added support for object_pairs_hook.

parse_float, if specified, will be called with the string of every JSON
float to be decoded. By default, this is equivalent to .
This can be used to use another datatype or parser for JSON floats
(e.g. ).

parse_int, if specified, will be called with the string of every JSON int
to be decoded. By default, this is equivalent to . This can
be used to use another datatype or parser for JSON integers
(e.g. ).

parse_constant, if specified, will be called with one of the following
strings: , , .
This can be used to raise an exception if invalid JSON numbers
are encountered.

If strict is false ( is the default), then control characters
will be allowed inside strings. Control characters in this context are
those with character codes in the 0–31 range, including (tab),
, and .

If the data being deserialized is not a valid JSON document, a
will be raised.

Changed in version 3.6: All parameters are now .

(s)

Return the Python representation of s (a instance
containing a JSON document).

will be raised if the given JSON document is not
valid.

(s)

Decode a JSON document from s (a beginning with a
JSON document) and return a 2-tuple of the Python representation
and the index in s where the document ended.

This can be used to decode a JSON document from a string that may have
extraneous data at the end.

Copying¶

Because of reference counting, passing JSON values around doesn’t
require copying them. But sometimes a fresh copy of a JSON value is
needed. For example, if you need to modify an array, but still want to
use the original afterwards, you should take a copy of it first.

Jansson supports two kinds of copying: shallow and deep. There is a
difference between these methods only for arrays and objects. Shallow
copying only copies the first level value (array or object) and uses
the same child values in the copied value. Deep copying makes a fresh
copy of the child values, too. Moreover, all the child values are deep
copied in a recursive fashion.

*json_copy( *value)

Return value: New reference.

Returns a shallow copy of value, or NULL on error.

Сохранение данных в файл Pickle.

Модуль Pickle работает со структурами данных. Давайте создадим одну.

>>> shell 1                                                                 ①>>> entry = {}                                                              ②>>> entry’title’ = ‘Dive into history, 2009 edition’>>> entry’article_link’ = ‘http://diveintomark.org/archives/2009/03/27/dive-into-history-2009-edition’>>> entry’comments_link’ = None>>> entry’internal_id’ = b’\xDE\xD5\xB4\xF8′>>> entry’tags’ = (‘diveintopython’, ‘docbook’, ‘html’)>>> entry’published’ = True>>> import time>>> entry’published_date’ = time.strptime(‘Fri Mar 27 22:20:42 2009′)     ③>>> entry’published_date’ time.struct_time(tm_year=2009, tm_mon=3, tm_mday=27, tm_hour=22, tm_min=20, tm_sec=42, tm_wday=4, tm_yday=86, tm_isdst=-1)

① Все дальнейшее происходит в консоли Python #1.

② Идея в том чтобы создать словарь, который будет представлять что-нибудь полезное, например элемент рассылки Atom. Также я хочу быть уверенным, что он содержит несколько разных типов данных, чтобы раскрыть возможности модуля pickle. Не вчитывайтесь слишком сильно в эти переменные.

③ Модуль time содержит структуру данных (struct_time) для представления момента времени (вплоть до миллисекунд) и функции для работы с этими структурами. Функция strptime() принимает на вход форматированную строку и преобразует ее в struct_time. Эта строка в стандартном формате, но вы можете контролировать ее при помощи кодов форматирования. Для более подробного описания загляните в модуль time.

Теперь у нас есть замечательный словарь. Давайте сохраним его в файл.

>>> shell                                    ①1>>> import pickle>>> with open(‘entry.pickle’, ‘wb’) as f:    ②
…     pickle.dump(entry, f)                ③
…

① Мы все еще в первой консоли

② Используйте функцию open() для того чтобы открыть файл. Установим режим работы с файлом в ‘wb’ для того чтобы открыть файл для записи в двоичном режиме. Обернем его в конструкцию with для того чтобы быть уверенным в том что файл закроется автоматически, когда вы завершите работу с ним.

③ Функция dump() модуля pickle принимает сериализуемую структуру данных Python, сериализует ее в двоичный, Python-зависимый формат использует последнюю версию протокола pickle и сохраняет ее в открытый файл.

Последнее предложение было очень важным.

• Протокол pickle зависит от Python; здесь нет гарантий совместимости с другими языками. Вы возможно не сможете взять entry.pickle файл, который только что сделали и как — либо с пользой его использовать при помощи Perl, PHP, Java или любого другого языка программирования
• Не всякая структура данных Python может быть сериализована модулем Pickle. Протокол pickle менялся несколько раз с добавлением новых типов данных в язык Python, и все еще у него есть ограничения.
• Как результат, нет гарантии совместимости между разными версиями Python. Новые версии Python поддерживают старые форматы сериализации, но старые версии Python не поддерживают новые форматы (поскольку не поддерживают новые форматы данных)
• Пока вы не укажете иное, функции модуля pickle будут использовать последнюю версию протокола pickle. Это сделано для уверенности в том, что вы имеете наибольшую гибкость в типах данных, которые вы можете сериализовать, но это также значит, что результирующий файл будет невозможно прочитать при помощи старых версий Python, которые не поддерживают последнюю версию протокола pickle.
• Последняя версия протокола pickle это двоичный формат. Убедитесь, что открываете файлы pickle в двоичном режиме, или данные будут повреждены при записи.

Encodeurs et décodeurs¶

class (*, 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

Les valeurs , et sont aussi comprises comme leurs valeurs 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 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 . 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 à . Cela peut servir à utiliser un autre type de données ou un autre analyseur pour les nombres réels JSON (p. ex. ).

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 à . Cela peut servir à utiliser un autre type de données ou un autre analyseur pour les nombres entiers JSON (p. ex. ).

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

Si strict vaut ( 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 (tabulation), , et .

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

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

(s)

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

Une est levée si le document JSON donné n’est pas valide.

(s)

Décode en document JSON depuis s (une instance 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.

Understand the load and loads() method in detail

We can do many JSON parsing operations using load and loads() method. First, understand it’s syntax and arguments, then we move to its usage one-by-one.

All arguments have the same meaning in both methods.

The is used to read the JSON document from file and The is used to convert the JSON String document into the Python dictionary.

• file pointer used to read a text file, binary file or a JSON file that contains a JSON document.
•   is the optional function that will be called with the result of any object literal decoded. The Python built-in json module can only handle primitives types that have a direct JSON equivalent (e.g., dictionary, lists, strings, Numbers, None, etc.). But when you want to convert JSON data into a custom Python type, we need to implement custom decoder and pass it as an object to a method so we can get a custom Python type in return instead of a dictionary.
•  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  will be used instead of the Python dictionary. This feature can also be used to implement custom decoders. If  is also defined, the  takes priority.
• is optional parameters but, if specified, will be called with the string of every JSON float and integer to be decoded. By default, this is equivalent to .
• if specified, it will be called with the string of every JSON int to be decoded. By default, this is equivalent to .

We will see the use of all these parameters in detail.

Convert Python Dict to JSON formatted String using json.dumps()

There are multiple scenarios where you need to use serialized JSON data in your program. If you need this serialized JSON data in your application of further processing then you can convert it to a native Python object instead of writing it in a file.

For example, you receive an HTTP request to send developer detail. you fetched developer data from the database table and store it in a Python dictionary or any Python object, Now you need to send that data back to the requested application so you need to convert Python dictionary object into a JSON formatted string to send as a response in JSON string. To do this you need to use .

The returns the JSON string representation of the Python dict. Let see the example now.

Convert Python dictionary into a JSON formatted String

Output:

Writing JSON data into a Python String
{"name": "Jane Doe", "salary": 9000, "skills": , "email": "jane.doe@pynative.com"}

Convert Python primitive types into JSON equivalent

In this section, we will see how to convert any Python primitive types such as a dictionary, list, set, tuple, string, numbers into a JSON formatted data. just to get to know the JSON equivalent of Python type, please refer to the following example.

Let see the example now.

Output:

Converting Python primitive types into JSON
Done converting Python primitive types into JSON
{"colorList": , "carTuple": , "sampleString": "pynative.com", "sampleInteger": 457, "sampleFloat": 225.48, "booleantrue": true, "booleanfalse": false, "nonevalue": null}

Байты и строки снова вздымают свои уродливые головы

Протокол pickle существует уже много лет, и он развивался вместе с тем как развивался сам Python. Сейчас существует четыре различных версии протокола pickle.

• Python 1.x породил две версии протокола, основанный на тексте формат (версия 0) и двоичный формат (версия 1)
• Python 2.3 ввел новый протокол pickle(версия 2) для того чтобы поддерживать новый функционал в классах Python. Он двоичный.
• Python 3.0 ввел еще один протокол pickle(версия 3) с полной поддержкой объектов типа bytes и массивов байт. Он так же двоичный.

Вау смотрите, разница между строками и байтами снова вздымает свою уродливую голову. (Если вы удивлены, вы не уделяли достаточно внимания.) На практике это значит, что в то время, как Python 3 может читать данные сохраненные при помощи протокола версии 2, Python 2 не может читать данные сохраненные при помощи протокола версии 3.

Соответствие типов данных Python к JSON

Поскольку JSON разрабатывался не только для Python, есть некоторые недочеты в покрытии типов данных Python. Некоторые из них просто различие в названии типов, но есть два важных типа данных Python, которые полностью упущены из виду. Посмотрим, сможете ли вы заметить их:

Пометки	JSON	PYTHON 3
	object	dictionary
	array	list
	string	string
	integer	integer
	real number	float
*	true	True
*	false	False
*	null	None
*	Текст ячейки	Текст ячейки

— Все переменные в JavaScript регистрозависимые

Вы заметили что потеряно? Кортежи и байты! В JSON есть тип — массив, который модуль JSON ставит в соответствие типу список в Python, но там нет отдельного типа для «статичных массивов» (кортежей). И также в JSON есть хорошая поддержка строк, но нет поддержки объектов типа bytes или массивов байт.

Python Tutorial

Python HOMEPython IntroPython Get StartedPython SyntaxPython CommentsPython Variables
Python Variables
Variable Names
Assign Multiple Values
Output Variables
Global Variables
Variable Exercises

Python Data TypesPython NumbersPython CastingPython Strings
Python Strings
Slicing Strings
Modify Strings
Concatenate Strings
Format Strings
Escape Characters
String Methods
String Exercises

Python BooleansPython OperatorsPython Lists
Python Lists
Access List Items
Change List Items
Add List Items
Remove List Items
Loop Lists
List Comprehension
Sort Lists
Copy Lists
Join Lists
List Methods
List Exercises

Python Tuples
Python Tuples
Access Tuples
Update Tuples
Unpack Tuples
Loop Tuples
Join Tuples
Tuple Methods
Tuple Exercises

Python Sets
Python Sets
Access Set Items
Add Set Items
Remove Set Items
Loop Sets
Join Sets
Set Methods
Set Exercises

Python Dictionaries
Python Dictionaries
Access Items
Change Items
Add Items
Remove Items
Loop Dictionaries
Copy Dictionaries
Nested Dictionaries
Dictionary Methods
Dictionary Exercise

Python If…ElsePython While LoopsPython For LoopsPython FunctionsPython LambdaPython ArraysPython Classes/ObjectsPython InheritancePython IteratorsPython ScopePython ModulesPython DatesPython MathPython JSONPython RegExPython PIPPython Try…ExceptPython User InputPython String Formatting

Library Version¶

The Jansson version is of the form A.B.C, where A is the major
version, B is the minor version and C is the micro version. If the
micro version is zero, it’s omitted from the version string, i.e. the
version string is just A.B.

When a new release only fixes bugs and doesn’t add new features or
functionality, the micro version is incremented. When new features are
added in a backwards compatible way, the minor version is incremented
and the micro version is set to zero. When there are backwards
incompatible changes, the major version is incremented and others are
set to zero.

The following preprocessor constants specify the current version of
the library:

Complex JSON object decoding in Python

To decode complex object in JSON, use an object_hook parameter which checks JSON string contains the complex object or not. Example,

import json
  # function check JSON string contains complex object
  def is_complex(objct):
    if '__complex__' in objct:
      return complex(objct, objct)
    return objct
  
  # use of json loads method with object_hook for check object complex or not
  complex_object =json.loads('{"__complex__": true, "real": 4, "img": 5}', object_hook = is_complex)
  #here we not passed complex object so it's convert into dictionary
  simple_object =json.loads('{"real": 6, "img": 7}', object_hook = is_complex)
  print("Complex_object......",complex_object)
  print("Without_complex_object......",simple_object)

Output:

Complex_object...... (4+5j)
Without_complex_object...... {'real': 6, 'img': 7}

Command Line Interface¶

The module provides a simple command line interface to
validate and pretty-print JSON.

If the optional and arguments are not
specified, and will be used respectively:

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

Command line options

The JSON file to be validated or pretty-printed:

$ python -m simplejson.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 .

Write the output of the infile to the given outfile. Otherwise, write it
to .

Footnotes

As noted in the errata for RFC 7159, JSON permits literal U+2028 (LINE SEPARATOR) and U+2029 (PARAGRAPH SEPARATOR) characters in strings, whereas JavaScript (as of ECMAScript Edition 5.1) does not.

Command Line Interface¶

Source code: Lib/json/tool.py

The module provides a simple command line interface to validate
and pretty-print JSON objects.

If the optional and arguments are not
specified, and 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)

Changed in version 3.5: The output is now in the same order as the input. Use the
option to sort the output of dictionaries
alphabetically by key.

Command line options

The JSON file to be validated or pretty-printed:

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

Write the output of the infile to the given outfile. Otherwise, write it
to .

Sort the output of dictionaries alphabetically by key.

New in version 3.5.

Parse every input line as separate JSON object.

New in version 3.8.

Show the help message.

Footnotes

As noted in the errata for RFC 7159,
JSON permits literal U+2028 (LINE SEPARATOR) and
U+2029 (PARAGRAPH SEPARATOR) characters in strings, whereas JavaScript
(as of ECMAScript Edition 5.1) does not.

Python to JSON (Encoding)

JSON Library of Python performs following translation of Python objects into JSON objects by default

Python	JSON
dict	Object
list	Array
unicode	String
number — int, long	number – int
float	number – real
True	True
False	False
None	Null

Converting Python data to JSON is called an Encoding operation. Encoding is done with the help of JSON library method – dumps()

dumps() method converts dictionary object of python into JSON string data format.

Now lets we perform our first encoding example with Python.

import json

x = {
  "name": "Ken",
  "age": 45,
  "married": True,
  "children": ("Alice","Bob"),
  "pets": ,
  "cars": 
}
# sorting result in asscending order by keys:
sorted_string = json.dumps(x, indent=4, sort_keys=True)
print(sorted_string)

Output:

{"person": {"name": "Kenn", "sex": "male", "age": 28}})

Let’s create a JSON file of the dictionary using the same function dump()

# here we create new data_file.json file with write mode using file i/o operation 
with open('json_file.json', "w") as file_write:
# write json data into file
json.dump(person_data, file_write)

Output:

Nothing to show…In your system json_file.json is created you can check that file.

Standard Compliance and Interoperability¶

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, and subclasses, and
parameters other than those explicitly mentioned, are not considered.

This module does not comply with the RFC in a strict fashion, implementing some
extensions that are valid JavaScript but not valid JSON. In particular:

• Infinite and NaN number values are accepted and output;

• Repeated names within an object are accepted, and only the value of the last
  name-value pair is used.

Since the RFC permits RFC-compliant parsers to accept input texts that are not
RFC-compliant, this module’s deserializer is technically RFC-compliant under
default settings.

Character Encodings

The RFC requires that JSON be represented using either UTF-8, UTF-16, or
UTF-32, with UTF-8 being the recommended default for maximum interoperability.

As permitted, though not required, by the RFC, this module’s serializer sets
ensure_ascii=True by default, thus escaping the output so that the resulting
strings only contain ASCII characters.

Other than the ensure_ascii parameter, this module is defined strictly in
terms of conversion between Python objects and
, and thus does not otherwise directly address
the issue of character encodings.

The RFC prohibits adding a byte order mark (BOM) to the start of a JSON text,
and this module’s serializer does not add a BOM to its output.
The RFC permits, but does not require, JSON deserializers to ignore an initial
BOM in their input. This module’s deserializer raises a
when an initial BOM is present.

The RFC does not explicitly forbid JSON strings which contain byte sequences
that don’t correspond to valid Unicode characters (e.g. unpaired UTF-16
surrogates), but it does note that they may cause interoperability problems.
By default, this module accepts and outputs (when present in the original
) code points for such sequences.

Infinite and NaN Number Values

The RFC does not permit the representation of infinite or NaN number values.
Despite that, by default, this module accepts and outputs ,
, and as if they were valid JSON number literal values:

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

In the serializer, the allow_nan parameter can be used to alter this
behavior. In the deserializer, the parse_constant parameter can be used to
alter this behavior.

Repeated Names Within an Object

The RFC specifies that the names within a JSON object should be unique, but
does not mandate how repeated names in JSON objects should be handled. By
default, this module does not raise an exception; instead, it ignores all but
the last name-value pair for a given name:

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

The object_pairs_hook parameter can be used to alter this behavior.

Top-level Non-Object, Non-Array Values

The old version of JSON specified by the obsolete RFC 4627 required that
the top-level value of a JSON text must be either a JSON object or array
(Python or ), and could not be a JSON null,
boolean, number, or string value. RFC 7159 removed that restriction, and
this module does not and has never implemented that restriction in either its
serializer or its deserializer.

Regardless, for maximum interoperability, you may wish to voluntarily adhere
to the restriction yourself.

19.2.1. Basic Usage¶

(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 -supporting
) using this .

If skipkeys is true (default: ), then dict keys that are not
of a basic type (, , , ,
) will be skipped instead of raising a .

The module always produces objects, not
objects. Therefore, must support
input.

If ensure_ascii is true (the default), the output is guaranteed to
have all incoming non-ASCII characters escaped. If ensure_ascii is
false, these characters will be output as-is.

If check_circular is false (default: ), then the circular
reference check for container types will be skipped and a circular reference
will result in an (or worse).

If allow_nan is false (default: ), then it will be a
to serialize out of range values (,
, ) in strict compliance of the JSON specification.
If allow_nan is true, their JavaScript equivalents (,
, ) will be used.

If indent is a non-negative integer or string, then JSON array elements and
object members will be pretty-printed with that indent level. An indent level
of 0, negative, or will only insert newlines. (the default)
selects the most compact representation. Using a positive integer indent
indents that many spaces per level. If indent is a string (such as ),
that string is used to indent each level.

Changed in version 3.2: Allow strings for indent in addition to integers.

If specified, separators should be an
tuple. The default is if indent is and
otherwise. To get the most compact JSON representation,
you should specify to eliminate whitespace.

Changed in version 3.4: Use as default if indent is not .

If specified, default should be a function that gets called for objects that
can’t otherwise be serialized. It should return a JSON encodable version of
the object or raise a . If not specified,
is raised.

If sort_keys is true (default: ), then the output of
dictionaries will be sorted by key.

To use a custom subclass (e.g. one that overrides the
method to serialize additional types), specify it with the
cls kwarg; otherwise is used.

(obj, 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 to a JSON formatted using this . The arguments have the same meaning as in
.

Note

Unlike and , JSON is not a framed protocol,
so trying to serialize multiple objects with repeated calls to
using the same fp will result in an invalid JSON file.

Note

Keys in key/value pairs of JSON are always of the type . When
a dictionary is converted into JSON, all the keys of the dictionary are
coerced to strings. As a result of this, if a dictionary is converted
into JSON and then back into a dictionary, the dictionary may not equal
the original one. That is, if x has non-string
keys.

(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

Deserialize fp (a -supporting
containing a JSON document) to a Python object using this .

object_hook is an optional function that will be called with the result of
any object literal decoded (a ). The return value of
object_hook will be used instead of the . 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
. This feature can be used to implement custom decoders that
rely on the order that the key and value pairs are decoded (for example,
will remember the order of insertion). If
object_hook is also defined, the object_pairs_hook takes priority.

Changed in version 3.1: Added support for object_pairs_hook.

parse_float, if specified, will be called with the string of every JSON
float to be decoded. By default, this is equivalent to .
This can be used to use another datatype or parser for JSON floats
(e.g. ).

parse_int, if specified, will be called with the string of every JSON int
to be decoded. By default, this is equivalent to . This can
be used to use another datatype or parser for JSON integers
(e.g. ).

parse_constant, if specified, will be called with one of the following
strings: , , .
This can be used to raise an exception if invalid JSON numbers
are encountered.

Changed in version 3.1: parse_constant doesn’t get called on ‘null’, ‘true’, ‘false’ anymore.

To use a custom subclass, specify it with the
kwarg; otherwise is used. Additional keyword arguments
will be passed to the constructor of the class.

If the data being deserialized is not a valid JSON document, a
will be raised.

Погружение

С первого взгляда, идея сериализации проста. У вас есть структура данных в памяти, которую вы хотите сохранить, использовать повторно, или отправить кому либо. Как вам это сделать? Это зависит от того как вы ее сохраните, как вы ее хотите использовать, и кому вы ее хотите отправить. Многие игры позволяют вам сохранять ваш прогресс перед выходом и возобновлять игру после запуска. (Вообще, многие неигровые приложения также позволяют это делать). В этом случае, структура, которая хранит ваш прогресс в игре, должна быть сохранена на диске, когда вы закрываете игру, и загружена с диска, когда вы ее запускаете. Данные предназначены только для использования той же программой что и создала их, никогда не посылаются по сети, и никогда не читаются ничем кроме программы их создавшей. Поэтому проблемы совместимости ограничены тем, чтобы более поздние версии программы могли читать данные созданные ранними версиями.

Для таких случаев модуль pickle идеален. Это часть стандартной библиотеки Python, поэтому он всегда доступен. Он быстрый, большая часть написана на C, как и сам интерпретатор Python. Он может сохранять совершенно произвольные комплексные структуры данных Python.

Что может сохранять модуль pickle?

• Все встроенные типы данных Python: тип boolean, Integer, числа с плавающей точкой, комплексные числа, строки, объекты bytes, массивы байт, и None.
• Списки, кортежи, словари и множества, содержащие любую комбинацию встроенных типов данных
• Списки, кортежи, словари и множества, содержащие любую комбинацию списков, кортежей, словарей и множеств содержащий любую комбинацию встроенных типов данных (и так далее, вплоть до максимального уровня вложенности, который поддерживает Python).
• Функции, классы и экземпляры классов (с caveats).

Если для вас этого мало, то модуль pickle еще и расширяем. Если вам интересна эта возможность, то смотрите ссылки в разделе «Дальнейшее чтение» в конце этой главы.