XML в Python: полное руководство по парсингу и обработке данных

Для кого эта статья:

• Разработчики, работающие с Python и XML
• Специалисты по интеграции систем и API

• Студенты и начинающие разработчики, стремящиеся улучшить свои навыки в обработке данных

  XML — рабочая лошадка обмена данными между системами, и Python великолепно справляется с его обработкой. Каждому разработчику рано или поздно приходится взаимодействовать с этим форматом — будь то API интеграции, конфигурационные файлы или обработка данных. Если вы ещё не освоили эти инструменты, вы теряете в эффективности. Представляю полное руководство, которое превратит вас из новичка в эксперта по работе с XML в Python. Готовы избавиться от головной боли при парсинге сложных XML-структур? 🚀

Хотите быстро освоить не только работу с XML, но и все профессиональные аспекты Python-разработки? Обучение Python-разработке от Skypro охватывает весь спектр навыков — от фундаментальных основ до продвинутых технологий работы с данными. Наши выпускники решают реальные задачи парсинга, трансформации и создания XML-документов уже через несколько недель обучения. Инвестируйте в навыки, которые работают!

Основы XML и его роль в обмене данными

XML (eXtensible Markup Language) — это язык разметки, который позволяет структурировать данные в формате, понятном как человеку, так и машине. Благодаря своей самоописательной природе, XML остаётся одним из ключевых форматов для хранения и обмена информацией между различными системами. 📄

XML-документ имеет древовидную структуру, состоящую из:

• Элементов — основных блоков XML с открывающим и закрывающим тегами
• Атрибутов — дополнительных свойств элементов
• Текстового содержимого — данных внутри элементов
• Комментариев — пояснений, не влияющих на обработку

Рассмотрим простой XML-документ:

<?xml version="1.0" encoding="UTF-8"?>
<book>
<title>Мастер и Маргарита</title>
<author>Михаил Булгаков</author>
<year published="true">1967</year>
<!-- Это комментарий -->
</book>

Преимущества использования XML как формата для обмена данными:

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

Алексей Воронин, Senior Backend Developer

Однажды мне пришлось интегрировать нашу систему с ERP-платформой крупного промышленного клиента. Система поддерживала только обмен данными через XML, причём со сложной и строго валидируемой схемой. Первая неделя ушла на попытки ручной генерации XML-файлов, что привело к бесконечным ошибкам валидации. Всё изменилось, когда я применил ElementTree для автоматического создания документов. Мы написали класс-маппер между нашими объектами и XML-структурой, и буквально за день разрешили проблему, которая мучила команду неделями. С тех пор работа с XML в Python стала для меня одним из базовых и необходимых навыков.

Встроенные библиотеки Python для обработки XML

Python предоставляет несколько встроенных библиотек для работы с XML, каждая из которых имеет свои сильные стороны и особенности применения. Выбор правильного инструмента существенно влияет на эффективность вашего кода. 🛠️

Основные библиотеки в стандартной поставке Python:

• xml.etree.ElementTree — легковесный и удобный API для большинства задач
• xml.dom.minidom — реализация DOM API для XML
• xml.sax — реализация SAX (Simple API for XML) для потоковой обработки

Кроме того, существует популярная сторонняя библиотека lxml, которая предлагает расширенную функциональность и высокую производительность.

Выбор подходящей библиотеки зависит от конкретных требований вашей задачи:

• ElementTree — оптимальный выбор для большинства повседневных задач парсинга и создания XML
• minidom — удобен, если вам уже знаком DOM API или требуется точный контроль над структурой документа
• SAX — незаменим при обработке очень больших XML-файлов, когда загрузка всего документа в память нецелесообразна
• lxml — рекомендуется для сложных задач с высокими требованиями к производительности и поддержкой XPath, XSLT

Базовый пример использования ElementTree для чтения XML:

import xml.etree.ElementTree as ET

# Парсинг из файла
tree = ET.parse('data.xml')
root = tree.getroot()

# Парсинг из строки
xml_string = '<data><item>Значение</item></data>'
root = ET.fromstring(xml_string)

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

from xml.dom import minidom

# Парсинг из файла
doc = minidom.parse('data.xml')

# Парсинг из строки
xml_string = '<data><item>Значение</item></data>'
doc = minidom.parseString(xml_string)

Как правило, ElementTree является наиболее сбалансированным решением для большинства Python-разработчиков благодаря интуитивному API и достаточной производительности.

Парсинг XML с ElementTree: чтение и навигация

ElementTree — это мощный и элегантный инструмент для парсинга XML-документов. Его концепция представления элементов в виде объектов Python делает навигацию по дереву XML интуитивно понятной. 🌳

Начнем с базового примера парсинга XML-файла:

import xml.etree.ElementTree as ET

# Создаем объект ElementTree из файла
tree = ET.parse('library.xml')

# Получаем корневой элемент
root = tree.getroot()

# Вывод имени корневого элемента
print(f"Корневой элемент: {root.tag}")

# Вывод всех атрибутов корневого элемента
print(f"Атрибуты: {root.attrib}")

Для навигации по элементам ElementTree предлагает несколько удобных методов:

• Итерация по дочерним элементам — перебор прямых потомков элемента
• Доступ по индексу — обращение к дочерним элементам как к элементам списка
• Методы find() и findall() — поиск элементов с использованием XPath-подобных выражений

Рассмотрим практические примеры навигации по XML-документу:

<!-- Предположим, у нас есть XML с книгами: -->
<library>
<book id="1">
<title>Война и мир</title>
<author>Лев Толстой</author>
<genre>Роман</genre>
<price>750</price>
</book>
<book id="2">
<title>Преступление и наказание</title>
<author>Фёдор Достоевский</author>
<genre>Роман</genre>
<price>550</price>
</book>
</library>

# Итерация по всем книгам
for book in root.findall('./book'):
title = book.find('title').text
author = book.find('author').text
price = float(book.find('price').text)
book_id = book.get('id') # Получение атрибута

print(f"Книга {book_id}: {title} – {author}, Цена: {price} руб.")

# Поиск всех романов
romance_books = root.findall(".//book[genre='Роман']")
print(f"Найдено романов: {len(romance_books)}")

# Поиск книг с ценой выше 600
expensive_books = [
book.find('title').text
for book in root.findall(".//book")
if float(book.find('price').text) > 600
]
print(f"Дорогие книги: {', '.join(expensive_books)}")

ElementTree поддерживает упрощенную версию XPath для поиска элементов. Вот наиболее полезные XPath-выражения:

• tag — выбирает все дочерние элементы с именем tag
• * — выбирает все дочерние элементы
• //tag — выбирает все элементы с именем tag во всем документе
• ./tag — выбирает дочерние элементы с именем tag относительно текущего элемента
• ../tag — выбирает элементы с именем tag на уровень выше
• tag[@attr='value'] — выбирает элементы с атрибутом attr, равным 'value'

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

# Итеративный парсинг для больших файлов
for event, elem in ET.iterparse('huge_file.xml', events=('start', 'end')):
if event == 'end' and elem.tag == 'book':
# Обработка элемента book
print(f"Найдена книга: {elem.find('title').text}")

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

Мария Соколова, Data Engineer

Однажды мне пришлось обрабатывать XML-файл размером 12 ГБ с данными медицинских исследований. Первая попытка загрузить весь файл в память с помощью стандартного parse() привела к OutOfMemoryError. Ситуацию спас iterparse(). Мы настроили потоковую обработку, которая обрабатывала каждую запись и сразу же очищала память. Процесс занял около часа, но успешно завершился без сбоев. Главный вывод: при работе с XML всегда оценивайте размер входных данных и выбирайте соответствующий подход к парсингу. ElementTree с его iterparse() — настоящее спасение для анализа гигантских XML-документов, когда память ограничена.

Создание и модификация XML-документов в Python

ElementTree не только отлично справляется с чтением XML, но и предоставляет удобный API для создания новых документов и модификации существующих. Эта функциональность особенно полезна при генерации отчетов, конфигурационных файлов или при подготовке данных для API. 🔄

Создание нового XML-документа с нуля выглядит так:

import xml.etree.ElementTree as ET

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

# Добавляем первую книгу
book1 = ET.SubElement(root, "book")
book1.set("id", "1") # Устанавливаем атрибут

# Добавляем элементы книги
title1 = ET.SubElement(book1, "title")
title1.text = "Идиот"

author1 = ET.SubElement(book1, "author")
author1.text = "Фёдор Достоевский"

# Добавляем вторую книгу аналогичным образом
book2 = ET.SubElement(root, "book")
book2.set("id", "2")

title2 = ET.SubElement(book2, "title")
title2.text = "Евгений Онегин"

author2 = ET.SubElement(book2, "author")
author2.text = "Александр Пушкин"

# Создаем объект ElementTree
tree = ET.ElementTree(root)

# Записываем в файл с правильной кодировкой и отступами
tree.write("new_library.xml", encoding="utf-8", xml_declaration=True)

К сожалению, стандартный ElementTree не имеет встроенной поддержки форматирования (pretty printing). Для создания читаемого XML с отступами можно использовать такую функцию:

def indent_xml(elem, level=0):
"""Функция для добавления отступов в XML-документ."""
i = "\n" + level * " "
if len(elem):
if not elem.text or not elem.text.strip():
elem.text = i + " "
if not elem.tail or not elem.tail.strip():
elem.tail = i
for elem in elem:
indent_xml(elem, level + 1)
if not elem.tail or not elem.tail.strip():
elem.tail = i
else:
if level and (not elem.tail or not elem.tail.strip()):
elem.tail = i

# Применение функции
indent_xml(root)
tree.write("formatted_library.xml", encoding="utf-8", xml_declaration=True)

Для модификации существующего XML-документа сначала нужно его загрузить:

# Загружаем существующий XML
tree = ET.parse("library.xml")
root = tree.getroot()

# Модификация существующих элементов
for book in root.findall("./book"):
# Увеличиваем цену на 10%
price_elem = book.find("price")
if price_elem is not None:
current_price = float(price_elem.text)
price_elem.text = str(round(current_price * 1.1, 2))

# Добавляем новый элемент к каждой книге
pub_date = ET.SubElement(book, "publication_date")
pub_date.text = "2023"

# Добавляем новую книгу
new_book = ET.SubElement(root, "book")
new_book.set("id", "3")

title = ET.SubElement(new_book, "title")
title.text = "Мастер и Маргарита"

author = ET.SubElement(new_book, "author")
author.text = "Михаил Булгаков"

# Сохраняем изменения
tree.write("updated_library.xml", encoding="utf-8", xml_declaration=True)

Также можно удалять элементы из XML-документа:

# Удаление элементов
for book in root.findall("./book"):
# Удаляем элемент genre, если он существует
genre = book.find("genre")
if genre is not None:
book.remove(genre)

# Удаляем книги с ценой ниже 500
price = book.find("price")
if price is not None and float(price.text) < 500:
root.remove(book)

# Сохраняем результат
tree.write("filtered_library.xml", encoding="utf-8", xml_declaration=True)

При работе с XML-документами полезно понимать различные операции над элементами:

• element.append(subelement) — добавляет дочерний элемент
• element.extend(subelements) — добавляет несколько дочерних элементов
• element.insert(index, subelement) — вставляет элемент по указанному индексу
• element.remove(subelement) — удаляет дочерний элемент
• element.set(key, value) — устанавливает атрибут
• element.get(key, default) — получает значение атрибута
• element.attrib — словарь атрибутов элемента

При работе с XML важно помнить о безопасности, особенно при чтении XML из ненадежных источников. ElementTree имеет некоторые уязвимости, связанные с атаками XML Entity Expansion. Для безопасной обработки можно использовать defusedxml — библиотеку, которая защищает от таких атак:

# Сначала установите: pip install defusedxml
import defusedxml.ElementTree as secure_ET

# Безопасный парсинг
root = secure_ET.parse('untrusted.xml').getroot()

Продвинутые техники работы с XML через lxml

Библиотека lxml — это мощная альтернатива встроенным XML-парсерам Python. Она базируется на быстрых библиотеках libxml2 и libxslt, написанных на C, что обеспечивает высокую производительность и расширенную функциональность. Для сложных задач обработки XML lxml часто становится незаменимым инструментом. 🚀

Перед использованием lxml необходимо установить её через pip:

pip install lxml

Базовый парсинг с lxml похож на ElementTree, но с дополнительными возможностями:

from lxml import etree

# Парсинг из файла
tree = etree.parse("library.xml")
root = tree.getroot()

# Парсинг из строки
xml_string = '''
<library>
<book id="1">
<title>Преступление и наказание</title>
</book>
</library>
'''
root = etree.fromstring(xml_string)

Одним из главных преимуществ lxml является полноценная поддержка XPath, включая все функции и оси стандарта XPath 1.0:

# Использование полного XPath
# Найти все книги, у которых цена больше 500 и жанр "Роман"
expensive_novels = root.xpath("//book[price > 500 and genre='Роман']")

# Найти книги по автору, используя функции XPath
tolstoy_books = root.xpath("//book[contains(author, 'Толстой')]")

# Использование осей XPath
# Найти всех "братьев" элемента (на том же уровне)
first_book = root.xpath("//book[1]")[0]
siblings = first_book.xpath("following-sibling::book")

# Поиск по атрибутам
books_with_id = root.xpath("//book[@id]")
book_id_1 = root.xpath("//book[@id='1']")[0]

lxml также поддерживает валидацию XML по схемам DTD, XSD и RelaxNG:

# Валидация по XSD схеме
schema_root = etree.parse("library_schema.xsd")
schema = etree.XMLSchema(schema_root)

# Проверка валидности документа
is_valid = schema.validate(tree)
if not is_valid:
# Вывод ошибок валидации
for error in schema.error_log:
print(f"Ошибка: {error.message}")

Трансформация XML с использованием XSLT — ещё одна мощная возможность lxml:

# Загрузка XSLT шаблона
xslt_root = etree.parse("transform_template.xslt")
transform = etree.XSLT(xslt_root)

# Применение трансформации
result_tree = transform(tree)

# Сохранение результата
result_tree.write("transformed_output.xml", encoding="utf-8", pretty_print=True)

lxml предоставляет удобные возможности для форматированного вывода XML:

# Создание XML с отступами (pretty printing)
print(etree.tostring(root, encoding="utf-8", pretty_print=True).decode("utf-8"))

# Запись в файл с отступами
tree.write("formatted.xml", encoding="utf-8", xml_declaration=True, pretty_print=True)

Сравнение основных возможностей ElementTree и lxml:

lxml особенно полезна при работе с XML-пространствами имён, которые часто встречаются в сложных XML-форматах, таких как SOAP, SVG или XHTML:

<!-- XML с пространствами имён -->
<soap:Envelope 
xmlns:soap="http://www.w3.org/2003/05/soap-envelope/"
xmlns:m="http://example.org/stock">
<soap:Body>
<m:GetStockPrice>
<m:StockName>IBM</m:StockName>
</m:GetStockPrice>
</soap:Body>
</soap:Envelope>

root = etree.fromstring(xml_with_ns)

# Определение пространств имён для XPath
namespaces = {
'soap': 'http://www.w3.org/2003/05/soap-envelope/',
'm': 'http://example.org/stock'
}

# Поиск с учётом пространств имён
stock_name = root.xpath('//m:StockName', namespaces=namespaces)[0].text
print(f"Название акции: {stock_name}")

При работе с большими XML-файлами lxml также предлагает итеративный парсинг, аналогичный iterparse() в ElementTree, но с расширенными возможностями:

# Итеративный парсинг больших файлов с lxml
for event, elem in etree.iterparse("huge_file.xml", events=('end',), tag="book"):
# Обрабатываем только завершающие события для тегов 'book'
title = elem.findtext("title")
author = elem.findtext("author")
print(f"Книга: {title} – {author}")

# Очищаем память
elem.clear()

# Также удаляем ссылки на элемент из родителя
while elem.getprevious() is not None:
del elem.getparent()[0]

lxml — мощный инструмент, который значительно расширяет возможности работы с XML в Python. Она особенно полезна для проектов, где требуется производительность, валидация схем, трансформации XSLT или продвинутые XPath-запросы.

XML — неизбежная часть современной инфраструктуры разработки, и Python предоставляет исчерпывающий набор инструментов для эффективной работы с этим форматом. От простого парсинга с ElementTree до сложных трансформаций с lxml — выбор правильной библиотеки и подхода зависит от конкретной задачи. Освоив различные техники работы с XML, вы сможете справиться с любыми задачами интеграции, анализа и генерации данных, повысив свою эффективность как разработчика и обеспечив надежность ваших решений.