Парсинг json
Содержание:
- Exceptions Related to JSON Library in Python:
- Создание объектов Array
- JSON — схема
- Простой пример в JSON
- JSON — Синтаксис
- JSON — DataTypes
- Performance
- Complex JSON object decoding in Python
- Standard Compliance and Interoperability¶
- Расшифровка JSON на Java
- JSON с Ajax
- Пример схемы JSON
- JSON — Сравнение с XML
- enum instances¶
- Python поддерживает JSON
- Пример сериализации JSON Python
- Performance
- Итоги
Exceptions Related to JSON Library in Python:
- Class json.JSONDecoderError handles the exception related to decoding operation. and it’s a subclass of ValueError.
- Exception — json.JSONDecoderError(msg, doc)
- Parameters of Exception are,
- msg – Unformatted Error message
- doc – JSON docs parsed
- pos – start index of doc when it’s failed
- lineno – line no shows correspond to pos
- colon – column no correspond to pos
Python load JSON from file Example:
import json
#File I/O Open function for read data from JSON File
data = {} #Define Empty Dictionary Object
try:
with open('json_file_name.json') as file_object:
data = json.load(file_object)
except ValueError:
print("Bad JSON file format, Change JSON File")
Создание объектов Array
В следующем примере показано создание объекта массива в javascript с использованием JSON, сохраните приведенный ниже код как json_array_object.htm —
<html>
<head>
<title>Creation of array object in javascript using JSON</title>
<script language = "javascript" >
document.writeln("<h2>JSON array object</h2>");
var books = { " Pascal " : ,
"Scala" :
}
var i = 0
document.writeln("<table border = '2'><tr>");
for(i = 0;i<books. Pascal .length;i++) {
document.writeln("<td>");
document.writeln("<table border = '1' width = 100 >");
document.writeln("<tr><td><b>Name</b></td><td width = 50>" + books. Pascal .Name+"</td></tr>");
document.writeln("<tr><td><b>Price</b></td><td width = 50>" + books. Pascal .price +"</td></tr>");
document.writeln("</table>");
document.writeln("</td>");
}
for(i = 0;i<books.Scala.length;i++) {
document.writeln("<td>");
document.writeln("<table border = '1' width = 100 >");
document.writeln("<tr><td><b>Name</b></td><td width = 50>" + books.Scala.Name+"</td></tr>");
document.writeln("<tr><td><b>Price</b></td><td width = 50>" + books.Scala.price+"</td></tr>");
document.writeln("</table>");
document.writeln("</td>");
}
document.writeln("</tr></table>");
</script>
</head>
<body>
</body>
</html>
Теперь давайте попробуем открыть Json Array Object с помощью IE или любого другого браузера с поддержкой javaScript. Это дает следующий результат —
JSON — схема
Схема JSON — это спецификация формата на основе JSON для определения структуры данных JSON. Он был написан по проекту IETF, срок действия которого истек в 2011 году. Схема JSON —
- Описывает ваш существующий формат данных.
- Четкая, понятная человеку и машинная документация.
- Полная структурная проверка, полезная для автоматизированного тестирования.
- Полная структурная проверка, проверка данных, предоставленных клиентом.
Простой пример в JSON
В следующем примере показано, как использовать JSON для хранения информации, связанной с книгами, в зависимости от их темы и издания.
{
"book":
}
После понимания вышеупомянутой программы мы попробуем другой пример. Давайте сохраним код ниже как json.htm —
<html>
<head>
<title>JSON example</title>
<script language = "javascript" >
var object1 = { "language" : "Java", "author" : "herbert schildt" };
document.write("<h1>JSON with JavaScript example</h1>");
document.write("<br>");
document.write("<h3>Language = " + object1.language+"</h3>");
document.write("<h3>Author = " + object1.author+"</h3>");
var object2 = { "language" : "C++", "author" : "E-Balagurusamy" };
document.write("<br>");
document.write("<h3>Language = " + object2.language+"</h3>");
document.write("<h3>Author = " + object2.author+"</h3>");
document.write("<hr />");
document.write(object2.language + " programming language can be studied " + "from book written by " + object2.author);
document.write("<hr />");
</script>
</head>
<body>
</body>
</html>
Теперь давайте попробуем открыть json.htm с помощью IE или любого другого браузера с поддержкой javascript, который выдает следующий результат:
Вы можете обратиться к главе «Объекты JSON» для получения дополнительной информации об объектах JSON.
JSON — Синтаксис
Давайте кратко рассмотрим основной синтаксис JSON. Синтаксис JSON в основном рассматривается как подмножество синтаксиса JavaScript; это включает в себя следующее —
-
Данные представлены в парах имя / значение.
-
В фигурных скобках хранятся объекты, и за каждым именем следует ‘:’ (двоеточие), пары имя / значение разделяются (запятая).
-
Квадратные скобки содержат массивы, а значения разделяются, (запятая).
Ниже приведен простой пример —
{
"book":
}
JSON поддерживает следующие две структуры данных —
-
Коллекция пар имя / значение — эта структура данных поддерживается различными языками программирования.
-
Упорядоченный список значений — включает массив, список, вектор или последовательность и т. Д.
JSON — DataTypes
Формат JSON поддерживает следующие типы данных —
| Sr.No. | Тип и описание |
|---|---|
| 1 |
номер формат с плавающей точкой двойной точности в JavaScript |
| 2 |
строка Unicode с двойными кавычками с обратной косой чертой |
| 3 |
логический правда или ложь |
| 4 |
массив упорядоченная последовательность значений |
| 5 |
Значение это может быть строка, число, истина или ложь, null т. д. |
| 6 |
объект неупорядоченный набор пар ключ: значение |
| 7 |
Пробелы может использоваться между любой парой токенов |
| 8 |
null опорожнить |
Performance
Serialization and deserialization performance of orjson is better than
ultrajson, rapidjson, simplejson, or json. The benchmarks are done on
fixtures of real data:
-
twitter.json, 631.5KiB, results of a search on Twitter for «一», containing
CJK strings, dictionaries of strings and arrays of dictionaries, indented. -
github.json, 55.8KiB, a GitHub activity feed, containing dictionaries of
strings and arrays of dictionaries, not indented. -
citm_catalog.json, 1.7MiB, concert data, containing nested dictionaries of
strings and arrays of integers, indented. -
canada.json, 2.2MiB, coordinates of the Canadian border in GeoJSON
format, containing floats and arrays, indented.
Latency
twitter.json serialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 0.59 | 1698.8 | 1 |
| ujson | 2.14 | 464.3 | 3.64 |
| rapidjson | 2.39 | 418.5 | 4.06 |
| simplejson | 3.15 | 316.9 | 5.36 |
| json | 3.56 | 281.2 | 6.06 |
twitter.json deserialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 2.28 | 439.3 | 1 |
| ujson | 2.89 | 345.9 | 1.27 |
| rapidjson | 3.85 | 259.6 | 1.69 |
| simplejson | 3.66 | 272.1 | 1.61 |
| json | 4.05 | 246.7 | 1.78 |
github.json serialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 0.07 | 15265.2 | 1 |
| ujson | 0.22 | 4556.7 | 3.35 |
| rapidjson | 0.26 | 3808.9 | 4.02 |
| simplejson | 0.37 | 2690.4 | 5.68 |
| json | 0.35 | 2847.8 | 5.36 |
github.json deserialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 0.18 | 5610.1 | 1 |
| ujson | 0.28 | 3540.7 | 1.58 |
| rapidjson | 0.33 | 3031.5 | 1.85 |
| simplejson | 0.29 | 3385.6 | 1.65 |
| json | 0.29 | 3402.1 | 1.65 |
citm_catalog.json serialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 0.99 | 1008.5 | 1 |
| ujson | 3.69 | 270.7 | 3.72 |
| rapidjson | 3.55 | 281.4 | 3.58 |
| simplejson | 11.76 | 85.1 | 11.85 |
| json | 6.89 | 145.1 | 6.95 |
citm_catalog.json deserialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 4.53 | 220.5 | 1 |
| ujson | 5.67 | 176.5 | 1.25 |
| rapidjson | 7.51 | 133.3 | 1.66 |
| simplejson | 7.54 | 132.7 | 1.66 |
| json | 7.8 | 128.2 | 1.72 |
canada.json serialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 4.72 | 198.9 | 1 |
| ujson | 17.76 | 56.3 | 3.77 |
| rapidjson | 61.83 | 16.2 | 13.11 |
| simplejson | 80.6 | 12.4 | 17.09 |
| json | 52.38 | 18.8 | 11.11 |
canada.json deserialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 10.28 | 97.4 | 1 |
| ujson | 16.49 | 60.5 | 1.6 |
| rapidjson | 37.92 | 26.4 | 3.69 |
| simplejson | 37.7 | 26.5 | 3.67 |
| json | 37.87 | 27.6 | 3.68 |
Memory
orjson’s memory usage when deserializing is similar to or lower than
the standard library and other third-party libraries.
This measures, in the first column, RSS after importing a library and reading
the fixture, and in the second column, increases in RSS after repeatedly
calling on the fixture.
| Library | import, read() RSS (MiB) | loads() increase in RSS (MiB) |
|---|---|---|
| orjson | 13.5 | 2.5 |
| ujson | 14 | 4.1 |
| rapidjson | 14.7 | 6.5 |
| simplejson | 13.2 | 2.5 |
| json | 12.9 | 2.3 |
github.json
| Library | import, read() RSS (MiB) | loads() increase in RSS (MiB) |
|---|---|---|
| orjson | 13.1 | 0.3 |
| ujson | 13.5 | 0.3 |
| rapidjson | 14 | 0.7 |
| simplejson | 12.6 | 0.3 |
| json | 12.3 | 0.1 |
citm_catalog.json
| Library | import, read() RSS (MiB) | loads() increase in RSS (MiB) |
|---|---|---|
| orjson | 14.6 | 7.9 |
| ujson | 15.1 | 11.1 |
| rapidjson | 15.8 | 36 |
| simplejson | 14.3 | 27.4 |
| json | 14 | 27.2 |
canada.json
| Library | import, read() RSS (MiB) | loads() increase in RSS (MiB) |
|---|---|---|
| orjson | 17.1 | 15.7 |
| ujson | 17.6 | 17.4 |
| rapidjson | 18.3 | 17.9 |
| simplejson | 16.9 | 19.6 |
| json | 16.5 | 19.4 |
Reproducing
The above was measured using Python 3.8.3 on Linux (x86_64) with
orjson 3.3.0, ujson 3.0.0, python-rapidson 0.9.1, and simplejson 3.17.2.
The latency results can be reproduced using the and
scripts. The memory results can be reproduced using the script.
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. Lets understand with string to JSON Python 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}
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.
Расшифровка JSON на Java
В следующем примере используются JSONObject и JSONArray, где JSONObject — это java.util.Map, а JSONArray — это java.util.List, поэтому вы можете обращаться к ним с помощью стандартных операций Map или List.
import org.json.simple.JSONObject;
import org.json.simple.JSONArray;
import org.json.simple.parser.ParseException;
import org.json.simple.parser.JSONParser;
class JsonDecodeDemo {
public static void main(String[] args) {
JSONParser parser = new JSONParser();
String s = "}}}}]";
try{
Object obj = parser.parse(s);
JSONArray array = (JSONArray)obj;
System.out.println("The 2nd element of array");
System.out.println(array.get(1));
System.out.println();
JSONObject obj2 = (JSONObject)array.get(1);
System.out.println("Field \"1\"");
System.out.println(obj2.get("1"));
s = "{}";
obj = parser.parse(s);
System.out.println(obj);
s = "";
obj = parser.parse(s);
System.out.println(obj);
s = "";
obj = parser.parse(s);
System.out.println(obj);
}catch(ParseException pe) {
System.out.println("position: " + pe.getPosition());
System.out.println(pe);
}
}
}
При компиляции и выполнении вышеуказанной программы будет получен следующий результат:
The 2nd element of array
{"1":{"2":{"3":{"4":}}}}
Field "1"
{"2":{"3":{"4":}}}
{}
JSON с Ajax
AJAX — это асинхронный JavaScript и XML, который используется на стороне клиента как группа взаимосвязанных методов веб-разработки для создания асинхронных веб-приложений. Согласно модели AJAX, веб-приложения могут отправлять и извлекать данные с сервера асинхронно, не влияя на отображение и поведение существующей страницы.
Многие разработчики используют JSON для передачи обновлений AJAX между клиентом и сервером. В качестве примера AJAX можно рассматривать сайты, обновляющие результаты спортивных матчей. Если эти оценки должны быть обновлены на веб-сайте, они должны храниться на сервере, чтобы веб-страница могла получать оценку, когда это требуется. Здесь мы можем использовать данные в формате JSON.
Любые данные, которые обновляются с использованием AJAX, могут храниться в формате JSON на веб-сервере. AJAX используется для того, чтобы javascript мог при необходимости извлекать эти файлы JSON, анализировать их и выполнять одну из следующих операций:
-
Сохраните проанализированные значения в переменных для дальнейшей обработки, прежде чем отображать их на веб-странице.
-
Он напрямую назначает данные элементам DOM на веб-странице, чтобы они отображались на веб-сайте.
Пример схемы JSON
Ниже приведена базовая схема JSON, которая охватывает классическое описание каталога продукции —
{
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "Product",
"description": "A product from Acme's catalog",
"type": "object",
"properties": {
"id": {
"description": "The unique identifier for a product",
"type": "integer"
},
"name": {
"description": "Name of the product",
"type": "string"
},
"price": {
"type": "number",
"minimum": 0,
"exclusiveMinimum": true
}
},
"required":
}
Давайте проверим различные важные ключевые слова, которые можно использовать в этой схеме —
| Sr.No. | Ключевое слово и описание |
|---|---|
| 1 |
$ схема Ключевое слово $ schema указывает, что эта схема написана согласно черновой спецификации v4. |
| 2 |
заглавие Вы будете использовать это, чтобы дать название вашей схеме. |
| 3 |
описание Небольшое описание схемы. |
| 4 |
тип Ключевое слово type определяет первое ограничение для наших данных JSON: это должен быть объект JSON. |
| 5 |
свойства Определяет различные ключи и их типы значений, минимальные и максимальные значения, которые будут использоваться в файле JSON. |
| 6 |
требуется Это хранит список обязательных свойств. |
| 7 |
минимальный Это ограничение, накладываемое на значение, и представляет минимально допустимое значение. |
| 8 |
exclusiveMinimum Если присутствует «exclusiveMinimum» и имеет логическое значение true, экземпляр действителен, если он строго больше значения «минимума». |
| 9 |
максимальная Это ограничение, которое будет наложено на значение и представляет собой максимально допустимое значение. |
| 10 |
exclusiveMaximum Если присутствует «exclusiveMaximum» и имеет логическое значение true, экземпляр действителен, если он строго ниже значения «Maximum». |
| 11 |
multipleOf Числовой экземпляр действителен для «множественного значения», если результатом деления экземпляра по значению этого ключевого слова является целое число. |
| 12 |
максимальная длина Длина экземпляра строки определяется как максимальное количество ее символов. |
| 13 |
MINLENGTH Длина экземпляра строки определяется как минимальное количество ее символов. |
| 14 |
шаблон Экземпляр строки считается допустимым, если регулярное выражение соответствует экземпляру успешно. |
Вы можете проверить http://json-schema.org для полного списка ключевых слов, которые можно использовать при определении схемы JSON. Приведенную выше схему можно использовать для проверки правильности следующего кода JSON:
JSON — Сравнение с XML
JSON и XML являются удобочитаемыми форматами и не зависят от языка. Они оба поддерживают создание, чтение и декодирование в реальных ситуациях. Мы можем сравнить JSON с XML, основываясь на следующих факторах:
enum instances¶
Support for enums was added in Python 3.4. Support for previous versions of Python is available with the enum 34 package.
- (obj, primitives=False, with_enum_value=False)
-
Encodes an enum instance to json. Note that it can only be recovered if the environment allows the enum to be
imported in the same way.
:param primitives: If true, encode the enum values as primitive (more readable, but cannot be restored automatically).
:param with_enum_value: If true, the value of the enum is also exported (it is not used during import, as it should be constant).
- class (cls_lookup_map=None)
-
This hook tries to convert json encoded by enum_instance_encode back to it’s original instance.
It only works if the environment is the same, e.g. the enum is similarly importable and hasn’t changed.
By default cannot be encoded as enums since they cannot be differenciated from integers. To serialize them, you must use encode_intenums_inplace which mutates a nested data structure (in place!) to replace any by their representation. If you serialize this result, it can subsequently be loaded without further adaptations.
Python поддерживает JSON
Python содержит встроенный модуль под названием json для кодирования и декодирования данных JSON.
Просто импортируйте модуль в начале вашего файла:
Python
import json
| 1 | importjson |
Небольшой словарь
Как правило, процесс кодирования JSON называется сериализация. Этот термин обозначает трансформацию данных в серию байтов (следовательно, серийных) для хранения или передачи по сети. Также вы, возможно, уже слышали о термине «маршалинг», но это уже совсем другая область.
Естественно, десериализация — является противоположным процессом декодирования данных, которые хранятся или направлены в стандарт JSON.
Пример сериализации JSON Python
Представьте, что вы работаете с объектом Python в памяти, который выглядит следующим образом:
data_file.json
Python
data = {
«president»: {
«name»: «Zaphod Beeblebrox»,
«species»: «Betelgeusian»
}
}
|
1 2 3 4 5 6 |
data={ «president»{ «name»»Zaphod Beeblebrox», «species»»Betelgeusian» } } |
Сохранить эту информацию на диск — критично, так что ваша задача — записать на файл.
Используя контекстный менеджер Python, вы можете создать файл под названием data_file.json и открыть его в режиме write (файлы JSON имеют расширение .json).
Python
with open(«data_file.json», «w») as write_file:
json.dump(data, write_file)
|
1 2 |
withopen(«data_file.json»,»w»)aswrite_file json.dump(data,write_file) |
Обратите внимание на то, что dump() принимает два позиционных аргумента: (1) объект данных, который сериализуется и (2), файловый объект, в который будут вписаны байты. Или, если вы склонны продолжать использовать эти сериалзированные данные JSON в вашей программе, вы можете работать как со строкой
Или, если вы склонны продолжать использовать эти сериалзированные данные JSON в вашей программе, вы можете работать как со строкой.
Python
json_string = json.dumps(data)
| 1 | json_string=json.dumps(data) |
Обратите внимание, что файловый объект является пустым, так как вы на самом деле не выполняете запись на диск. Кроме того, dumps() аналогичен dump()
Ура! У вас получился малыш JSON и вы можете выпустить его в реальный мир, чтобы он вырос большим и сильным.
Несколько полезных аргументов
Помните, что JSON создан таким образом, чтобы быть читаемым для людей. Но читаемого синтаксиса недостаточно, если все слеплено вместе. Кроме этого, ваш стиль программирования скорее всего отличается от моего, и вам будет проще читать код, если он отформатирован по вашему вкусу.
Первая опция, которую большинство людей хотят поменять, это пробел. Вы можете использовать аргумент indent для определения размера отступа вложенных структур. Ощутите разницу лично, используя данные, упомянутые выше и выполните следующие команды в консоли:
Python
json.dumps(data)
json.dumps(data, indent=4)
|
1 2 |
json.dumps(data) json.dumps(data,indent=4) |
Еще один вариант форматирования — это аргумент separators. По умолчанию, это двойной кортеж строк разделителя («, «, «: «), но обычно в качестве альтернативы для компактного JSON является («,», «:»). Взгляните на пример JSON еще раз, чтобы понять, где в игру вступают разделители.
Есть и другие аргументы, такие как sort_keys, но я не имею понятия, что он делает. Вы можете найти полный список в , если вам интересно.
Performance
Serialization and deserialization performance of orjson is better than
ultrajson, rapidjson, simplejson, or json. The benchmarks are done on
fixtures of real data:
-
twitter.json, 631.5KiB, results of a search on Twitter for «一», containing
CJK strings, dictionaries of strings and arrays of dictionaries, indented. -
github.json, 55.8KiB, a GitHub activity feed, containing dictionaries of
strings and arrays of dictionaries, not indented. -
citm_catalog.json, 1.7MiB, concert data, containing nested dictionaries of
strings and arrays of integers, indented. -
canada.json, 2.2MiB, coordinates of the Canadian border in GeoJSON
format, containing floats and arrays, indented.
Latency
twitter.json serialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 0.59 | 1698.8 | 1 |
| ujson | 2.14 | 464.3 | 3.64 |
| rapidjson | 2.39 | 418.5 | 4.06 |
| simplejson | 3.15 | 316.9 | 5.36 |
| json | 3.56 | 281.2 | 6.06 |
twitter.json deserialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 2.28 | 439.3 | 1 |
| ujson | 2.89 | 345.9 | 1.27 |
| rapidjson | 3.85 | 259.6 | 1.69 |
| simplejson | 3.66 | 272.1 | 1.61 |
| json | 4.05 | 246.7 | 1.78 |
github.json serialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 0.07 | 15265.2 | 1 |
| ujson | 0.22 | 4556.7 | 3.35 |
| rapidjson | 0.26 | 3808.9 | 4.02 |
| simplejson | 0.37 | 2690.4 | 5.68 |
| json | 0.35 | 2847.8 | 5.36 |
github.json deserialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 0.18 | 5610.1 | 1 |
| ujson | 0.28 | 3540.7 | 1.58 |
| rapidjson | 0.33 | 3031.5 | 1.85 |
| simplejson | 0.29 | 3385.6 | 1.65 |
| json | 0.29 | 3402.1 | 1.65 |
citm_catalog.json serialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 0.99 | 1008.5 | 1 |
| ujson | 3.69 | 270.7 | 3.72 |
| rapidjson | 3.55 | 281.4 | 3.58 |
| simplejson | 11.76 | 85.1 | 11.85 |
| json | 6.89 | 145.1 | 6.95 |
citm_catalog.json deserialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 4.53 | 220.5 | 1 |
| ujson | 5.67 | 176.5 | 1.25 |
| rapidjson | 7.51 | 133.3 | 1.66 |
| simplejson | 7.54 | 132.7 | 1.66 |
| json | 7.8 | 128.2 | 1.72 |
canada.json serialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 4.72 | 198.9 | 1 |
| ujson | 17.76 | 56.3 | 3.77 |
| rapidjson | 61.83 | 16.2 | 13.11 |
| simplejson | 80.6 | 12.4 | 17.09 |
| json | 52.38 | 18.8 | 11.11 |
canada.json deserialization
| Library | Median latency (milliseconds) | Operations per second | Relative (latency) |
|---|---|---|---|
| orjson | 10.28 | 97.4 | 1 |
| ujson | 16.49 | 60.5 | 1.6 |
| rapidjson | 37.92 | 26.4 | 3.69 |
| simplejson | 37.7 | 26.5 | 3.67 |
| json | 37.87 | 27.6 | 3.68 |
Memory
orjson’s memory usage when deserializing is similar to or lower than
the standard library and other third-party libraries.
This measures, in the first column, RSS after importing a library and reading
the fixture, and in the second column, increases in RSS after repeatedly
calling on the fixture.
| Library | import, read() RSS (MiB) | loads() increase in RSS (MiB) |
|---|---|---|
| orjson | 13.5 | 2.5 |
| ujson | 14 | 4.1 |
| rapidjson | 14.7 | 6.5 |
| simplejson | 13.2 | 2.5 |
| json | 12.9 | 2.3 |
github.json
| Library | import, read() RSS (MiB) | loads() increase in RSS (MiB) |
|---|---|---|
| orjson | 13.1 | 0.3 |
| ujson | 13.5 | 0.3 |
| rapidjson | 14 | 0.7 |
| simplejson | 12.6 | 0.3 |
| json | 12.3 | 0.1 |
citm_catalog.json
| Library | import, read() RSS (MiB) | loads() increase in RSS (MiB) |
|---|---|---|
| orjson | 14.6 | 7.9 |
| ujson | 15.1 | 11.1 |
| rapidjson | 15.8 | 36 |
| simplejson | 14.3 | 27.4 |
| json | 14 | 27.2 |
canada.json
| Library | import, read() RSS (MiB) | loads() increase in RSS (MiB) |
|---|---|---|
| orjson | 17.1 | 15.7 |
| ujson | 17.6 | 17.4 |
| rapidjson | 18.3 | 17.9 |
| simplejson | 16.9 | 19.6 |
| json | 16.5 | 19.4 |
Reproducing
The above was measured using Python 3.8.3 on Linux (x86_64) with
orjson 3.3.0, ujson 3.0.0, python-rapidson 0.9.1, and simplejson 3.17.2.
The latency results can be reproduced using the and
scripts. The memory results can be reproduced using the script.
Итоги
Поздравляю, теперь вы обладаете могущественной силой JSON для любых ваших потребностей в Python.
Хотя примеры, с которыми вы работали, безусловно, оригинальные и чрезмерно упрощены, они демонстрируют рабочий процесс, который вы можете применить к более общим задачам:
- Импорт модуля json
- Чтение данных с load() или loads()
- Обработка данных
- Запись измененных данных при помощи dump() или dumps()
Что вы будете делать с данными, после того как они загрузились в память — зависит от вашего случая. В целом, ваша задача — собрать данные из источника, извлечение полезной информации, и передача этой информации (или ее запись).
Сегодня вы проделали небольшое путешествие: вы поймали и приручили JSON, и вернулись домой как раз к ужину! И в качестве бонуса, научившись работать с модулем json, можете начать изучение модулей pickle и marshal.
Спасибо за внимание, и удачи с вашими начинаниями в Python!
