В этой статье рассмотрим основные библиотеки Python, заточенные под JSON и XML. Подберем решения для парсинга, генерации, валидации и оптимизации работы с ними.
Что такое JSON и XML
JSON и XML — это форматы для хранения информации. Их используют для обмена данными в веб-разработке между клиентом и сервером, поэтому они часто встречаются при работе с AP.
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 кода.
Модуль, пакет, библиотека, фреймворк: разбираемся в разницеtproger.ru
Элементы состоят из тегов — они бывают открывающими и закрывающими. Открывающий тег состоит из знака меньше “<”, имени и знака больше “>”.
Аналогично с закрывающим тегом. Но к нему добавляем слэш “/” после знака меньше “<”. Вот так:
<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: также обрабатывает большие объемы информации по кусочкам.
Если вы пользуетесь другими библиотеками или фичами — рассказывайте о них в комментариях.