Simplejson python что это

Формат данных JSON в Python

Краткое руководство по использованию JSON в Python

JSON (JavaScript Object Notation) это легковесный формат обмена данными. Людям его легко читать и вести в нем записи, а компьютеры запросто справляются с его синтаксическим анализом и генерацией.

JSON основан на языке программирования JavaScript. Но этот текстовый формат не зависит от языка и среди прочих может использоваться в Python и Perl. В основном его применяют для передачи данных между сервером и веб-приложением.

JSON построен на двух структурах:

JSON в Python

В Python есть ряд пакетов, поддерживающих JSON, в частности metamagic.json, jyson, simplejson, Yajl-Py, ultrajson, и json. В этом руководстве мы будем использовать json, имеющий «родную» поддержку в Python. Для проверки данных JSON мы можем воспользоваться этим сайтом, предоставляющим JSON-линтер.

Ниже приведен пример записи JSON. Как видим, представление данных очень похоже на словари Python.

Конвертируем JSON в объекты Python

Конвертируем объекты Python в JSON

Теперь давайте сравним типы данных в Python и JSON.

Ниже мы покажем, как сконвертировать некоторые объекты Python в типы данных JSON.

Кортеж Python — в массив JSON

Список Python — в массив JSON

Строка Python — в строку JSON

Булевы значения Python — в булевы значения JSON

Запись в файл JSON

Чтение файлов JSON

json.load vs json.loads

json.load используют для загрузки файла, а json.loads – для загрузки строки (loads расшифровывается как «load string»).

json.dump vs json.dumps

Аналогично, json.dump применяется, если нужно сохранить JSON в файл, а json.dumps (dump string) – если данные JSON нам нужны в виде строки для парсинга или вывода.

Работа с данными JSON в Data Science

Ограничения имплементации

Процесс кодирования в JSON называется сериализацией, а декодирования – десериализацией. Некоторые реализации десериализаторов имеют ограничения на:

Впрочем, подобные ограничения связаны только с типами данных Python и работой самого интерпретатора Python.

Формат JSON в разработке API

Эта программа отправит в браузер что-то вроде следующего:

Источник

Python simplejson

last modified November 29, 2021

Python simplejson tutorial shows how to read and write JSON data with Python simplejson module.

The simplejson module

The is simple, fast, complete, and extensible JSON encoder and decoder for Python 2.5+ and Python 3.3+. It is pure Python code with no dependencies.

The simplejson module is included in modern Python versions. The decoder can handle incoming JSON strings of any specified encoding (UTF-8 by default)

Using simplejson

Simplejson conversion table

The following table shows how data types are converted between Python and JSON.

The json.dump()

The json.dump method serializes Python object as a JSON formatted stream to a file object.

The example serializes a Python dictionary into JSON with json.dump method. The JSON data is written to friends.json file.

After executing the script, we have this data.

The json.dumps()

The json.dumps method serializes Python object to a JSON string.

The example serializes a Python list into JSON string with json.dumps method. The JSON data is printed to the console.

This is the output of the example.

The json.load()

The json.load method deserializes a file object containing a JSON document to a Python object.

The config.json file contains this data.

The example reads configuration data from config.json file with json.load and prints the data to the terminal.

The json.loads()

The json.loads method deserializes a JSON string to a Python object.

The example deserializes a JSON string into a Python dictionary.

This is the output of the example.

Simplejson read JSON from URL

A GET request to this site returns this JSON string.

In the example, we use urllib.request module to create a request to the web site.

From the returned response, we transform the JSON string into a Python dictionary with json.loads method.

With the help of Python’s format method, we print the retrieved data to the console.

Pretty printing

With simplejson we can easily pretty print our data.

With sort_keys and indent options we nicely format the JSON data.

This is the output of the example. The data is indented and the keys are sorted.

Simplejson custom class

Simplejson serializes and deserializes only a few Python objects, which are listed in the conversion table. For custom Python objects, we need to do some additional steps.

In this example, we serialize a custom object into JSON.

The trick is to use the __dict__ attribute, which stores the object attributes (name and age).

Simplejson list of custom classes

In the next example, we show how to serialize a list of custom classes.

We have created a toJson method that serializes the object.

We call the toJson method when we add the objects to the list.

This is the output of the example.

In this tutorial, we have worked with the Python simplejson library.

Источник

simplejson — JSON encoder and decoder¶

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

simplejson is a simple, fast, complete, correct and extensible JSON encoder and decoder for Python. It is pure Python code with no dependencies, but includes an optional C extension for a serious speed boost.

Development of simplejson happens on Github: http://github.com/simplejson/simplejson

Encoding basic Python object hierarchies:

Using Decimal instead of float:

Specializing JSON object decoding:

Specializing JSON object encoding:

Using simplejson.tool from the shell to validate and pretty-print:

Parsing multiple documents serialized as JSON lines (newline-delimited JSON):

Serializing multiple objects to JSON lines (newline-delimited JSON):

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.

Basic Usage¶

The simplejson module will produce str objects in Python 3, not bytes objects. Therefore, fp.write() must support str input.

See dumps() for a description of each argument. The only difference is that this function writes the resulting JSON document to fp instead of returning it.

When using Python 2, if ensure_ascii is set to false, some chunks written to fp may be unicode instances, subject to normal Python str to unicode coercion rules. Unless fp.write() explicitly understands unicode (as in codecs.getwriter() ) this is likely to cause an error. It’s best to leave the default settings, because they are safe and it is highly optimized.

When using Python 2, both str and unicode are considered to be basic types that represent text.

If ensure_ascii is false (default: True ), then the output may contain non-ASCII characters, so long as they do not need to be escaped by JSON. When it is true, all non-ASCII characters are escaped.

When using Python 2, if ensure_ascii is set to false, the result may be a unicode object. By default, as a memory optimization, the result would be a str object.

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

If indent is a string, then JSON array elements and object members will be pretty-printed with a newline followed by that string repeated for each level of nesting. None (the default) selects the most compact representation without any newlines. For backwards compatibility with versions of simplejson earlier than 2.1.0, an integer is also accepted and is converted to a string with that many spaces.

If specified, separators should be an (item_separator, key_separator) tuple. The default is (‘, ‘, ‘: ‘) if indent is None and (‘,’, ‘: ‘) otherwise. To get the most compact JSON representation, you should specify (‘,’, ‘:’) to eliminate whitespace.

Changed in version 3.15.0: encoding=None disables serializing bytes by default in Python 3.

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

Subclassing is not recommended. Use the default kwarg or for_json instead. This is faster and more portable.

If use_decimal is true (default: True ) then decimal.Decimal will be natively serialized to JSON with full precision.

If namedtuple_as_object is true (default: True ), objects with _asdict() methods will be encoded as JSON objects.

If tuple_as_array is true (default: True ), tuple (and subclasses) will be encoded as JSON arrays.

If iterable_as_array is true (default: False ), any object not in the above table that implements __iter__() will be encoded as a JSON array.

Changed in version 3.8.0: iterable_as_array is new in 3.8.0.

If sort_keys is true (not the default), then the output of dictionaries will be sorted by key; this is useful for regression tests to ensure that JSON serializations can be compared on a day-to-day basis.

If for_json is true (not the default), objects with a for_json() method will use the return value of that method for encoding as JSON instead of the object.

JSON is not a framed protocol so unlike pickle or marshal it does not make sense to serialize more than one JSON document without some container protocol to delimit them.

If fp.read() returns str then decoded JSON strings that contain only ASCII characters may be parsed as str for performance and memory reasons. If your code expects only unicode the appropriate solution is to wrap fp with a reader as demonstrated above.

simplejson. loads ( s, encoding=’utf-8′, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, use_decimal=None, **kw ) ¶

Deserialize s (a str or unicode instance containing a JSON document) to a Python object. JSONDecodeError will be raised if the given JSON document is not valid.

In Python 2, str is considered to be bytes as above, if your JSON is using an encoding that is not ASCII based, then you must decode to unicode first.

If iterable_as_array is true (default: False ), any object not in the above table that implements __iter__() will be encoded as a JSON array.

Changed in version 3.8.0: iterable_as_array is new in 3.8.0.

To use a custom JSONDecoder subclass, specify it with the cls kwarg. Additional keyword arguments will be passed to the constructor of the class. You probably shouldn’t do this.

Subclassing is not recommended. You should use object_hook or object_pairs_hook. This is faster and more portable than subclassing.

Encoders and decoders¶

Simple JSON decoder.

Performs the following translations in decoding by default:

encoding determines the encoding used to interpret any str objects decoded by this instance ( ‘utf-8’ by default). It has no effect when decoding unicode objects.

strict controls the parser’s behavior when it encounters an invalid control character in a string. The default setting of True means that unescaped control characters are parse errors, if False then control characters will be allowed in strings.

Return the Python representation of the JSON document s. See loads() for details. It is preferable to use that rather than this class.

Decode a JSON document from s (a str or unicode beginning with a JSON document) starting from the index idx 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, or to decode a string that has a series of JSON objects.

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

class simplejson. JSONEncoder ( skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, encoding=’utf-8′, default=None, use_decimal=True, namedtuple_as_object=True, tuple_as_array=True, bigint_as_string=False, item_sort_key=None, for_json=True, ignore_nan=False, int_as_string_bitcount=None, iterable_as_array=False ) ¶

Extensible JSON encoder for Python data structures.

Supports the following objects and types by default:

The JSON format only permits strings to be used as object keys, thus any Python dicts to be encoded should only have string keys. For backwards compatibility, several other types are automatically coerced to strings: int, long, float, Decimal, bool, and None. It is error-prone to rely on this behavior, so avoid it when possible. Dictionaries with other types used as keys should be pre-processed or wrapped in another type with an appropriate for_json method to transform the keys during encoding.

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

Subclassing is not recommended. You should use the default or for_json kwarg. This is faster and more portable than subclassing.

If skipkeys is false (the default), then it is a TypeError to attempt encoding of keys that are not str, int, long, float, Decimal, bool, or None. If skipkeys is true, such items are simply skipped.

If ensure_ascii is true (the default), the output is guaranteed to be str objects with all incoming unicode characters escaped. If ensure_ascii is false, the output will be a unicode object.

If check_circular is true (the default), then lists, dicts, and custom encoded objects will be checked for circular references during encoding to prevent an infinite recursion (which would cause an OverflowError ). Otherwise, no such check takes place.

If sort_keys is true (not the default), then the output of dictionaries will be sorted by key; this is useful for regression tests to ensure that JSON serializations can be compared on a day-to-day basis.

If indent is a string, then JSON array elements and object members will be pretty-printed with a newline followed by that string repeated for each level of nesting. None (the default) selects the most compact representation without any newlines. For backwards compatibility with versions of simplejson earlier than 2.1.0, an integer is also accepted and is converted to a string with that many spaces.

If specified, separators should be an (item_separator, key_separator) tuple. The default is (‘, ‘, ‘: ‘) if indent is None and (‘,’, ‘: ‘) otherwise. To get the most compact JSON representation, you should specify (‘,’, ‘:’) to eliminate whitespace.

Changed in version 3.15.0: encoding=None disables serializing bytes by default in Python 3.

If namedtuple_as_object is true (default: True ), objects with _asdict() methods will be encoded as JSON objects.

If tuple_as_array is true (default: True ), tuple (and subclasses) will be encoded as JSON arrays.

If iterable_as_array is true (default: False ), any object not in the above table that implements __iter__() will be encoded as a JSON array.

Changed in version 3.8.0: iterable_as_array is new in 3.8.0.

If for_json is true (default: False ), objects with a for_json() method will use the return value of that method for encoding as JSON instead of the object.

Implement this method in a subclass such that it returns a serializable object for o, or calls the base implementation (to raise a TypeError ).

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

Return a JSON string representation of a Python data structure, o. For example:

Encode the given object, o, and yield each string representation as available. For example:

class simplejson. JSONEncoderForHTML ( skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, encoding=’utf-8′, default=None, use_decimal=True, namedtuple_as_object=True, tuple_as_array=True, bigint_as_string=False, item_sort_key=None, for_json=True, ignore_nan=False, int_as_string_bitcount=None ) ¶

Subclass of JSONEncoder that escapes &, for embedding in HTML.

It also escapes the characters U+2028 (LINE SEPARATOR) and U+2029 (PARAGRAPH SEPARATOR), irrespective of the ensure_ascii setting, as these characters are not valid in JavaScript strings (see http://timelessrepo.com/json-isnt-a-javascript-subset).

Exceptions¶

Subclass of ValueError with the following additional attributes:

The unformatted error message

The JSON document being parsed

The start index of doc where parsing failed

The end index of doc where parsing failed (may be None )

The line corresponding to pos

The column corresponding to pos

The line corresponding to end (may be None )

The column corresponding to end (may be None )

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, JSONEncoder and JSONDecoder 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:

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

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 will ignore an initial BOM, if 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 str ) codepoints for such sequences.

Infinite and NaN Number Values¶

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:

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 dict or list ), 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.

Implementation Limitations¶

Some JSON deserializer implementations may set limits on:

This module does not impose any such limits beyond those of the relevant Python datatypes themselves or the Python interpreter itself.

Command Line Interface¶

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

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

Command line options¶

The JSON file to be validated or pretty-printed:

Источник

В чем разница между модулями json и simplejson Python?

Хорошей практикой, на мой взгляд, является использование того или другого в качестве резерва.

И результаты моей системы (Python 2.7.4, Linux 64-bit):

Сложные данные реального мира:
json dumps 1.56666707993 секунды
simplejson dumps 2.25638604164 секунды
json load 2.71256899834 секунды
simplejson load 1.29233884811 секунд

Простые данные:
json dumps 0.370109081268 секунд
спейсы простого пользователя 0.574181079865 секунды
json load 0.422876119614 секунды
simplejson load 0.270955085754 секунды

Поскольку в настоящее время я создаю веб-службу, dumps() более важен, и использование стандартной библиотеки всегда предпочтительнее.

Кроме того, cjson не обновлялся за последние 4 года, поэтому я бы не стал его трогать.

Все эти ответы не очень полезны, потому что они чувствительны к времени.

После самостоятельного исследования я обнаружил, что simplejson действительно быстрее, чем встроенный, if, который вы обновляете до последней версии.

pip/easy_install хотел установить 2.3.2 на ubuntu 12.04, но после выяснения последней версии simplejson на самом деле 3.3.0, поэтому я обновил ее и повторил тесты времени.

simplejson примерно в 3 раза быстрее встроенного json при загрузке
simplejson примерно на 30% быстрее, чем встроенный json на дампах

Отказ от ответственности:

Вышеуказанные утверждения приведены в python-2.7.3 и simplejson 3.3.0 (с ускорением c)
И чтобы убедиться, что мой ответ также не чувствителен к времени, вы должны запустить свои собственные тесты, так как он сильно варьируется между версиями; нет простого ответа, который не зависит от времени.

Как узнать, включены ли ускорения C в simplejson:

UPDATE: Недавно я встретил библиотеку под названием ujson, которая выполняет

3 раза быстрее, чем simplejson с некоторыми базовыми тестами.

Источник