Работа с JSON и XML в Python: парсинг, генерация и валидация

Что такое JSON и XML

JSON и XML — это форматы для хранения информации. Их используют для обмена данными в веб-разработке между клиентом и сервером, поэтому они часто встречаются при работе с API.

Если вы хотите научиться работать с этими форматами и эффективно обрабатывать данные, рекомендуем пройти курс по Python.

JSON (JavaScript Object Notation)

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

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

Перед объектом ставятся фигурные скобки {}. Далее идет имя ключа в кавычках “”, двоеточие и значение.

			Объект{“ключ”: значение}
		

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

Пример синтаксиса JSON:

			{
  "name": "Alice",              // Строка
  "age": 25,                    // Число
  "isStudent": false,           // Булево значение
  "courses": ["Math", "Physics"], // Массив строк
  "address": {                  // Объект
    "city": "New York",
    "zip": "10001"
  },
  "graduationYear": null        // Пустое значение
}
		

XML (eXtensible Markup Language)

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

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

			<?xml version="1.0" encoding="UTF-8"?>
		

Далее идет структура из элементов, внутри которых хранится наша информация с разными типами данных. Этот принцип напоминает устройство HTM кода.

Элементы состоят из тегов — они бывают открывающими и закрывающими. Открывающий тег состоит из знака меньше “<”, имени и знака больше “>”.

Аналогично с закрывающим тегом. Но к нему добавляем слэш “/” после знака меньше “<”. Вот так:

			<city>New York</city> <!-- // Первый тег "city"открывающий, второй — закрывающий-->
		

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

Для открывающих тегов есть возможность прописывать атрибуты — они позволяют указывать дополнительную информацию для элементов. Делается это вот так:

			<name gender="female">Alice</name> <!-- // Элемент "name", содержащий строку "Alice" -->
		

Здесь мы написали атрибут gender со значением “female”

При написании кода мы должны заключить все элементы в один главный элемент. Его называют корневым:

			<person>
	<name gender="female">Alice</name> <!-- // Элемент "name", содержащий строку "Alice" -->
	<city>New York</city> <!-- // Элемент "city", содержащий строку "New York" -->
</person>
		

В этом примере <person> корневой элемент.

Библиотеки python для работы с JSON и XML

Существует много библиотек для работы с JSON и XML. Ниже перечислены основные из них.

Библиотеки для работы с JSON

json

• Не нужно устанавливать, встроена по умолчанию.
• Может парсить из строк и файлов.
• Способна конвертировать объекты в JSON-строки.

SimpleJSON

• Может парсить из строк и файлов.
• Способна создавать JSON-строки из объектов.
• Предоставляет более гибкие опции кодирования и декодирования по сравнению с встроенной json.

ujson

• Может парсить из строк и файлов.
• Способна конвертировать объекты в JSON-строки.
• Отличается высокой скоростью работы благодаря реализации на C.

orjson

• Может парсить из строк и файлов.
• Способна создавать JSON-строки из объектов.
• Производительная благодаря реализации на Rust.
• Поддерживает только Python версии 3.6 и выше.
  

ijson

• Может парсить из строк и файлов.
• Экономит память за счет потоковой обработки данных.

jsonschema

• Специализируется на валидации.
• Поддерживает различные версии спецификации JSON Schema.

cerberus

• Специализируется на валидации.
• Поддерживает валидацию сложных вложенных структур и поддерживает пользовательские правила валидации.

Библиотеки для работы с XML

xml.etree.ElementTree

• Встроена по умолчанию.
• Может парсить из строки и файлов.
• Способна создавать и редактировать XML-строки и файлы.

lxml

• Может парсить из строки и файлов.
• Способна создавать и редактировать XML-строки и файлы.
• Поддерживает валидацию.
• Обеспечивает высокую производительность благодаря реализации на C.

xml.dom.minidom

• Встроена по умолчанию.
• Может парсить из строки и файлов.
• Способна создавать и редактировать XML-строки и файлы.
• Предоставляет DOM-интерфейс для работы с XML.

xml.sax

• Встроена по умолчанию.
• Может парсить из строки и файлов. 
• Позволяет создавать собственные обработчики для XML-элементов.
• Эффективна для обработки больших XML-файлов, так как не загружает весь документ в память.

xmlschema

• Может парсить из строки и файлов.
• Выполняет валидацию XML-документов.
• Способна генерировать объекты из XML-данных.
• Позволяет создавать XML-схемы.

xmltodict

• Может парсить из строки и файлов.
• Преобразует XML в словари.
• Способна создавать XML-строки из словарей.

BeautifulSoup

• Может парсить XML и HTML из строки и файлов.

Парсинг данных из JSON и XML

Парсинг — это извлечение данных для последующей обработки и анализа. Давайте представим, что мы ищем новую работу. Для этого ходим по сайтам IT-агентств и сохраняем их контакты себе в таблицу. Это простейший пример парсинга.

Примеры извлечения JSON данных в разных библиотеках

Предположим, что нам надо спарсить вот этот код и вытащить из него значение "occupation".

			json_string = """
{
"name": "Alice",
"age": 25,
"city": "London",
"occupation": "Software Engineer"
}
"""
		

json

Если данные уже находятся у нас в виде строки, то мы можем вызвать функцию json.loads() для извлечения:

			import json

# Преобразуем JSON строку в словарь Python
data = json.loads(json_string)

# Выводим значение ключа "occupation"
print(data["occupation"])  #
Вывод: Software Engineer
		

Здесь мы принимаем JSON и записываем его в словарь Python. Далее выводим значение ключа "occupation".

simplejson

Представим, что у нас не строка, а файл json_string.json:

			import simplejson as json

# Открываем файл json_string.json в режиме чтения ('r')
with open('json_string.json', 'r') as f:
  # Используем json.load() из SimpleJSON
для чтения и парсинга JSON из файла
  data = json.load(f)

# Выводим значение ключа "occupation"
print(data["occupation"])  #
Вывод: Software Engineer
		

Мы открываем файл json_string.json и называем его f. Далее читаем JSON из файла f с помощью json.load(f) и превращаем в словарь data. В конце возвращаем значение, ключа "occupation".

ujson

			import ujson

# Открываем файл json_string.json для чтения
with open('json_string.json', 'r') as f:
    # Используем ujson.load() для чтения
и парсинга JSON из файла
    data = ujson.load(f)

# Выводим значение ключа "occupation"
print(data["occupation"])  #
Вывод: Software Engineer
		

Здесь происходит то же, что и в примере выше: ujson.load(f) читает JSON из файла f и преобразует его в словарь Python, который сохраняется в data.

orjson

Если мы хотим спарсить данные по url, то понадобиться библиотека requests:

			import requests
import orjson

# Представим, что наш JSON код находится по URL
url = "https://example.com/data.json"

# Получаем данные по URL
response = requests.get(url)

# Проверяем успешность запроса
if response.status_code == 200:
    # Парсим JSON данные с помощью
orjson.loads()
    data = orjson.loads(response.content)

    # Выводим значение ключа
"occupation"
    print(data["occupation"]) 
else:
    print("Ошибка при получении
данных")
		

Функция orjson.loads(response.content) парсит по url JSON, и преобразует их в словарь data, после чего мы можем обращаться к значениям этого словаря.

Примеры извлечения XML данных в разных библиотеках

Представим, что нам нужно спарсить значение из тега name в этом коде:

			xml_string = """
<person>
  <name
attribute1="value1">John Doe</name>
  <age
attribute2="value2">30</age>
  <city>New York</city>
</person>
"""
		

xml.etree.ElementTree

			import xml.etree.ElementTree as ET

# Парсим XML из строки
root = ET.fromstring(xml_string)

# Выводим текст первого дочернего элемента
print(root[0].text)  # Вывод: John Doe
		

При помощи ET.fromstring(xml_string) мы извлекаем XML из строки и создаем объект root — он представляет корневой элемент. Далее при помощи индекса root[0] обращаемся к первому дочернему элементу <name> и выводим его значение.

lxml

			from lxml import etree

# Парсим XML из строки
root = etree.fromstring(xml_string)

# Выводим текст первого дочернего элемента
print(root[0].text)  # Вывод: John Doe
		

etree.fromstring(xml_string) извлекает данные из xml_string в объект root. Как и в примере выше, мы можем обращаться к элементам и атрибутам через root и его дочерние элементы при помощи индекса, например, root[0].

xml.dom.minidom

			from xml.dom import minidom

# Парсим XML из строки
dom = minidom.parseString(xml_string)

# Получаем первый элемент с тегом 'name'
name_element = dom.getElementsByTagName('name')[0]

# Выводим текст элемента
print(name_element.firstChild.data)  #
Вывод: John Doe
		

Здесь minidom.parseString(xml_string) извлекает XML из строки и создает объект dom. Далее команда находит первый элемент с тегом <name>, записывает его в переменную name_element и выводит значение.

xmltodict

			import xmltodict

# Парсинг XML в словарь
data_dict = xmltodict.parse(xml_string)

# Доступ к элементам и атрибутам
print(data_dict['person']['name'])  #
Вывод: John Doe
		

Библиотека анализирует XML структуру и создает словарь, где ключи — это теги XML, а значения — дочерние элементы. Мы обращаемся к элементу <name> и выводим его.

BeautifulSoup

			from bs4 import BeautifulSoup

# Парсим XML из строки
soup = BeautifulSoup(xml_string, features='xml')

# Получаем доступ к элементам и атрибутам
name_element = soup.find('name')

if name_element:
    print(name_element.text)  # Вывод: John Doe
else:
    print("Элемент 'name' не
найден")
		

При помощи BeautifulSoup(xml_string, 'xml') мы парсим из строки xml_string и указываем, что нам нужен формат xml. Далее сохраняем данные в объект soup, находим элемент с тегом <name> и выводим его значение.

Генерация данных JSON и XML в Python

Примеры генерации JSON в разных библиотеках

Библиотеки python используют схожий подход для генерации JSON. Делается это при помощи функции dumps(). Вот несколько примеров:

json

			import json

# Словарь с данными
data = {
    "name": "John
Doe",
    "age": 30,
    "city": "New
York"
}

# Преобразование словаря в JSON строку
json_string = json.dumps(data)

# Вывод JSON строки
print(json_string)
		

SimpleJSON

			import simplejson as json

# Словарь с данными
data = {
    "name": "John
Doe",
    "age": 30,
    "city": "New
York"
}

# Преобразование словаря в JSON строку
json_string = json.dumps(data)

# Вывод JSON строки
print(json_string)
		

ujson

			import ujson

# Словарь с данными
data = {
    "name": "John
Doe",
    "age": 30,
    "city": "New
York"
}

# Преобразование словаря в JSON строку
json_string = ujson.dumps(data)

# Вывод JSON строки
print(json_string)
		

orjson

			import orjson

# Словарь с данными
data = {
    "name": "John
Doe",
    "age": 30,
    "city": "New
York"
}

# Преобразование словаря в JSON байты
json_bytes = orjson.dumps(data)

# Декодирование байтов в строку UTF-8
json_string = json_bytes.decode("utf-8")

# Вывод JSON строки
print(json_string)
		

Мы создали словарь data с данными и преобразовали их в JSON.

dumps() конвертирует объект в JSON. Но если необходимо записать данные в файл, то стоит воспользоваться функцией dump().

Примеры генерации XML в разных библиотеках

Если мы хотим записать XML файл, то нам понадобятся следующие функции:

• ET.Element() — создает корневой элемент
• ET.SubElement() — создает дочерние элементы
• ET.ElementTree() — сохраняет дерево из элементов
• tree.write() — записывает xml данные в файл

xml.etree.ElementTree

			import xml.etree.ElementTree as ET

# Создание корневого элемента
root = ET.Element("person")

# Добавление дочерних элементов и их значений
name = ET.SubElement(root, "name")
name.text = "John Doe"

age = ET.SubElement(root, "age")
age.text = "30"

# Создание XML дерева
tree = ET.ElementTree(root)

# Запись XML в файл
tree.write("person.xml", encoding="utf-8",
xml_declaration=True)
		

В этом примере мы создаем корневой элемент person, добавляем дочерние элементы name и age, прописываем их значения, а затем сохраняем XML дерево в файл person.xml.

lxml

			from lxml import etree

# Создание корневого элемента
root = etree.Element("person")

# Добавление дочерних элементов
etree.SubElement(root, "name").text = "John Doe"
etree.SubElement(root, "age").text = "30"

# Создание XML дерева
tree = etree.ElementTree(root)

# Запись XML в файл
tree.write("person.xml", encoding="utf-8",
xml_declaration=True)
		

Здесь мы тоже создаем корневой элемент, добавляем дочерние элементы, формируем дерево и записываем в файл.

xmltodict

			import xmltodict

# Словарь с данными
data_dict = {
    'person': {
        'name': 'John Doe',
        'age': '30',
        'city': 'New York'
    }
}

# Генерация XML из словаря
xml_string = xmltodict.unparse(data_dict)

# Вывод XML строки
print(xml_string)
		

А это пример создания XML из словаря. Библиотека анализирует структуру словаря и создает XML документ. Ключи словаря становятся тегами, а значения — текстовым содержимым или вложенными элементами.

Примеры валидации данных в JSON и XML

Валидация — это проверка кода на соответствие определенным правилам. Например, мы создаем форму для регистрации, где будет пароль только из латинских знаков. Следовательно, нам нужно проверять символы, которые будут вводить пользователи при регистрации.

Примеры валидации JSON в jsonschema и Cerberus

jsonschema

Мы прописываем схему "schema", которая определяет наши правила. Данные должны быть объектом с ключами "name" и "age". Ключ "name" принимает только строки в качестве значений, а "age" только числа".

			from jsonschema import validate, ValidationError

# Схема JSON - определяем правила
schema = {
    "type": "object",

    "properties": {
        "name":
{"type": "string"},
        "age":
{"type": "integer"}
    },
}
		

Далее мы определяем два набора данных. Один валидный, другой нет.

			# Валидные JSON данные
valid_data = {
    "name": "John
Doe",
    "age": 30
}

# Невалидные JSON данные (age - строка)
invalid_data = {
    "name": "Jane
Doe",
    "age": "25"
}
		

Проверяем, соответствуют ли valid_data и invalid_data заданной схеме. Выводим сообщение о валидности/невалидности данных.

			# Валидация данных
try:
    validate(instance=valid_data,
schema=schema)
    print("Валидные данные: JSON
валиден")
except ValidationError as e:
    print(f"Валидные данные: Ошибка
валидации: {e}")

# Валидация невалидных данных
try:
    validate(instance=invalid_data,
schema=schema)
    print("Невалидные данные: JSON
невалиден"
		

Cerberus

			from cerberus import Validator

# Определение схемы валидации
schema = {
    'name': {'type': 'string',
'required': True},  # Имя - обязательная
строка
    'age': {'type': 'integer', 'min':
0},  # Возраст - целое число, не меньше 0
}
		

Задаем схему с правилами. Указываем, что у нас обязательно должен быть ключ "name", который принимает строку. Его наличие обязательно благодаря команде "required": True. Ключ "age" принимает только числа.

			# Создание объекта валидатора
validator = Validator(schema)

# Валидные JSON данные
valid_document = {'name': 'John Doe', 'age': 30}

# Невалидные JSON данные (отсутствует поле 'name')
invalid_document = {'age': 25}
		

Здесь мы передаем нашу схему в объект validator и определяем два набора данных. Первый — валидный, второй с ошибкой. В нем отсутствует "name".

			# Валидация валидных данных
is_valid = validator.validate(valid_document)
print(f"Результат: {is_valid}") 
# Ожидаемый вывод: True
print(f"Ошибки: {validator.errors}")

# Валидация невалидных данных
print("\nВалидация невалидных данных:")
is_valid = validator.validate(invalid_document)
print(f"Результат: {is_valid}") 
# Ожидаемый вывод: False
print(f"Ошибки: {validator.errors}") 
# Ожидаемый вывод: {'name': ['required field']}}
		

Проверяем корректность кода и выводим сообщения.

Примеры валидации XML в lxml и xmlschema

lxml

			from lxml import etree

# XML файл для валидации
xml_data = """
<person>
  <name>John Doe</name>
  <age>30</age>
</person>
"""
		

Это XML-данные, которые мы будем проверять на ошибки.

			# XSD схема для валидации
xsd_data = """
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element
name="person">
    <xs:complexType>
      <xs:sequence>
        <xs:element
name="name" type="xs:string"/>
        <xs:element
name="age" type="xs:integer"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>
"""
		

А это наша схема с правилами. Давайте разберем ее более детально.

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> — означает, что этот код является схемой и ссылается на определенный стандарт.

<xs:element name="person"> — здесь мы говорим, что элемент с тегом <person> должен быть корневым в проверяемом XML коде.

<xs:complexType> и <xs:sequence> означают, что у нас несколько элементов и они должны идти в определенном порядке. Далее мы указываем наши элементы и их тип.

			# Парсим XML и XSD
xml_doc = etree.fromstring(xml_data)
xsd_doc = etree.fromstring(xsd_data)

# Создаем объект схемы
schema = etree.XMLSchema(xsd_doc)
		

xml_data и xsd_date являются строками. Чтобы выполнить валидацию, их необходимо преобразовать в объект python. Делаем это при помощи метода etree.fromstring(). Теперь у нас есть объекты xml_doc и xsd_doc. В них хранится информация о нашем xml коде и схеме.

При помощи xsd_doc создаем новый объект схемы.

			# Валидируем XML
is_valid = schema.validate(xml_doc)

# Выводим результат
if is_valid:
    print("XML валиден!")
else:
    print("XML не валиден!")
		

Валидируем xml_doc и выводим сообщение о результате.

xmlschema

Рассмотрим вариант, при котором наша схема расположена в отдельном файле.

			from xmlschema importXMLSchema

# Определение схемы XSD
schema = XMLSchema('person.xsd')  #
Предполагается, что файл person.xsd содержит схему
		

Импортируем библиотеку и указываем файл с правилами.

			# Валидный XML документ
valid_xml = """
<person>
  <name>John Doe</name>
  <age>30</age>
</person>
"""

# Невалидный XML документ (отсутствует элемент 'name')
invalid_xml = """
<person>
  <age>25</age>
</person>
"""
		

Определяем два набора данных для проверки. Один валидный, другой нет.

			# Валидация валидного XML
print("Валидация валидного XML:")
try:
    schema.validate(valid_xml)
    print("Результат: Валидный
XML")  
except Exception as e:
    print(f"Результат: Ошибка
валидации: {e}")

# Валидация невалидного XML
print("\nВалидация невалидного XML:")
try:
    schema.validate(invalid_xml)
    print("Результат: Валидный
XML")  
except Exception as e:
    print(f"Результат: Ошибка
валидации: {e}")
		

Проверяем валидность данных в функции validate() и выводим сообщения о результате валидации при помощи условной конструкции try: except.

Работа с API JSON и XML

Теперь рассмотрим несколько простых примеров передачи данных по API.

Получение данных из API с использованием JSON

			import requests

# URL API
url = "https://api.example.com/users"
		

Импортируем библиотеку для работы с API requests и записываем адрес в переменную url.

			# Отправка GET-запроса
response = requests.get(url)

# Проверка успешного ответа
if response.status_code == 200:
    # Преобразование JSON ответа в
словарь Python
    data = response.json()
		

Отправляем запрос на наш API и проверяем ответ. Если он успешный, то записываем его в словарь data.

			# Вывод данных
    for user in data:
        print(f"Имя: {user['name']},
Email: {user['email']}")
else:
    print("Ошибка при получении
данных")
		

Выводим значения элементов name и email. Если их нет, то код покажет ошибку.

Отправка данных в API с использованием JSON

			import requests

# URL API
url = "https://api.example.com/posts"

# Данные для отправки
new_post = {
    "title": "Мой новый
пост",
    "content": "Это текст
моего нового поста",
    "author": "John
Doe"
}
		

Импортируем requests, записываем адрес API в url и определяем данные, которые надо отправить.

			# Отправка POST-запроса с JSON данными
response = requests.post(url, json=new_post)
		

Отправляем POST-запрос с данными на сервер.

			# Проверка успешного ответа
if response.status_code == 201:
    print("Пост успешно
создан")
else:
    print("Ошибка при создании
поста")
		

Если всё работает, то получаем статус-код 201 и выводим сообщение об успехе. Если данные не отправились, то выводим сообщение с ошибкой.

Получение данных из API с использованием XML

			import requests
import xmltodict

# URL API
url = "https://api.example.com/data.xml"

# Отправка GET-запроса
response = requests.get(url)
		

Импортируем библиотеки, записываем API-адрес в переменную url и отправляем GET-запрос.

			# Проверка успешного ответа
if response.status_code == 200:
    # Преобразование XML ответа в словарь
Python
    data =
xmltodict.parse(response.content)

    # Вывод данных (пример)
    print(f"Имя:
{data['person']['name']}")
else:
    print(f"Ошибка:
{response.status_code}")
		

Если запрос отправлен успешно, обращаемся к элементу name и выводим его значение.

Отправка данных в API с использованием XML

			import requests
import xmltodict

# URL API
url = "https://api.example.com/data"

# Данные для отправки
data_dict = {'person': {'name': 'John Doe', 'age': '30'}}

# Преобразование словаря в XML
xml_data = xmltodict.unparse(data_dict)
		

Всё по классике. Импортируем requests и xmltodict. Записываем API в переменную url. Создаем словарь с данными для отправки.

			# Отправка POST-запроса с XML данными
headers = {'Content-Type': 'application/xml'}
response = requests.post(url, data=xml_data, headers=headers)
		

Создаем словарь headers , в который записываем заголовок нашего запроса. Отправляем его.

			# Проверка успешного ответа
if response.status_code == 201:
    print("Данные успешно
отправлены")
else:
    print(f"Ошибка:
{response.status_code}")
		

Проверяем код ответа. Если все отправилось, то выводим соответствующее сообщение. Если нет — выводим ошибку.

Конвертация JSON и XML

Пример конвертации JSON в XML

			import xmltodict

# Пример JSON данных
json_data = {
        "person": {
            "name": "John Doe",
            "age": 30,
            "city": "New York"
    }
}
		

Импортируем библиотеку и прописываем JSON, который будем конвертировать.

			# Конвертируем JSON в XML
xml_data = xmltodict.unparse(json_data)

# Выводим XML
print(xml_data)
		

Конвертируем JSON в XML, сохраняем данные в xml_data и выводим результат.

Пример конвертации XML в JSON

			import xmltodict
import json

# Пример XML данных
xml_data = """
<person>
  <name>John Doe</name>
  <age>30</age>
  <city>New York</city>
</person>
"""
		

Импортируем библиотеки и определяем XML-данные.

			# Конвертируем XML в JSON
json_data = xmltodict.parse(xml_data)
		

Преобразуем данные в словарь json_data.

			# Выводим JSON
print(json.dumps(json_data))
		

Конвертируем словарь в JSON и выводим его.

Оптимизация работы с JSON и XML

Встроенные библиотеки Python, такие как json и xml.etree.ElementTree, обычно являются хорошим выбором для простых задач. Однако, для больших объемов или высокопроизводительных приложений они не подходят.

Производительность

С точки зрения производительности следует рассмотреть библиотеки: orjson и lxml.

Для JSON

orjson: Быстрая библиотека, написанная на Rust. Но поддерживает версию python от 3.6.

Производительность Python библиотек для работы с JSON при сериализации

Эта диаграмма показывает скорость кодирования JSON данных в объект python на примере работы с API. Как видно, orjson справляется с задачей быстрее всех.

Производительность Python библиотек для работы с JSON при десериализации

А здесь мы видим обратный процесс — преобразование Python в JSON-данные.

Эти тесты могут быть предвзятыми, поскольку проводились самими разработчиками orjson. Но другие эксперименты также подтверждают превосходство orjson.

Для XML

lxml: основана на C-библиотеках libxml2 и libxslt, обычно быстрее, чем xml.etree.ElementTree, особенно для больших XML-документов и сложных операций.

скорость обработки XML данных разными библиотеками

На этом скриншоте изображены итоги теста Python-библиотек. Они анализировали XML-файл весом в 95 мегабайт, и lxml показала себя здесь лучшим образом.

Работа с памятью

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

Для JSON:

• ijson: Эта библиотека позволяет итеративно обрабатывать данные, не загружая весь документ.

Для XML:

• xml.sax: обрабатывает данные по частям, не загружая всё в память.
• lxml: также обрабатывает большие объемы информации по кусочкам.

Если вы пользуетесь другими библиотеками или фичами — рассказывайте о них в комментариях.