Преобразование XML в JSON: 4 проверенных метода для Python

import json
import xmltodict

# XML строка с данными о книгах
xml_data = '''
<library>
<book category="fiction">
<title>Harry Potter</title>
<author>J.K. Rowling</author>
<year>1997</year>
<price>19.99</price>
</book>
<book category="science">
<title>A Brief History of Time</title>
<author>Stephen Hawking</author>
<year>1988</year>
<price>15.99</price>
</book>
</library>
'''

# Преобразование XML в словарь Python
dict_data = xmltodict.parse(xml_data)

# Преобразование словаря Python в JSON
json_data = json.dumps(dict_data, indent=4)

print(json_data)

{
"library": {
"book": [
{
"@category": "fiction",
"title": "Harry Potter",
"author": "J.K. Rowling",
"year": "1997",
"price": "19.99"
},
{
"@category": "science",
"title": "A Brief History of Time",
"author": "Stephen Hawking",
"year": "1988",
"price": "15.99"
}
]
}
}

import json
import xmltodict

xml_data = '''
<data xmlns:h="http://www.w3.org/TR/html4/">
<h:table id="123">
<h:tr>
<h:td>Cell 1</h:td>
<h:td>Cell 2</h:td>
</h:tr>
</h:table>
</data>
'''

# Настраиваем обработку пространств имен и префиксов атрибутов
dict_data = xmltodict.parse(
xml_data, 
process_namespaces=True, 
namespace_separator='.', 
attr_prefix='_'
)

json_data = json.dumps(dict_data, indent=4)
print(json_data)

import json
import xmltodict
from io import BytesIO

# Предположим, у нас большой XML-файл
with open('large_file.xml', 'rb') as f:
# Обрабатываем XML порциями с помощью итератора
xml_iter = xmltodict.parse(f, item_depth=2, item_callback=lambda path, item: True)

# Создаем JSON на лету
with open('output.json', 'w') as json_file:
json_file.write('[')
for i, item in enumerate(xml_iter):
if i > 0:
json_file.write(',')
json_file.write(json.dumps(item))
json_file.write(']')

import xml.etree.ElementTree as ET
import json

def xml_to_dict(element):
"""Рекурсивное преобразование XML элемента в словарь"""
result = {}

# Добавляем атрибуты элемента
if element.attrib:
result["@attributes"] = element.attrib

# Добавляем дочерние элементы
for child in element:
child_dict = xml_to_dict(child)

# Обрабатываем случай, когда элементы с одинаковым тегом
if child.tag in result:
# Если уже есть такой ключ, преобразуем его в список
if not isinstance(result[child.tag], list):
result[child.tag] = [result[child.tag]]
result[child.tag].append(child_dict)
else:
result[child.tag] = child_dict

# Добавляем текстовое содержимое
text = element.text.strip() if element.text else ""
if text:
if result: # Если есть другие данные, добавляем текст с особым ключом
result["#text"] = text
else: # Иначе просто возвращаем текст
result = text

return result

# Пример использования
xml_data = '''
<order id="12345">
<customer>
<name>John Doe</name>
<email>john@example.com</email>
</customer>
<item>
<name>Product 1</name>
<quantity>2</quantity>
<price>9.99</price>
</item>
<item>
<name>Product 2</name>
<quantity>1</quantity>
<price>19.99</price>
</item>
</order>
'''

# Парсинг XML
root = ET.fromstring(xml_data)

# Преобразование в словарь
xml_dict = {root.tag: xml_to_dict(root)}

# Преобразование в JSON
json_data = json.dumps(xml_dict, indent=4)

print(json_data)

{
"order": {
"@attributes": {
"id": "12345"
},
"customer": {
"name": "John Doe",
"email": "john@example.com"
},
"item": [
{
"name": "Product 1",
"quantity": "2",
"price": "9.99"
},
{
"name": "Product 2",
"quantity": "1",
"price": "19.99"
}
]
}
}

import xml.etree.ElementTree as ET
import json

def process_xml_iteratively(xml_file, json_file, target_element):
"""Обрабатывает крупный XML-файл итеративно"""
context = ET.iterparse(xml_file, events=('end',))

with open(json_file, 'w') as f:
f.write('[')
first = True

for event, elem in context:
# Обрабатываем только целевые элементы
if elem.tag == target_element:
if not first:
f.write(',')
else:
first = False

# Преобразуем элемент в словарь и затем в JSON
elem_dict = xml_to_dict(elem)
f.write(json.dumps(elem_dict))

# Освобождаем память
elem.clear()

f.write(']')

# Пример использования
process_xml_iteratively('large_data.xml', 'output.json', 'item')

pip install lxml

from lxml import etree
import json

def xml_to_json(xml_string):
# Парсим XML
root = etree.fromstring(xml_string)

# Функция для рекурсивного преобразования элементов
def element_to_dict(element):
result = {}

# Обрабатываем атрибуты
for key, value in element.attrib.items():
result[f"@{key}"] = value

# Обрабатываем текстовое содержимое
if element.text and element.text.strip():
result["#text"] = element.text.strip()

# Обрабатываем дочерние элементы
for child in element:
child_dict = element_to_dict(child)

# Получаем имя тега с учетом пространства имен
tag = child.tag
if '}' in tag:
# Убираем часть с пространством имен для краткости
tag = tag.split('}', 1)[1]

if tag in result:
if not isinstance(result[tag], list):
result[tag] = [result[tag]]
result[tag].append(child_dict)
else:
result[tag] = child_dict

# Очищаем память, если больше не нужен элемент
child.clear()

return result

# Преобразуем корневой элемент
tag = root.tag
if '}' in tag:
tag = tag.split('}', 1)[1]

result = {tag: element_to_dict(root)}

# Преобразуем в JSON
return json.dumps(result, indent=2)

# Пример использования
xml_data = '''
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<GetStockPriceResponse xmlns="http://example.com/stock">
<Price currency="USD">34.5</Price>
<Symbol>MSFT</Symbol>
<History>
<Day date="2023-01-01">33.0</Day>
<Day date="2023-01-02">34.1</Day>
</History>
</GetStockPriceResponse>
</soap:Body>
</soap:Envelope>
'''

print(xml_to_json(xml_data))

from lxml import etree

# XSLT-стиль для преобразования XML в JSON
xslt_str = '''
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="text"/>

<xsl:template match="/">
<xsl:text>{"</xsl:text>
<xsl:value-of select="local-name(/*)"/>
<xsl:text>":</xsl:text>
<xsl:apply-templates select="/*"/>
<xsl:text>}</xsl:text>
</xsl:template>

<!-- Шаблон для элементов -->
<xsl:template match="*">
<xsl:text>{</xsl:text>

<!-- Атрибуты -->
<xsl:if test="@*">
<xsl:text>"@attributes":{</xsl:text>
<xsl:for-each select="@*">
<xsl:text>"</xsl:text>
<xsl:value-of select="local-name()"/>
<xsl:text>":"</xsl:text>
<xsl:value-of select="."/>
<xsl:text>"</xsl:text>
<xsl:if test="position() != last()">,</xsl:if>
</xsl:for-each>
<xsl:text>}</xsl:text>
<xsl:if test="node()[not(self::text() and normalize-space(.)='')]">,</xsl:if>
</xsl:if>

<!-- Дочерние элементы и текстовое содержимое -->
<xsl:apply-templates select="node()[not(self::text())]"/>

<!-- Текстовое содержимое, если есть -->
<xsl:if test="text() and normalize-space(text()) != ''">
<xsl:if test="*">,</xsl:if>
<xsl:text>"#text":"</xsl:text>
<xsl:value-of select="normalize-space(text())"/>
<xsl:text>"</xsl:text>
</xsl:if>

<xsl:text>}</xsl:text>
</xsl:template>
</xsl:stylesheet>
'''

# Создаем XSLT-трансформер
xslt_root = etree.XML(xslt_str)
transform = etree.XSLT(xslt_root)

# XML для преобразования
xml = etree.parse('input.xml')

# Выполняем трансформацию
json_result = transform(xml)

# Выводим результат
print(str(json_result))

from lxml import etree
import json
import os

def process_large_xml(xml_file, json_file, element_path):
"""
Обрабатывает большой XML-файл потоково, извлекая
определенные элементы и записывая их в JSON.
"""
# Открываем файл для записи JSON
with open(json_file, 'w') as f_out:
f_out.write('[')

# Счетчик для отслеживания элементов
count = 0

# Создаем итеративный парсер
context = etree.iterparse(xml_file, events=('end',), tag=element_path)

for event, elem in context:
# Преобразуем элемент в словарь
data = {}

# Обрабатываем атрибуты
if elem.attrib:
data['@attributes'] = dict(elem.attrib)

# Обрабатываем вложенные элементы
for child in elem:
if child.tag not in data:
data[child.tag] = []

child_data = {}
if child.attrib:
child_data['@attributes'] = dict(child.attrib)
if child.text and child.text.strip():
child_data['#text'] = child.text.strip()

data[child.tag].append(child_data)

# Записываем запятую перед всеми элементами, кроме первого
if count > 0:
f_out.write(',')

# Записываем элемент в JSON
f_out.write(json.dumps(data))

# Увеличиваем счетчик
count += 1

# Очищаем элемент для освобождения памяти
elem.clear()

# Также очищаем предыдущие ссылки в дереве
while elem.getprevious() is not None:
del elem.getparent()[0]

f_out.write(']')

print(f"Обработано {count} элементов. JSON-файл создан: {os.path.abspath(json_file)}")

# Пример использования
process_large_xml('huge_data.xml', 'output.json', '//item')

import xml.sax
import json

class CustomXMLHandler(xml.sax.ContentHandler):
def __init__(self):
super().__init__()
self.current_path = []
self.result = {}
self.current = self.result
self.stack = [self.current]
self.text_buffer = ""

# Правила трансформации для специфичных элементов
self.transform_rules = {
'price': lambda x: float(x),
'quantity': lambda x: int(x),
'available': lambda x: x.lower() == 'true'
}

# Элементы, которые должны всегда быть списками
self.force_list = ['item', 'product', 'option']

# Элементы, которые нужно пропустить
self.skip_elements = ['metadata', 'debug_info']

def startElement(self, name, attrs):
# Пропускаем нежелательные элементы
if name in self.skip_elements:
return

# Добавляем текущий элемент в путь
self.current_path.append(name)

# Обрабатываем атрибуты
element_data = {}
if attrs:
element_data['@attributes'] = {k: attrs[k] for k in attrs.getNames()}

# Определяем, должен ли элемент быть списком
path_str = '/'.join(self.current_path)
if name in self.force_list or any(path_str.endswith(f'/{item}') for item in self.force_list):
if name not in self.current:
self.current[name] = []

self.current[name].append(element_data)
self.stack.append(self.current)
self.current = element_data
else:
self.current[name] = element_data
self.stack.append(self.current)
self.current = element_data

self.text_buffer = ""

def endElement(self, name):
# Пропускаем нежелательные элементы
if name in self.skip_elements:
return

# Обрабатываем текст элемента
if self.text_buffer.strip():
text = self.text_buffer.strip()

# Применяем правила трансформации, если они определены для этого элемента
if name in self.transform_rules:
text = self.transform_rules[name](text)

# Если элемент содержит только текст, заменяем объект на текст
if not self.current:
parent = self.stack[-2]
path_str = '/'.join(self.current_path)

if name in self.force_list or any(path_str.endswith(f'/{item}') for item in self.force_list):
# Находим индекс текущего элемента в списке
items = parent[name]
items[-1] = text
else:
parent[name] = text
else:
self.current['#text'] = text

# Восстанавливаем родительский элемент
self.current = self.stack.pop()

# Удаляем текущий элемент из пути
self.current_path.pop()

self.text_buffer = ""

def characters(self, content):
self.text_buffer += content

def custom_xml_to_json(xml_data):
handler = CustomXMLHandler()
parser = xml.sax.make_parser()
parser.setContentHandler(handler)

try:
parser.parse(xml_data)
return json.dumps(handler.result, indent=2)
except Exception as e:
return json.dumps({'error': str(e)})

# Пример использования
xml_file = open('complex_data.xml', 'r')
json_result = custom_xml_to_json(xml_file)
print(json_result)
xml_file.close()