Модуль json

Class instances¶

can serialize class instances.

If the class behaves normally (not generated dynamic, no or magic, etc) and all it’s attributes are serializable, then this should work by default.

# json_tricks/test_class.py
class MyTestCls
        def __init__(self, **kwargs):
                for k, v in kwargs.items():
                        setattr(self, k, v)

cls_instance = MyTestCls(s='ub', dct={'7' 7})

json = dumps(cls_instance, indent=4)
cls_instance_again = loads(json)

You’ll get your instance back. Here the json looks like this:

{
        "__instance_type__" 
                "json_tricks.test_class",
                "MyTestCls"
        ],
        "attributes" {
                "s" "ub",
                "dct" {
                        "7" 7
                }
        }
}

As you can see, this stores the module and class name. The class must be importable from the same module when decoding (and should not have changed).
If it isn’t, you have to manually provide a dictionary to when loading in which the class name can be looked up. Note that if the class is imported, then is such a dictionary (so try ).
Also note that if the class is defined in the ‘top’ script (that you’re calling directly), then this isn’t a module and the import part cannot be extracted. Only the class name will be stored; it can then only be deserialized in the same script, or if you provide .

Note that this also works with without having to do anything (thanks to ), which encodes like this (custom indentation):

{
        "__instance_type__" "module.path", "ClassName"],
        "slots" {"slotattr" 37},
        "attributes" {"dictattr" 42}
}

If the instance doesn’t serialize automatically, or if you want custom behaviour, then you can implement and methods, like so:

class CustomEncodeCls
        def __init__(self):
                self.relevant = 42
                self.irrelevant = 37

        def __json_encode__(self):
                # should return primitive, serializable types like dict, list, int, string, float...
                return {'relevant' self.relevant}

        def __json_decode__(self, **attrs):
                # should initialize all properties; note that __init__ is not called implicitly
                self.relevant = attrs'relevant'
                self.irrelevant = 12

JSON-Encoder.

Синтаксис:

import json

json.JSONEncoder(*, skipkeys=False, ensure_ascii=True, 
              check_circular=True, allow_nan=True, 
              sort_keys=False, indent=None, 
              separators=None, default=None)

Параметры:

• — игнорирование не базовых типов ключей в словарях,
• — экранирование не-ASSCI символов,
• — проверка циклических ссылок,
• — представление значений , , в JSON,
• — сортировка словарей,
• — количество отступов при сериализации,
• — разделители используемые в JSON,
• — метод подкласса для объектов, которые не могут быть сериализованы,

Описание:

Функция модуля расширяет возможности преобразование структур данных Python в формат JSON.

Поддерживает следующие объекты и типы по умолчанию:

Python	JSON

Чтобы расширить возможности преобразование других объектов, создайте подкласс и реализуйте в нем метод , который возвращает сериализуемый объект для , если это возможно, в противном случае он должен вызвать реализацию суперкласса, которая будет вызвать исключение .

Если аргумент имеет значение (по умолчанию), то вызывается для попытки преобразования ключей, которые не являются , , или . Если имеет значение , такие элементы просто пропускаются.

Если аргумент имеет значение (по умолчанию), на выходе гарантированно все входящие не ASCII символы будут экранированы последовательностями \uXXXX. Если имеет значение , то не ASCII символы будут выводиться как есть.

Если аргумент (по умолчанию), тогда списки, словари и самостоятельно закодированные объекты будут проверяться на циклические ссылки во время кодировки, чтобы предотвратить бесконечную рекурсию, что может вызвать исключение . В другом случае, такая проверка не выполняется.

Если аргумент (по умолчанию: ), при каждой попытке сериализировать значение , выходящее за допустимые пределы (, , ), будет возникать исключение , в соответствии с сертификацией JSON. В случае если , будут использованы JavaScript аналоги (, , ).

Если аргумент (по умолчанию: False), выводимый словарь будет отсортирован по именам ключей, что полезно для регрессивного тестирования.

Если аргумент является неотрицательным целым числом или строкой, то вложенные объекты и массивы JSON будут выводиться с этим количеством отступов. Если уровень отступа равен 0, отрицательный или является пустой строкой , будут использоваться новые строки без отступов. Если (по умолчанию), то на выходе JSON будет наиболее компактным. Если будет строкой типа , то это значение будет использоваться в качестве отступа.

Если указан аргумент , то он должен быть кортежем типа . По умолчанию используется если . Для получения наиболее компактного представления JSON следует использовать , чтобы уменьшить количество пробелов.

Значение должно быть методом подкласса . Он вызывается для объектов, которые не могут быть сериализованы. Метод должен вернуть кодируемую версию объекта JSON или вызывать исключение . Если аргумент не указан и какой-то из объектов не может быть преобразован в JSON, то возникает ошибка .

Методы класса .

Реализует метод в подклассе так, чтобы он возвращал сериализуемый объект для или вызывал базовую реализацию.

Например, чтобы поддерживать произвольные итераторы, вы можете реализовать метод следующим образом:

def default(self, obj):
   try
       iterable = iter(obj)
   except TypeError
       pass
   else
       return list(iterable)
   # базовый класс вызывает исключение TypeError
   return json.JSONEncoder.default(self, obj)

Возвращает строковое представление JSON структуры данных Python.

json.JSONEncoder().encode({"foo" \"bar", "baz"\]})
'{"foo": \}'

Преобразовывает переданный объект o и выдаёт каждое строковое представление, как только оно становится доступным. Например:

for chunk in json.JSONEncoder().iterencode(bigobject):
    mysocket.write(chunk)

Примеры использования:

>>> 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 json.JSONEncoder.default(self, obj)
...
>>> json.dumps(2 + 1j, cls=ComplexEncoder)
# ''
>>> ComplexEncoder().encode(2 + 1j)
# ''
>>> list(ComplexEncoder().iterencode(2 + 1j))
# ']

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

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

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.

numpy scalars¶

It’s not possible (without a lot of hacks) to encode numpy scalars. This is the case because some numpy scalars (float64, and depending on Python version also int64) are subclasses of float and int. This means that the Python json encoder will stringify them without them ever reaching the custom encoders.

So if you really want to encode numpy scalars, you’ll have to do the conversion beforehand. For that purpose you can use encode_scalars_inplace, which mutates a nested data structure (in place!) to replace any numpy scalars by their representation. If you serialize this result, it can subsequently be loaded without further adaptations.

It’s not great, but unless the Python json module changes, it’s the best that can be done. See issue 18 for more details.

(obj)

Searches a data structure of lists, tuples and dicts for numpy scalars
and replaces them by their dictionary representation, which can be loaded
by json-tricks. This happens in-place (the object is changed, use a copy).

Python JSON Cheat Sheet

Python JSON Function	Description
json.dumps(person_data)	Create JSON Object
json.dump(person_data, file_write)	Create JSON File using File I/O of Python
compact_obj = json.dumps(data, separators=(‘,’,’:’))	Compact JSON Object by removing space character from JSON Object using separator
formatted_obj = json.dumps(dic, indent=4, separators=(‘,’, ‘: ‘))	Formatting JSON code using Indent
sorted_string = json.dumps(x, indent=4, sort_keys=True)	Sorting JSON object key by alphabetic order
complex_obj = json.dumps(4 + 5j, default=complex_encode)	Python Complex Object encoding in JSON
JSONEncoder().encode(colour_dict)	Use of JSONEncoder Class for Serialization
json.loads(data_string)	Decoding JSON String in Python dictionary using json.loads() function
json.loads(‘{«__complex__»: true, «real»: 4, «img»: 5}’, object_hook = is_complex)	Decoding of complex JSON object to Python
JSONDecoder().decode(colour_string)	Use of Decoding JSON to Python with Deserialization

Основные методы

Метод json dump

Сериализует в JSON-подобный формат записывая его в (который поддерживает ) используя эту .

Если (по умолчанию: ), тогда ключи словаря не базового типа (, , , , ) будут пропущены, вместо того, чтобы вызывать исключение .

Модуль всегда создает объекты , не . Следовательно, должен поддерживать ввод .

Когда (по умолчанию), все не-ASCII символы в выводе будут экранированы последовательностями ,. Если , эти символы будут записаны как есть.

Когда (по умолчанию: ), тогда проверка циклических ссылок для типов контейнера будет пропущена, а такие ссылки будут вызывать (или ошибку серьёзнее).

Если (по умолчанию: ), при каждой попытке сериализировать значение , выходящее за допустимые пределы (, , ), будет возникать , в соответствии с сертификацией JSON. В случае если , будут использованы JavaScript аналоги (, , ).

Когда является неотрицательным целым числом или строкой, то объекты и массивы JSON будут выводиться с этим количеством отступов. Если уровень отступа равен 0, отрицательный или , будут использоваться новые строки без отступов. (по умолчанию) отражает наиболее компактное представление. Если строка (например, ), эта строка используется в качестве отступа.

должны быть tuple . По умолчанию используется значение если и при другом значении. Чтобы получить наиболее компактное представление JSON, вы должны указать .

Значение должно быть функцией. Он вызывается для объектов, которые не могут быть сериализованы. Функция должна вернуть кодируемую версию объекта JSON или вызывать . Если не указано, возникает ошибка .

Если (по умолчанию: ), ключи выводимого словаря будут отсортированы.

Чтобы использовать собственный подкласс (например, тот который переопределяет метод для сериализации дополнительных типов), укажите его с помощью аргумента ; в противном случае используется .

Метод json dumps

Сериализирует в строку формата JSON с помощью . Аргументы имеют то же значение, что и для .

Ключи в парах ключ/значение всегда являются строками. Когда словарь конвертируется в JSON, все ключи словаря преобразовываются в строки. Если в результате, сначала конвертировать его в JSON, а потом обратно, новый в словарь может отличаться от, то можно получить словарь идентичный исходному. Другими словами, если x имеет не строковые ключи.

Метод json load

Десериализует из (текстовый или бинарный файл, который поддерживает метод и содержит JSON документ) в объект Python используя эту таблицу конвертации.

— опциональная функция, которая применяется к результату декодирования объекта. Использоваться будет значение, возвращаемое этой функцией, а не полученный словарь . Эта функция используется для реализации пользовательских декодеров (например JSON-RPC).

— опциональная функция, которая применяется к результату декодирования объекта с определенной последовательностью пар ключ/значение. Вместо исходного словаря будет использоваться результат, возвращаемый функцией. Эта функция используется для реализации пользовательских декодеров. Если задан , будет в приоритете.

В случае определения , он будет вызван для каждого значения JSON с плавающей точкой. По умолчанию, это эквивалентно . Можно использовать другой тип данных или парсер для этого значения (например )

В случае определения , он будет вызван для декодирования строк JSON int. По умолчанию, эквивалентен . Можно использовать другой тип данных или парсер для этого значения (например ).

В случае определения , он будет вызван для строк: , , . Может быть использован для вызова исключений при обнаружении недопустимых чисел JSON. больше не вызывается при .

Чтобы использовать собственный подкласс , укажите его с помощью аргумента ; в противном случае используется . Дополнительные аргументы ключевого слова будут переданы конструктору класса.

Если десериализованные данные не являются допустимым документом JSON, возникнет .

Метод json loads

Десериализует (экземпляр , или , содержащий JSON документ) в объект Python используя таблицу конвертации.

Остальные аргументы аналогичны аргументам в , кроме кодировки, которая устарела либо игнорируется.

Если десериализованные данные не являются допустимым документом JSON, возникнет ошибка .

Сохранение данных в JSON

Чтобы записать информацию в формате JSON с помощью средств языка Python, нужно прежде всего подключить модуль json, воспользовавшись командой import json в начале файла с кодом программы. Метод dumps отвечает за автоматическую упаковку данных в JSON, принимая при этом переменную, которая содержит всю необходимую информацию. В следующем примере демонстрируется кодирование словаря под названием dictData. В нем имеются некие сведения о пользователе интернет-портала, такие как идентификационный код, логин, пароль, полное имя, номер телефона, адрес электронной почты и данные об активности. Эти значения представлены в виде обычных строк, а также целых чисел и булевых литералов True/False.

import json
dictData = { "ID"       : 210450,
             "login"    : "admin",
             "name"     : "John Smith",
             "password" : "root",
             "phone"    : 5550505,
             "email"    : "smith@mail.com",
             "online"   : True }
jsonData = json.dumps(dictData)
print(jsonData)

{"ID": 210450, "login": "admin", "name": "John Smith", "password": "root", "phone": 5550505, "email": "smith@mail.com", "online": true}

Результат выполнения метода dumps передается в переменную под названием jsonData. Таким образом, словарь dictData был преобразован в JSON-формат всего одной строчкой. Как можно увидеть, благодаря функции print, все сведения были закодированы в своем изначальном виде. Стоит заметить, что данные из поля online были преобразованы из литерала True в true.

С помощью Python сделаем запись json в файл. Для этого дополним код предыдущего примера следующим образом:

with open("data.json", "w") as file:
    file.write(jsonData)

Подробнее про запись данных в текстовые файлы описано в отдельной статье на нашем сайте.

Создайте свой собственный кодер JSON

Модуль использует кодер под названием , который использует правила в приведенной выше таблице для кодирования объектов Python.

Однако он не кодирует все объекты Python, и в зависимости от проблемы, с которой мы сталкиваемся, нам может потребоваться написать наш собственный кодер JSON, чтобы кодировать эти объекты особым образом.

Для этого мы должны написать свой собственный класс кодировщика. Давайте назовем его . Это должно расширить класс , чтобы добавить к его существующим функциям.

Для этой демонстрации мы возьмем массивы numpy и преобразуем их в объекты Python JSON. Теперь модуль json по умолчанию не может обрабатывать массивы numpy, поэтому, если вы попытаетесь преобразовать массив numpy без нашего расширенного класса, вы получите ошибку типа:

TypeError: Object of type ndarray is not JSON serializable

Давайте напишем этот класс для сериализации и кодирования массива numpy в объекты json, а также путем преобразования его в список Python в нашем методе handler.

import json
import numpy as np

class MyEncoder(json.JSONEncoder):
    # Handles the default behavior of
    # the encoder when it parses an object 'obj'
    def default(self, obj):
        # If the object is a numpy array
        if isinstance(obj, np.ndarray):
            # Convert to Python List
            return obj.tolist()
        else:
            # Let the base class Encoder handle the object
            return json.JSONEncoder.default(self, obj)


# Numpy array of floats
a = np.arange(1, 10, 0.5)
print(type(a), a)

# Pass our encoder to json.dumps()
b = json.dumps(a, cls=MyEncoder)
print(b)

Наконец, мы кодируем его, передавая имя класса параметру |/json.dumps()

Таким образом, вызов кодирования будет:

json_object = json.dumps(python_object, cls=MyEncoder)

Выход

Действительно, наш пользовательский кодер теперь может преобразовывать массивы numpy в объекты 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, но я не имею понятия, что он делает. Вы можете найти полный список в , если вам интересно.

Преобразование данных JSON

В предыдущих двух разделах вы могли заметить, что список Python преобразуется в данные JSONArray, а словарь Python становится JSONObject. Итак, какой объект Python по умолчанию преобразован в объект JSON, показан в таблице ниже.

dict	object
list, tuple	array
str	string
int, float, int — производные от float перечисления	number
True	true
False	false
None	null

Кроме того, если вы конвертируете JSONArray, вы получите список. Так что здесь тоже есть некоторые правила. Итак, в следующих таблицах показан тип данных JSON, которые преобразуются в данные.

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

Convert from Python to JSON

If you have a Python object, you can convert it into a JSON string by
using the method.

Example

Convert from Python to JSON:

import json# a Python object (dict):x = {  «name»:
«John»,  «age»: 30,  «city»: «New York»}#
convert into JSON:y = json.dumps(x)# the result is a JSON string:
print(y)

You can convert Python objects of the following types, into JSON strings:

• dict
• list
• tuple
• string
• int
• float
• True
• False
• None

Example

Convert Python objects into JSON strings, and print the values:

import jsonprint(json.dumps({«name»: «John», «age»: 30}))print(json.dumps())print(json.dumps((«apple», «bananas»)))
print(json.dumps(«hello»))print(json.dumps(42))print(json.dumps(31.76))print(json.dumps(True))print(json.dumps(False))print(json.dumps(None))

When you convert from Python to JSON, Python objects are converted into the JSON (JavaScript) equivalent:

Python	JSON
dict	Object
list	Array
tuple	Array
str	String
int	Number
float	Number
True	true
False	false
None	null

Example

Convert a Python object containing all the legal data types:

import jsonx = {  «name»:
«John»,  «age»: 30,  «married»: True, 
«divorced»: False,  «children»: («Ann»,»Billy»),  «pets»:
None,  «cars»:
}print(json.dumps(x))

json.dumps()

В этом разделе мы узнаем, как преобразовать данные Python в данные JSON. Задача очень простая. Сначала импортируйте модуль json. Затем используйте функцию json.dumps() для декодирования данных json. Ниже приведен простой пример функции json.dumps() в Python.

import json

# initialize different data
str_data = 'normal string'
int_data = 1
float_data = 1.50
list_data = 
nested_list = 
dictionary = {
    'int': int_data,
    'str': str_data,
    'float': float_data,
    'list': list_data,
    'nested list': nested_list
}

# convert them to JSON data and then print it
print('String :', json.dumps(str_data))
print('Integer :', json.dumps(int_data))
print('Float :', json.dumps(float_data))
print('List :', json.dumps(list_data))
print('Nested List :', json.dumps(nested_list, indent=2))
print('Dictionary :', json.dumps(dictionary, indent=2))  # the json data will be indented

Вы получите такой результат.

String : "normal string"
Integer : 1
Float : 1.5
List : 
Nested List : 
]
Dictionary : {
  "int": 1,
  "str": "normal string",
  "float": 1.5,
  "list": ,
  "nested list": 
  ]
}

Создание объектов 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 —

• Описывает ваш существующий формат данных.
• Четкая, понятная человеку и машинная документация.
• Полная структурная проверка, полезная для автоматизированного тестирования.
• Полная структурная проверка, проверка данных, предоставленных клиентом.

Способ 1: Использование json.load () для чтения файла json в python

JSON Module Это встроенный модуль в Python3, который предоставляет нам возможности обработки файлов JSON, используя Отказ

Мы можем построить объект Python после того, как мы напрямую прочитаем файл JSON в Python, используя этот метод.

Предположить это файл JSON со следующим содержимым:

{
"name": "AskPython",
"type": "website",
"language": "Python"
}

Мы можем загрузить объекты JSON в объект Python, используя следующую программу. Теперь мы можем легко получить доступ к нему, используя {ключ: значение} Пары сопоставления словаря!

import json
 
with open("sample.json", "r") as rf:
    decoded_data = json.load(rf)
 
print(decoded_data)
# Check is the json object was loaded correctly
try:    
    print(decoded_data)
except KeyError:
    print("Oops! JSON Data not loaded correctly using json.loads()")

Выход

{'name': 'AskPython', 'type': 'website', 'language': 'Python'}
AskPython

Действительно, мы смогли правильно загружать наши объекты JSON из нашего файла!

Способ 2: Используйте IJSON для больших файлов JSON

Если ваш файл JSON достаточно велик, так что он дорого принести весь контент в память, лучший подход будет преобразовать содержимое файла в Потоки Использование Отказ

Поток представляет собой коллекцию объектов (так же, как объекты JSON), которые будут загружены на память Только по требованию Отказ Это означает, что наш погрузчик данных загружает данные «Lazy», то есть только при необходимости.

Это ослабляет требование памяти при работе с большими файлами. Содержание потока хранится во временном буфере, что позволяет справиться с гигабайтами файлов JSON!

Чтобы установить Используйте PIP!

pip install ijson

Теперь, чтобы поэкспериментировать, мы будем использовать несколько маленький файл JSON, так как он будет много времени для загрузки гигабайт данных!

Я буду использовать файл covid thumeries json, на это связь. Загрузите файл и переименуйте это как Отказ Размер файла должен составлять около 2 МБ.

import ijson

for prefix, type_of_object, value in ijson.parse(open("covid_timeseries.json")):
    print(prefix, type_of_object, value)

Образец вывода (несколько строк)

Yemen.item.date string 2020-4-13
Yemen.item map_key confirmed
Yemen.item.confirmed number 1
Yemen.item map_key deaths
Yemen.item.deaths number 0
Yemen.item map_key recovered
Yemen.item.recovered number 0
Yemen.item end_map None
Yemen.item start_map None
Yemen.item map_key date
Yemen.item.date string 2020-4-14
Yemen.item map_key confirmed
Yemen.item.confirmed number 1
Yemen.item map_key deaths
Yemen.item.deaths number 0
Yemen.item map_key recovered
Yemen.item.recovered number 0
Yemen.item end_map None
Yemen end_array None

Это будет распечатать содержимое огромного файла JSON, но вы можете сохранить счетчик счетчиков, чтобы избежать печати всего файла.

В то время как Может быть медленным, кажется, работает в пределах меньшей памяти. Вы можете попробовать этот модуль, если вы работаете с большими файлами.

Packaging

rustup default nightly
pip wheel --no-binary=orjson orjson

This is an example of building a wheel using the repository as source,
installed from upstream, and a pinned version of Rust:

pip install maturin
curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain nightly-2021-05-25 --profile minimal -y
maturin build --no-sdist --release --strip --manylinux off
ls -1 target/wheels

Problems with the Rust nightly channel may require pinning a version.
is known to be ok.

orjson is tested for amd64 and aarch64 on Linux, macOS, and Windows. It
may not work on 32-bit targets. It has recommended
specified in so it is recommended to either not set
or include these options.

There are no runtime dependencies other than libc.

orjson’s tests are included in the source distribution on PyPI. It is
necessarily to install dependencies from PyPI specified in
. These require a C compiler. The tests do not
make network requests.

The tests should be run as part of the build. It can be run like this:

pip install -r test/requirements.txt
pytest -q test