Парсер xml файла: Парсер XML файлов | Datacol

Хранение данных, запись в XML— Ruby Rush

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

План урока

1. Пишем XML в Ruby
2. Программа учета финансов v. 2.0
3. Ошибки в XML

Почему нельзя просто писать текст в файлы

Вот несколько причин, почему стоит избегать создания файлов с данными для программ руками:

• Данные постоянно обновляются разными программами
• Файлы с данными могут содержать большие объемы информации, которые неудобно просматривать глазами
• Часто файлы, предназначенные для программ, вообще нельзя понять без дополнительных программ (JPEG, MP3, AVI)
• XML изначально придуман легко читаемым и простым по структуре именно для простоты его обработки в программах
• Человек может легко ошибиться в синтаксисе (об этом в конце)

Как писать XML с помощью Ruby

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

Пишем программу для записи расходов

Итак, давайте поставим задачу. Мы хотим программу, которая позволит нам ввести в консоли трату (описание, категорию, дату и количество потраченных денег), а потом допишет её в наш файл

<?xml version='1.0' encoding='UTF-8'?>
<expenses>
  <expense amount='900' category='Образование' date='9.7.2015'>
     Книжка по Ruby on Rails
  </expense>
  <expense amount='400' category='Хороший программист' date='1.7.2015'>
     Петличка и провода
  </expense>
  <expense amount='3500' category='Хороший программист' date='23.6.2015'>
     Софтбокс + штатив
  </expense>
</expenses>

Давайте писать программу для записи расходов в наш файл expenses.xml: для этого мы будем использовать всё тот же gem REXML

require "rexml/document" # подключаем парсер
require "date" # будем использовать операции с данными
# Спросим у пользователя, на что он потратил деньги и сколько
puts "На что потратили деньги?"
expense_text = STDIN.gets.chomp
puts "Сколько потратили?"
expense_amount = STDIN.gets.chomp.to_i
# Спросим у пользователя, когда он потратил деньги
puts "Укажите дату траты в формате ДД.ММ.ГГГГ, например 12.05.2003 (пустое поле - сегодня)"
date_input = STDIN.gets.chomp
# Для того, чтобы записать дату в удобном формате, воспользуемся методом parse класса Time
expense_date = nil
# Если пользователь ничего не ввёл, значит он потратил деньги сегодня
if date_input == ''
  expense_date = Date.today
else
  begin 
    expense_date = Date.parse(date_input)
  rescue ArgumentError # если дата введена неправильно, перехватываем исключение и выбираем "сегодня"
    expense_date = Date.  today
  end
end
# Наконец, спросим категорию траты
puts "В какую категорию занести трату"
expense_category = STDIN.gets.chomp
# Сначала получим текущее содержимое файла
# И построим из него XML-структуру в переменной doc
current_path = File.dirname(__FILE__)
file_name = current_path + "/my_expenses.xml"
file = File.new(file_name, "r:UTF-8")
doc = nil 
begin
  doc = REXML::Document.new(file)
rescue REXML::ParseException => e # если парсер ошибся при чтении файла, придется закрыть прогу :(
  puts "XML файл похоже битый :("
  abort e.message
end
file.close
# Добавим трату в нашу XML-структуру в переменной doc
# Для этого найдём элемент expenses (корневой)
expenses = doc.elements.find('expenses').first
# И добавим элемент командой add_element
 # Все аттрибуты пропишем с помощью параметра, передаваемого в виде АМ
expense = expenses.add_element 'expense', {
    'amount' => expense_amount,
    'category' => expense_category,
    'date' => expense_date.strftime('%Y.%m.%d') # or Date#to_s
}
# А содержимое элемента меняется вызовом метода text
expense.   text = expense_text
# Осталось только записать новую XML-структуру в файл методов write
# В качестве параметра методу передаётся указатель на файл
# Красиво отформатируем текст в файлике с отступами в два пробела
file = File.new(file_name, "w:UTF-8")
doc.write(file, 2)
file.close
puts "Информация успешно сохранена"

Отлично, осталось запустить этот файл и создать новую трату:

$ ruby expenses_writer.rb
На что потратили деньги?
Компот
Сколько потратили?
200
Укажите дату траты в формате ДД.ММ.ГГГГ, например 12.05.2003 (пустое поле - сегодня)
12.07.2015
В какую категорию занести трату
Развлечения
Информация успешно сохранена

Можно посмотреть содержимое файла my_expenses.xml и убедиться, что информация действительно успешно сохранена.

<?xml version='1.0' encoding='UTF-8'?>
<expenses>
  <expense amount='900' category='Образование' date='9.7.2015'>
     Книжка по Ruby on Rails
  </expense>
  <expense amount='400' category='Хороший программист' date='1.
  7.2015'>
     Петличка и провода
  </expense>
  <expense amount='3500' category='Хороший программист' date='23.6.2015'>
     Софтбокс + штатив
  </expense>
  <expense amount='200' category='Развлечения' date='2015.07.12'>
     Компот
  </expense>
</expenses>

Действительно, новая трата добавилась. Поиграйтесь с программой, добавьте несколько новых трат и посмотрите, как можно с помощью двух программ: expense_reader.rb и expense_writer.rb вообще обойтись без открывания файла my_expenses.xml в текстовом редакторе.

Ошибки в синтаксисе XML-файлов

Если вы работаете с внешними данными, которые непонятно кто готовил, помните о возможности ошибки. Например, незакрытый тег или забытая треугольная скобка. Парсер сообщит вам о таких ошибках.

Давайте попробуем сломать файл my_expenses.xml и, например, удалим закрывающий тег коревого контейнера </expenses>.

$ ruby expenses_reader.rb
.../ruby-2.1.4/lib/ruby/2.1.0/rexml/parsers/treeparser.rb:27:in `parse': No close tag for /expenses (REXML::ParseException)

Парсер сразу же ругнулся и всё нам прямо так и написал: «Нет закрывающего тега у expenses». Чтобы в этой ситуации программа не вылетала с ошибкой, можно написать обработчик.

begin
  doc = REXML::Document.new(file) # создаем новый документ REXML, построенный из открытого XML файла
rescue REXML::ParseException => e
  puts "Похоже, файл #{file_name} испорчен:"
  abort e.message
end

Теперь можно ломать наш файл как угодно и смотреть, что за сообщение напишет нам наш expense_reader.rb. Программа для записи также будет спотыкаться о битые XML-файлы, но обработчик туда допишите уже сами.

Итак, мы научились не только читать XML-файлы но и с лёгкостью писать свои (или обновлять уже имеющиеся, что полезнее).

Python XML Parser. — pythobyte.com

Автор оригинала: Pankaj Kumar.

Когда-нибудь застрял с раздражающим XML-файлом, который вам нужно разбираться, чтобы получить важные значения? Давайте узнаем, как создать Python XML Parser.

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

Давайте начнем!

Способ 1: Использование ElementTree (рекомендуется)

Мы можем использовать ElementTree Библиотека Python для достижения этой задачи.

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

Мы будем использовать xml.etree.elementtree Интерфейс внутри сердечника XML упаковка.

 
import xml. etree.ElementTree as ET

Постройте дерево Python XML Parser

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

К счастью, для нас этот API уже имеет следующий метод для нас:

 
import xml.etree.ElementTree as ET
root_node = ET.parse('sample.xml').getroot()
print(root_node)

Это автоматически прочитает файл ввода XML и получает узел корневого узла.

Выход

Хорошо, так кажется, что это спущено. Но мы не можем это подтвердить это. Итак, давайте разобраемся с другими атрибутами и попробуйте получить его значение.

Получите значения соответствующих атрибутов

Так что теперь наша задача – получить значение внутри <заголовок> Атрибут, с использованием нашего Python XML-парсера.

Его положение из корневого узла

Мы можем сделать это, используя root_node.findall (уровень) , где Уровень является желаемой позицией ( в нашем случае).

for tag in root_node.find_all(level):
    value = tag.get(attribute)
    if value is not None: print(value)

tag.get (атрибут) получит ценность нашего <Атрибут> Тег на уровнях, которые мы ищем. Итак, нам просто нужно сделать это в <Заголовок/Тип> и получите значения <заголовок> и <Текст> атрибуты. Это оно!

import xml.etree.ElementTree as ET
# We're at the root node ()
root_node = ET.parse('sample.xml').getroot()
# We need to go one level below to get 
# and then one more level from that to go to 
for tag in root_node.findall('header/type'):
    # Get the value of the heading attribute
    h_value = tag.get('heading')
    if h_value is not None:
        print(h_value)
    # Get the value of the text attribute
    t_value = tag.get('text')
    if t_value is not None:
        print(t_value)

Выход

XML Parsing in Python
Hello from AskPython.  We'll be parsing XML

Мы получили все значения на этом уровне нашего разбора XML! Мы успешно проанализировали наш XML-файл.

Давайте возьмем еще один пример, чтобы убрать все.

Теперь предположим, что файл XML выглядит так:

10203040

Здесь мы должны не только получить значения атрибута Имя Но также получают текстовые значения 10, 20, 30 и 40 для каждого элемента на этом уровне.

Чтобы получить значение атрибута Имя мы можем сделать то же самое, что и раньше. Мы также можем использовать tag.attrib [name] получить значение. Это так же, как tag.get (имя) За исключением того, что он использует словарные поиски.

attr_value = tag.get(attr_name)
# Both methods are the same. You can
# choose any approach
attr_value = tag.attrib[attr_name]

Чтобы получить текстовое значение, это просто! Просто получите его, используя:

tag.text

Итак, наша полная программа для этого парсера будет:

import xml. etree.ElementTree as ET
# We're at the root node ()
root_node = ET.parse('sample.xml').getroot()
# We need to go one level below to get 
# and then one more level from that to go to 
for tag in root_node.findall('items/item'):
    # Get the value from the attribute 'name'
    value = tag.attrib['name']
    print(value)
    # Get the text of that tag
    print(tag.text)

Выход

item1
10
item2
20
item3
30
item4
40

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

Но я уйду это для вас, чтобы выяснить из Документация , поскольку я предоставил отправную точку для вас, чтобы построить!

Способ 2: Использование BeautifulSoup (надежна)

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

Оказывается, Beautifulsoup Работает очень хорошо для всех этих типов файлов, поэтому, если вы хотите проанализировать любой тип XML-файла, используйте этот подход.

Чтобы установить его, используйте Пип и установить BS4 модуль:

pip3 install bs4

Я дам вам небольшой фрагмент для нашего предыдущего XML-файла:

10203040

Я передам этот файл, а затем разбирая его, используя BS4 Отказ

from bs4 import BeautifulSoup
fd = open('sample. xml', 'r')
xml_file = fd.read()
soup = BeautifulSoup(xml_file, 'lxml')
for tag in soup.findAll("item"):
    # print(tag)
    print(tag["name"])
    print(tag.text)
fd.close()

Синтаксис похож на наши XML Модуль, поэтому мы все еще получаем имена атрибутов, используя значение ['attribute_name'] и Text.Text Отказ Точно так же, как раньше!

Выход

item1
10
item2
20
item3
30
item4
40

Мы сейчас проанализировали это, используя BS4 тоже! Если ваш источник XML Файл плохо отформатирован, этот метод – это путь, поскольку BeautificSoup имеет разные правила для обработки таких файлов.

Заключение

Надеемся, что у вас есть хороший понять, как построить Python XML-парсер легко. Мы показали вам два подхода: один, использующий XML модуль, а другой, использующий Beautifulsoup Отказ

Рекомендации

• Stackoverflow вопрос на разборке XML
• XML модуль Документация

Парсинг XML Python подробно на примерах через ElementTree и BeautifulSoup

Вы когда-нибудь сталкивались с надоедливым XML-файлом, который вам нужно проанализировать, чтобы получить важные значения? Давайте узнаем, как создать парсер Python XML.

<page>
    <header>
        <type heading="XML Parsing in Python"/>
        <type text="Hello from AskPython. We'll be parsing XML"/>
    </header>
</page>

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

Метод 1: Использование ElementTree (рекомендуется)

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

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

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

<page>
    <header>
        <type heading="XML Parsing in Python"/>
        <type text="Hello from AskPython. We'll be parsing XML"/>
    </header>
</page>

Мы будем использовать интерфейс xml.etree.ElementTree внутри основного xml пакета.

import xml.etree.ElementTree as ET

Дерево синтаксического анализатора

Давайте сначала построим корневой узел этого дерева синтаксического анализа. Это самый верхний узел, он необходим нам для начала синтаксического анализа.

К счастью для нас, в этом API уже есть следующий метод:

import xml.etree.ElementTree as ET
root_node = ET.parse('sample.xml').getroot()
print(root_node)

Это автоматически прочитает входной XML-файл и получит для нас корневой узел.

Выход

<Element 'page' at 0x7f885836b2f0>

Похоже, он проанализирован. Но мы пока не можем это проверить. Итак, давайте проанализируем другие атрибуты и попробуем получить значение.

Получение значения соответствующих атрибутов

Итак, теперь наша задача — получить значение внутри атрибута <heading> с помощью нашего Python XML Parser.

Его позиция от корневого узла <page> — <header/type> , поэтому нам нужно перебрать все совпадения на этом уровне дерева.

Мы можем сделать это с помощью root_node. findall(level) , где level — это желаемая позиция (в нашем случае <header/type> ).

for tag in root_node.find_all(level):
    value = tag.get(attribute)
    if value is not None: print(value)

tag.get(attribute) получит значение нашего <attribute> на уровнях, на которых мы ищем. Итак, нам просто нужно сделать это в <header/type> и получить значения атрибутов <heading> и <text> . Это оно!

import xml.etree.ElementTree as ET

# We're at the root node (<page>)
root_node = ET.parse('sample.xml').getroot()

# We need to go one level below to get <header>
# and then one more level from that to go to <type>
for tag in root_node.findall('header/type'):
    # Get the value of the heading attribute
    h_value = tag.get('heading')
    if h_value is not None:
        print(h_value)
    # Get the value of the text attribute
    t_value = tag. get('text')
    if t_value is not None:
        print(t_value)

Выход

XML Parsing in Python
Hello from AskPython. We'll be parsing XML

Мы получили все значения на этом уровне нашего дерева синтаксического анализа XML! Мы успешно проанализировали наш XML-файл.

Возьмем другой пример, чтобы все прояснить.

Теперь предположим, что XML-файл выглядит так:

<data>
    <items>
        <item name="item1">10</item>
        <item name="item2">20</item>
        <item name="item3">30</item>
        <item name="item4">40</item>
    </items>
</data>

Здесь мы должны не только получить значения атрибутов name , но также получить текстовые значения 10, 20, 30 и 40 для каждого элемента на этом уровне.

Чтобы получить значение атрибута name , мы можем сделать то же самое, что и раньше. Мы также можем использовать tag.attrib[name] чтобы получить значение. Это то же самое, что и tag.get(name) , за исключением того, что он использует поиск по словарю.

attr_value = tag.get(attr_name)
# Both methods are the same. You can
# choose any approach
attr_value = tag.attrib[attr_name]

Получить текстовое значение просто. Просто используйте:

tag.text

Итак, наша полная программа для этого парсера будет:

import xml.etree.ElementTree as ET

# We're at the root node (<page>)
root_node = ET.parse('sample.xml').getroot()

# We need to go one level below to get <items>
# and then one more level from that to go to <item>
for tag in root_node.findall('items/item'):
    # Get the value from the attribute 'name'
    value = tag.attrib['name']
    print(value)
    # Get the text of that tag
    print(tag. text)

Выход

item1
10
item2
20
item3
30
item4
40

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

Метод 2: использование BeautifulSoup (надежный)

Это также еще один хороший выбор, если по какой-то причине исходный XML плохо отформатирован. XML может работать не очень хорошо, если вы не выполните предварительную обработку файла.

Оказывается, BeautifulSoup очень хорошо работает со всеми этими типами файлов, поэтому, если вы хотите проанализировать любой XML-файл, используйте этот подход.

Чтобы установить его, используйте pip и установите модуль bs4 :

pip3 install bs4

Я дам вам небольшой фрагмент нашего предыдущего XML-файла:

<data>
    <items>
        <item name="item1">10</item>
        <item name="item2">20</item>
        <item name="item3">30</item>
        <item name="item4">40</item>
    </items>
</data>

Я передам этот файл, а затем bs4 его с помощью bs4 .

from bs4 import BeautifulSoup

fd = open('sample.xml', 'r')

xml_file = fd.read()

soup = BeautifulSoup(xml_file, 'lxml')

for tag in soup.findAll("item"):
    # print(tag)
    print(tag["name"])
    print(tag.text)

fd.close()

Синтаксис аналогичен нашему модулю xml , поэтому мы по-прежнему получаем имена атрибутов, используя value = tag['attribute_name'] и text = tag.text . Точно так же, как и раньше!

Выход

item1
10
item2
20
item3
30
item4
40

Мы также проанализировали это с помощью bs4 ! Если ваш исходный XML файл плохо отформатирован, можно использовать этот метод, поскольку BeautifulSoup имеет другие правила для обработки таких файлов.

Работа с XML из Python

Введение

Не все элементы входных данных XML будут в конечном итоге являться элементами анализируемого дерева. В настоящий момент этот модуль пропускает все комментарии XML, инструкции по обработке и объявления типа документа во входных данных. Тем не менее, деревья, построенные с использованием API этого модуля, а не синтаксического анализа из XML-текста, могут иметь комментарии и инструкции по обработке в них.

Создание и сборка XML-документов

Импорт модуля Элемента Дерева

import xml.etree.ElementTree as ET

Функция Element () используется для создания элементов XML

p=ET.Element('parent')

Функция SubElement (), используемая для создания вложенных элементов в элементе give

c = ET.SubElement(p, 'child1')
 

Функция dump() используется для вывода элементов xml.

ET.dump(p)
# <parent><child1 /></parent>

Если вы хотите сохранить в файл, создайте дерево XML с функцией ElementTree() и сохраните в файл, используя метод write()

tree = ET.ElementTree(p)
tree. write("sample.xml")

Функция Comment() используется для вставки комментариев в XML-файл.

comment = ET.Comment('user comment')
p.append(comment) #этот комментарий будет добавлен к родительскому элементу
ET.dump(p)
# <parent><child1 /><!--user comment--></parent>

Изменение файла XML

Импортируйте модуль ElementTree и откройте файл XML, получите элемент XML

import xml.etree.ElementTree as ET
tree = ET.parse('sample.xml')
root=tree.getroot()
element = root[0] #получите первого ребенка родительского корня
element
# <Element 'child1' at 0x7fa5806a8b90>

Элементом объекта  можно управлять, изменяя его поля, добавляя и изменяя атрибуты, добавляя и удаляя дочерние элементы

element.set('attribute_name', 'attribute_value') #установите артрибут xml элементу
element.text="string_text"

Если вы хотите удалить элемент, используйте метод Element.remove()

root.remove(element)

Метод ElementTree. write(), используемый для вывода объекта XML в файлы XML.

tree.write('sample.xml')

Открытие и чтение больших файлов XML с помощью iterparse (инкрементальный анализ)

Иногда мы не хотим загружать весь XML-файл, чтобы получить необходимую нам информацию. В этих случаях полезно постепенно загружать соответствующие разделы и затем удалять их, когда мы закончим. С помощью функции iterparse вы можете редактировать дерево элементов, которое хранится при разборе XML.

Импортируйте объект ElementTree:

 import xml.etree.ElementTree as ET
 

Откройте файл .xml и переберите все элементы:

for event, elem in ET.iterparse("yourXMLfile.xml"):
#    ...  сделайте что-нибудь ...

Кроме того, мы можем искать только определенные события, такие как начальный / конечный теги или пространства имен. Если эта опция не указана (как указано выше), возвращаются только события «end»:

events=("start", "end", "start-ns", "end-ns")
for event, elem in ET. iterparse("yourXMLfile.xml", events=events):
#   ... сделайте что-нибудь ...
 

Вот полный пример, показывающий, как очистить элементы из дерева в памяти, когда мы закончим с ними:

for event, elem in ET.iterparse("yourXMLfile.xml", events=("start","end")):        
    if elem.tag == "record_tag" and event == "end":
        print elem.text
        elem.clear()
#    ... сделайтe что-нибудь другое ...

Открытие и чтение с помощью ElementTree

Импортируйте объект ElementTree, откройте соответствующий XML-файл и получите корневой тег:

import xml.etree.ElementTree as ET
tree = ET.parse("yourXMLfile.xml")
root = tree.getroot()

Есть несколько способов поиска по дереву. Сначала по итерации:

for child in root:
	print(child.tag, child.attrib)

В противном случае вы можете ссылаться на определенные места, такие как список:

print(root[0][1].text)

Для поиска конкретных тегов по имени, используйте .find или . findall:

print(root.findall("myTag"))
print(root[0].find("myOtherTag")) 

Поиск в XML с помощью XPath

Начиная с версии 2.7 ElementTree имеет лучшую поддержку XPath запросов. XPath — это синтаксис, позволяющий вам перемещаться по XML, как SQL используется для поиска в базе данных. Как find и findall функции поддержки XPath. Xml ниже будет использоваться для этого примера

<Catalog>
    <Books>
        <Book price="7.95">
            <Title>Мечтают ли андроиды об электроовцах?</Title>
            <Author>Philip K. Dick</Author>
        </Book>
        <Book price="5.95">
            <Title>The Colour of Magic</Title>
            <Author>Terry Pratchett</Author>
        </Book>
        <Book price="6.95">
            <Title>The Eye of The World</Title>
            <Author>Robert Jordan</Author>
        </Book>
    </Books>
</Catalog>
 

Поиск всех книг:

import xml. etree.cElementTree as ET
tree = ET.parse('sample.xml')
tree.findall('Books/Book')
 

Поиск книги с названием «Цвет магии»:

tree.find("Books/Book[Title='The Colour of Magic']") 
# всегда используйте '' в правой стороне сравнения

Поиск книги с id = 5:

tree.find("Books/Book[@id='5']")
# поиск с xml атрибутами должен иметь '@' перед именем
 

Поиск второй книги:

tree.find("Books/Book[2]")
# индексы начинаются с 1, не с 0

Поиск последней книги:

tree.find("Books/Book[last()]")
# 'last' единственная xpath функция позволенная в ElementTree

Поиск всех авторов:

tree.findall(".//Author")
# поиск с // должен использовать родственный путь

Парсер XML в Python с помощью ElementTree: создание, добавление и редактирование

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

Давайте начнем с примеров парсера XML с помощью ElementTree.

Содержание

1. Примеры
2. Создание файла
3. Добавление значений
4. Редактирование данных
5. Пример синтаксического анализатора

Примеры

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

Создание файла

В этом примере мы создадим новый XML-файл с элементом и подэлементом. Приступим сразу:

import xml.etree.ElementTree as xml

def createXML(filename):
    # Start with the root element
    root = xml.Element("users")
    children1 = xml.Element("user")
    root.append(children1)

    tree = xml.ElementTree(root)
    with open(filename, "wb") as fh:
        tree.write(fh)


if __name__ == "__main__":
    createXML("test.xml")

После запуска этого сценария в том же каталоге будет создан новый файл с файлом test. xml со следующим содержимым:

<users><user /></users>

Здесь следует отметить две вещи:

• При записи файла мы использовали режим wb вместо w, так как нам нужно записать файл в двоичном режиме.
• Дочерний пользовательский тег – это самозакрывающийся тег, поскольку мы не добавляли в него никаких вложенных элементов.

Добавление значений

Давайте улучшим программу, добавив значения к элементам XML:

import xml.etree.ElementTree as xml

def createXML(filename):
    # Start with the root element
    root = xml.Element("users")
    children1 = xml.Element("user")
    root.append(children1)

    userId1 = xml.SubElement(children1, "id")
    userId1.text = "123"

    userName1 = xml.SubElement(children1, "name")
    userName1.text = "Shubham"

    tree = xml.ElementTree(root)
    with open(filename, "wb") as fh:
        tree. write(fh)


if __name__ == "__main__":
    createXML("test.xml")

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

<users>
    <user>
        <id>123</id>
        <name>Shubham</name>
    </user>
</users>

Это совершенно правильный XML, и все теги закрыты. Обратите внимание, что я сам отформатировал XML, поскольку API записывает полный XML за один штраф, что немного неполно.

Теперь приступим к редактированию файлов.

Редактирование данных

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

<users>
    <user>
        <id>123</id>
        <name>Shubham</name>
        <salary>0</salary>
    </user>
    <user>
        <id>234</id>
        <name>Pankaj</name>
        <salary>0</salary>
    </user>
    <user>
        <id>345</id>
        <name>JournalDev</name>
        <salary>0</salary>
    </user>
</users>

Попробуем обновить зарплаты каждого пользователя:

import xml. etree.ElementTree as xml

def updateXML(filename):
    # Start with the root element
    tree = xml.ElementTree(file=filename)
    root = tree.getroot()

    for salary in root.iter("salary"):
        salary.text = '1000'
 
    tree = xml.ElementTree(root)
    with open("updated_test.xml", "wb") as fh:
        tree.write(fh)

if __name__ == "__main__":
    updateXML("test.xml")

Стоит заметить, что если вы попытаетесь обновить значение элемента до целого числа, это не сработает. Вам нужно будет назначить String, например:

salary.text = '1000'

Вместо того, чтобы делать:

salary.text = 1000

Пример синтаксического анализатора

На этот раз давайте попробуем проанализировать XML-данные, присутствующие в файле, и распечатать их:

import xml.etree.cElementTree as xml
 
def parseXML(file_name):
    # Parse XML with ElementTree
    tree = xml. ElementTree(file=file_name)
    print(tree.getroot())
    root = tree.getroot()
    print("tag=%s, attrib=%s" % (root.tag, root.attrib))
 
    # get the information via the children!
    print("-" * 40)
    print("Iterating using getchildren()")
    print("-" * 40)
    users = root.getchildren()
    for user in users:
        user_children = user.getchildren()
        for user_child in user_children:
            print("%s=%s" % (user_child.tag, user_child.text))
 
if __name__ == "__main__":
    parseXML("test.xml")

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

Как парсить xml python

От автора: что такое XML? XML расшифровывается как расширяемый язык разметки. Он был разработан для хранения и передачи небольших и средних объемов данных и широко используется для обмена структурированной информацией.

Python позволяет парсировать и изменять XML-документ. Для парсинга XML-документа вам необходимо иметь в памяти весь XML-документ. В этом руководстве мы рассмотрим, как в Python использовать класс XML minidom для загрузки и парсинга XML-файла.

Как парсить XML с помощью minidom

Как создать XML-узел

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Как парсить XML с помощью ElementTree

Как парсить XML с помощью minidom

Мы создали образец XML-файла, который мы собираемся парсить.

Шаг 1) Внутри файла мы видим имя, фамилию, дом и навыки (SQL, Python, Testing и Business)

Шаг 2) После того, как мы спарсим документ, мы выведем «имя узла» корня документа и «первый дочерний тэг». Tagname и nodename являются стандартными свойствами файла XML.

Импортируйте модуль xml.dom.minidom и объявите файл для парсинга (myxml.xml)

Этот файл содержит основную информацию о сотруднике, такую как имя, фамилия, адрес, навыки и т. д.

Мы используем функцию parse в minidom XML для загрузки и парсинга файла XML

У нас есть переменная doc, doc получает результат функции parse

Мы хотим вывести имя файла и дочерний тэг, поэтому объявляем это в функции print

Запустите код. Он выведет имя узла (#document) из файла XML и первый дочерний тэг (employee) из файла XML.

Примечание: Nodename и tagname являются стандартными именами или свойствами XML dom. В случае, если вы не знакомы с этим типом именования.

Шаг 3) Мы также можем вызвать список тегов XML из документа XML и вывести его. Здесь мы вывели набор навыков, таких как SQL, Python, Testing и Business.

Объявление переменной expertise, из которой мы будем извлекать всю информацию сотрудника

Используем стандартную функцию dom с именем «getElementsByTagName»

Она получит все элементы с именем skill

Объявляем цикл для каждого из тегов skill

Запустите код — он выдаст список из четырех навыков

Как создать XML-узел

Мы можем создать новый атрибут с помощью функции «createElement», а затем добавить этот новый атрибут или тег к существующим тегам XML. Мы добавили новый тег «BigData» в XML-файл.

Вам нужно написать код, чтобы добавить новый атрибут (BigData) в существующий тег XML

Затем вам нужно вывести тег XML с новыми атрибутами, добавленными к существующему тегу XML.

Чтобы добавить новый XML и вставить его в документ, мы используем код «doc.create elements»

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Как парсить на питоне
Добрый день! Только не пинайте жестко! Суть вопроса такова: Есть бат файл в котором происходит.

Как парсить xml, научите новичку-чайнику
пожалуйста, пытаюсь решить самостоятельно, но не выходит # xml=’<Test exp=’1+2+3/3′ exp2=’121/11′.

Сообщение было отмечено iSmokeJC как решение

Новости собираются с мира по нитке на совершенно безвозмездной основе.
Ты легко можешь посодействовать проекту, добавив ссылку на интересную новость, статью, интервью или проект о python.
А еще можно форкнуть код этого проекта на Github и помочь в развитии его функциональности.
И еще один вариант — проголосовать рублем

Как парсить данные основных форматов на Python

Парсинг CSV, JSON, SQLite, XML

Экспериментальная функция:

Ниже вы видите текст статьи по ссылке. По нему можно быстро понять ссылка достойна прочтения или нет

Просим обратить внимание, что текст по ссылке и здесь может не совпадать.

One of the biggest jumps you make in your Python learning is when you start dealing with external data.

With this post we wanted to demonstrate a few ways you can work with the more common data formats. Why? Because it’s a big deal when you’re starting out! Furthermore, unless you do it often enough it’s easy to forget how so bookmark this baby and reference it!

The links below are to articles and scripts we’ve actually written as well as to external resources we’ve found helpful.

1. CSV

If you’re going to play with CSV files, DictReader is your friend. It converts each row into an OrderedDict (Hallelujah!).

Reading the contents of a CSV file:

Opening and reading the CSV using a with statement:

2. JSON

JSON is a must these days, especially if you want to work with APIs.

Simple read of JSON data pulled down by requests :

One of our first articles used a with statement to load in JSON data:

Our Challenge 07 review used yield to return the JSON data:

Note the .json() method on requests.get :

Resources

3. SQLite

We’ve learned to love SQLite recently and have found ourselves using it all the time. It’s worth picking up as it’s such an easy and great way of getting a persistent DB!

Recent use to convert a CSV of movies to an sqlite DB:

Resources

4. XML

XML! The data format of choice for RSS feeds. Can be a bit troublesome at times but always worth the effort.

Example of using xml.etree.ElementTree to parse the Safari RSS feed:

Code Link — Worth checking out the full code but the gist of it is…

Using feedparser to pull specific XML tags and add to a list:

Challenge Solutions

We’ve had numerous challenges over the past few months where the solutions involved these data formats. Here are a few of the noteworthy ones:

This was definitely a great challenge. Check out the multiple community contributions for some examples of using sqlite and XML in functional scripts written by your fellow Pythonistas.

Learn By Doing

Now that you have the info, as we said in our Learn By Doing article, open up a vim session and get coding!

One awesome, shameless plug of a way to do this would be to come up with a solution for Code Challenge 19. Playing with an API means you’ll more than likely need to use quite a few of these formats.

We’d love to hear if you have any Pythonic tips on using these formats too so leave a comment!

Python содержит встроенные XML инструменты для парсинга, к которым вы можете получить доступ при помощи модуля xml. В данной статье мы рассмотрим два подмодуля xml:

• minidom
• ElementTree

Мы начнем с minidom по той причине, что де-факто он используется в качестве метода парсинга XML. После этого, мы взглянем на то, как использовать ElementTree для этих целей.

Работаем с minidom

Для начала, нам нужен XML для парсинга. Давайте взглянем на следующий небольшой пример XML:

Это типичный XML и читается он вполне интуитивно. В будущем вы, скорее всего, столкнетесь с более сложным примером XML, так что в нашем случае мы работаем с очень удобным материалом. В любом случае, сохраните описанный выше код XML под следующим названием: appt.xml

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

Этот код основан на примере из документации Python и стоит отметить, что, на мой взгляд, он немного уродливый. Давайте его разберем по кусочкам. Параметр url, который мы видим в классе ApptParser, может быть как url так и файлом. В методе getXml, мы используем обработчик исключений для того, чтобы попробовать открыть url. Если это привело к ошибке, значит url – это путь к файлу. Далее мы используем метод парсинга для парсинга XML. Далее мы изымаем node из XML. Мы опустим все условия, так как в данной статье это не принципиально. Наконец, мы возвращаем объект node. Технически, node является объектом XML, и мы передаем его методу handleXml. Чтобы получить все назначения в XML, мы делаем следующее:

После этого, мы передаем эту информацию методу handleAppts. Это большой объем информации. Хорошей идеей будет небольшой рефакторинг этого кода для этой цели, вместо передачи всей этой информации целиком, таким образом мы просто настраиваем переменные класса, после чего вызываем следующий метод без каких-либо аргументов. Я оставлю это в качестве упражнения для читателей. В любом случае, метод handleAppts только создает цикл в каждом назначении и вызывает метод handleAppt, чтобы вытянуть кое-какую дополнительную информации, добавляет данные в список и добавляет этот список в другой список. Идея в том, чтобы закончить со списком списков, которые содержат все соответствующие данные о встречах.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

Обратите внимание на то, что метод handleAppt вызывает метод getElement, который, в свою очередь вызывает метод getText. Технически, вы можете пропустить вызов getElement и вызвать getText напрямую. С другой стороны, вам может понадобиться добавить дополнительную обработку в getElement для конвертации текста, или чего-то другого перед возвратом. Например, вам может понадобиться конвертировать целые числа, числа с запятыми или объекты decimal.Decimal. Давайте попробуем еще один пример с minidom, перед тем как двигаться дальше. Мы используем пример XML с сайта MSDN Майкрософт: http://msdn.microsoft.com/en-us/library/ms762271%28VS.85%29.aspx . Сохраните следующий код под названием example.xml

В этом примере мы выполнили парсинг XML, извлекли заголовки книги и вывели их в stdout. Давайте взглянем на код:

Данный код – это только одна короткая функция, которая принимает один аргумент, который является файлом XML. Мы импортируем модуль minidom и даем ему такое же название, чтобы упростить отсылки к нему. Далее мы выполняем парсинг XML. Первые две строки функции очень похожи на те, что были в предыдущем примере. Мы используем метод getElementsByTagName чтобы собрать нужные нам части XML, после чего выполнить итерацию над результатом и извлечь заголовки книги. Так, мы извлекаем объекты заголовков, так что нужно выполнить итерацию этих данных в том числе, а также вытащить обычный текст, по этой причине мы используем вложенные данные цикла. Давайте уделим немного времени на унаследованный модуль xml под названием ElementTree.

Парсинг с ElementTree

В данном разделе, мы научимся создавать XML файлы, редактировать и выполнять парсинг при помощи ElementTree. Для сравнения, мы используем тот же XML, который мы использовали в предыдущем разделе для того, чтобы продемонстрировать разницу в использовании minidom и ElementTree. Вот наш код:

Давайте начнем с изучения того, как создавать такую XML структуру при помощи Python

Как создавать XML при помощи ElementTree

Создание XML при помощи ElementTree – это очень просто. В данном разделе, мы попытаемся создать написанный выше XML в Python. Давайте посмотрим на код:

Если вы запустите этот код, вы должны получить что-то вроде нижеизложенного (возможно в одной строке):

Это очень похоже на исходный код и это, безусловно, действенный XML. Само собой, наши коды отличаются, но весьма похожи. Давайте уделим время для разбора кода и убедиться в том, что мы его хорошо понимаем. Для начала мы создаем корневой элемент при помощи функции Element модуля ElementTree. Далее, мы создаем элемент назначения и добавляем его к root. Далее, мы создаем SubElements, выполнив парсинг назначения объекта Element (appt) в SubElement наряду с именем, например, begin. Далее, для каждого SubElement, мы назначаем их текстовые свойства, для передачи значения. В конце скрипта мы создаем ElementTree и используем его для написания XML в файле. Теперь мы готовы к тому, чтобы научиться редактировать файл!

Как редактировать XML при помощи ElementTree

Редактирование XML при помощи ElementTree это также очень просто. Чтобы все было немного интереснее, мы добавим другой блок назначения в XML:

Теперь мы напишем код для того, чтобы изменить каждое значение тега begin от секунд, начиная с эпохи на что-нибудь более читабельное. Мы используем модуль time python, чтобы облегчить себе жизнь:

Здесь мы создаем объект ElementTree под названием tree и извлечем из него root. Далее мы используем метод iter() чтобы найти все теги, помеченные “begin”. Обратите внимание на то, что метод iter() был добавлен в Python 2.7. В наем цикле for, мы указываем текстовое содержимое каждого объекта, чтобы получить более читабельный временной формат при помощи метода time.ctime(). Вы также можете обратить внимание на то, что нам нужно конвертировать строку для целых чисел, при передаче их к ctime. Результат будет выглядеть примерно следующим образом:

Вы также можете использовать методы ElementTree, такие как find() или findall() для поиска конкретных тегов в вашем XML. Метод find() найдет только первый пример, в то время как findall() найдет каждый тег с указанной отметкой. Это очень полезно при решении задач, возникших при редактировании или при парсинге, что является темой нашего следующего раздела!

Парсинг и ElementTree

Сейчас мы научимся тому, как выполнять базовый парсинг при помощи ElementTree. Сначала, мы пройдемся по коду в целом, затем разберем его кирпичик за кирпичиком, чтобы понять, как это работает. Обратите внимание на то, что этот код основан на оригинальном примере, и должен работать также и на втором примере.

Вы уже должны понять, что и как работает, но в этом примере и предыдущем мы импортируем cElementTree вместо обычного ElementTree. Разница между этими двумя в том, что cElementTree основан на С, а не на Python, так что он намного быстрее. В любом случае, мы снова создаем объект ElementTree и извлекаем root из него. Обратите внимание на то, что мы выводим root, его тег и атрибуты. Далее мы покажем несколько способов итерации тегов. Первый цикл просто итерирует XML, дочку за дочкой. Таким образом выведется только дочерний код (назначение) с наивысшим уровнем , так что мы добавили оператор if, чтобы проверить дочерний код и выполнить его итерацию. Далее мы берем итератор из объекта tree и также итерируем его. В итоге мы получим ту же информацию, но без дополнительных ступеней, как в первом примере. Третий метод использует корневую функцию getchildren(). Так что нам снова понадобится применить внутренний цикл, чтобы получить все теги дочернего кода и назначения. В последнем примере используется корневой метод iter() для цикла всех тегов, соответствующих строке “begin”.

Как было отмечено в последнем разделе, вы также можете использовать методы find() или findall(), чтобы облегчить поиск конкретных тегов, или набор тегов соответственно. Также обратите внимание на то, что каждый объект Element имеет свой тег и текстовое значение, этим можно воспользоваться для получения необходимой точной информации.

Подведем Итоги

Теперь вы знаете, как использовать minidom для парсинга XML. Вы также освоили ElementTree для создания, редактирования и парсинга XML. Существуют и другие библиотеки вне Python, которые предлагают дополнительные методы для работы с XML. Убедитесь в том, что вы пользуетесь понятным вам инструментом, так как данный вопрос может быть очень сложным и непонятным, если пытаться решить его неправильным инструментом.

Являюсь администратором нескольких порталов по обучению языков программирования Python, Golang и Kotlin. В составе небольшой команды единомышленников, мы занимаемся популяризацией языков программирования на русскоязычную аудиторию. Большая часть статей была адаптирована нами на русский язык и распространяется бесплатно.

Что такое синтаксический анализ и как это сделать в XML?

Ваша поддержка наших рекламодателей помогает покрыть расходы на размещение, исследования и обслуживание этого FAQ

XML FAQ — часто задаваемые вопросы о расширяемой разметке Язык

Раздел 3: Авторы

Разбор — это разбиение информации на составляющие частей

Предыдущий

Следующий

Синтаксический анализ — это процесс разделения информации на составные части (школы учили этому на языке классы, пока профессия учителя не захватила антиграмматический вирус).

«Мэри кормит Пятна» анализируется как

1. Субъект = Мэри, имя собственное, именительный падеж;

2. Глагол = кормит, переходный, третье лицо единственного числа, действительный залог, настоящее время;

3. Объект = пятно, имя собственное, винительный падеж.

В вычислительной технике синтаксический анализатор — это программа (или часть кода или API, на который вы можете ссылаться в своих собственных программах) который анализирует файлы для идентификации составных частей. Все приложения, которые считывают ввод, имеют какой-то синтаксический анализатор, иначе они никогда не смогли бы понять, что информационные средства. Майкрософт Слово содержит парсер, который запускается при открытии .doc и проверяет, может ли он выявить все скрытые коды; iCal и Google Календарь содержит парсер, который читает вложение .ical о встрече в вашей электронной почте, и выясняет, какая информация в нем. Дайте им поврежденный файл, и вы получите сообщение об ошибке сообщение.

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

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

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

<человек xml:id="abc123" рождение="1960-02-31" пол="женщина">
  <имя>
    Джуди
    <фамилия>О'Грейди
  

Приведенный выше пример обрабатывается как:

1. Идентифицированный элемент с атрибутом xml:id (предопределенный тип «ID»), содержащий «abc123», и атрибут рождения, содержащий «1960-02-31», и атрибут «пол», содержащий «женский», содержащий . ..

2. Элемент , содержащий …

3. Элемент <имя> содержащий текст «Джуди», за которым следует …

4. Элемент <фамилия> содержащий текст «О’Грейди».

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

Помимо встроенных парсеров, существуют и автономные парсеры-валидаторы (см. совет Билла Рэйера), которые читают файл XML и сообщают вам, если они находят ошибку (например, отсутствующие угловые скобки или кавычки или неуместные разметка). Это необходимо для тестирования файлов изолированно. прежде чем делать с ними что-то еще, особенно если они были созданы вручную без редактора XML или с помощью API, который может быть слишком глубоко встроен в другое место, чтобы его можно было легко тестирование.

Если нет хотите установить программное обеспечение, есть много онлайн веб-сайты парсера-валидатора, такие как Мукул Ганди в https://www. softwarebytes.org/xmlvalidation/ где вы можете загрузить свой XML-документ, схема XSD и любые вспомогательные файлы, и выберите версию.

Билл Райер пишет:

Для автономного синтаксического анализа/проверки используйте программное обеспечение, например onsgmls Джеймса Кларка или Rxp Ричарда Тобина. Оба работают под Linux и Windows/DOS. Разница в том, в формате списка ошибок (если есть), и что некоторые версии onsgmls нет извлекать DTD или другие файлы по сети, тогда как rxp делает.

Убедитесь, что ваш файл XML правильно ссылается на DTD в объявлении типа документа и что файл(ы) DTD доступны локально ( rxp извлечет их, если у вас есть подключение к Интернету; onsgmls не может, поэтому может понадобиться локальная копия).

Загрузите и установите программное обеспечение. Убедитесь, что это установлен в место, где ваша операционная система может Найди это. Если вы не знаете, что это означает, вы понадобится помощь того, кто знает, как скачать и установить программное обеспечение на ваш тип операционной система.

Для onsgmls , скопировать pubtext/xml.soc и pubtext/xml.dcl для вашей работы каталог.

Чтобы проверить файл myfile.xml, откройте окно оболочки (командное или терминал) (Linux) или MS-DOS (командное) окно (Microsoft Windows). В этих примерах мы предполагаем, что ваш файл XML называется myfile.xml и он в папке называется моя папка. Используйте настоящие имена вашей папки и файла при вводе команд.

Для onsgmls :

$ onsgmls -wxml -wundefined -cxml.soc -s myfile.xml

Есть много других вариантов для onsgmls , которые описано в сети страница. Приведенные здесь обязательны потому что он основан на синтаксическом анализаторе SGML, и эти параметры переключают его в режим XML и подавляют нормальный вывод, оставляя только ошибки (если Любые).

В Microsoft Windows может потребоваться префикс команда onsgmls с полным путь туда, где он был установлен, например C:\Программа Файлы\OpenSP\bin\onsgmls.

Для rxp :

$ rxp myfile. xml

rxp также есть некоторые опции которые описаны на его веб-сайте страница.

В Microsoft Windows может потребоваться префикс rxp с полным путем к где бы он ни был установлен, например, C:\Program Файлы\ltxml2\bin\rxp.

Предыдущий

Следующий

xml.etree.ElementTree — XML API ElementTree — Документация по Python 3.10.7

Исходный код: Lib/xml/etree/ElementTree.py

Модуль xml.etree.ElementTree реализует простой и эффективный API для анализа и создания XML-данных.

Изменено в версии 3.3: Этот модуль будет использовать быструю реализацию, когда это возможно.

Устарело, начиная с версии 3.3: модуль xml.etree.cElementTree устарел.

Предупреждение

Модуль xml.etree.ElementTree не защищен от злонамеренно сконструированные данные. Если вам нужно проанализировать ненадежные или данные, не прошедшие проверку подлинности, см. XML-уязвимости.

Учебник

Это краткое руководство по использованию xml.etree.ElementTree ( ET в короткая). Цель состоит в том, чтобы продемонстрировать некоторые строительные блоки и основные концепции модуля.

XML-дерево и элементы

XML по своей сути является иерархическим форматом данных и наиболее естественным способом представить это с деревом. ET имеет для этой цели два класса — ElementTree представляет весь документ XML в виде дерева, а Элемент представляет один узел в этом дереве. Взаимодействие с весь документ (чтение и запись в/из файлов) обычно выполняется на уровне ElementTree . Взаимодействие с одним элементом XML и его подэлементы выполняются на уровне Element .

Разбор XML

Мы будем использовать следующий XML-документ в качестве образца данных для этого раздела:

 
<данные>
    <название страны="Лихтенштейн">
        <ранг>1
        <год>2008
        141100
        
        
    
    <название страны="Сингапур">
        <ранг>4
        <год>2011
        59900
        
    
    <название страны="Панама">
        <ранг>68
        <год>2011
        13600
        
        
    

 

Мы можем импортировать эти данные, читая из файла:

 импортировать xml. etree.ElementTree как ET
дерево = ET.parse('country_data.xml')
корень = дерево.getroot()
 

Или напрямую из строки:

 корень = ET.fromstring(country_data_as_string)
 

fromstring() анализирует XML из строки непосредственно в элемент , который является корневым элементом анализируемого дерева. Другие функции синтаксического анализа могут создайте ElementTree . Проверьте документацию, чтобы быть уверенным.

Как элемент , корень имеет тег и словарь атрибутов:

 >>> root.тег
'данные'
>>> root.attrib
{}
 

У него также есть дочерние узлы, по которым мы можем перебирать:

 >>> для дочернего элемента в корне:
... print(child.tag, child.attrib)
...
страна {'имя': 'Лихтенштейн'}
страна {'имя': 'Сингапур'}
страна {'имя': 'Панама'}
 

Дочерние узлы вложены друг в друга, и мы можем получить доступ к определенным дочерним узлам по индексу:

 >>> корень[0][1]. текст
'2008'
 

Примечание

Не все элементы входных данных XML станут элементами разобранное дерево. В настоящее время этот модуль пропускает любые комментарии XML, инструкции по обработке и объявления типа документа в вход. Тем не менее, деревья, построенные с использованием API этого модуля, скорее чем синтаксический анализ текста XML может иметь комментарии и обработку инструкции в них; они будут включены при создании XML выход. Доступ к объявлению типа документа можно получить, передав обычай экземпляр TreeBuilder в XMLParser конструктор.

Pull API для неблокирующего синтаксического анализа

Для большинства функций синтаксического анализа, предоставляемых этим модулем, требуется весь документ для чтения сразу перед возвратом какого-либо результата. Можно использовать XMLParser и подавать в него данные постепенно, но это push-API, который вызывает методы для цели обратного вызова, что является слишком низкоуровневым и неудобным для большинство потребностей. Иногда пользователю действительно нужно иметь возможность анализировать XML. постепенно, не блокируя операции, наслаждаясь удобством полностью построен Элемент объектов.

Самый мощный инструмент для этого — XMLPullParser . Это не требуют блокирующего чтения для получения XML-данных и вместо этого загружаются данными постепенно с вызовами XMLPullParser.feed() . Чтобы получить проанализированный XML элементы, вызовите XMLPullParser.read_events() . Вот пример:

 >>> парсер = ET.XMLPullParser(['начало', 'конец'])
>>> parser.feed('sometext')
>>> список(parser.read_events())
[('start', <элемент 'mytag' по адресу 0x7fa66db2be58>)]
>>> parser.feed(' больше текста')
>>> для события elem в parser.read_events():
... печать (событие)
... print(elem.tag, 'text=', elem.text)
...
конец
 

Очевидным вариантом использования являются приложения, работающие неблокирующим образом. где данные XML принимаются из сокета или считываются постепенно из какое-то запоминающее устройство. В таких случаях блокирующие чтения неприемлемы.

Из-за своей гибкости XMLPullParser может оказаться неудобным для более простые варианты использования. Если вы не возражаете против блокировки вашего приложения при чтении XML данные, но все же хотели бы иметь возможности инкрементного анализа, взгляните в iterparse() . Это может быть полезно, когда вы читаете большой XML-документ. и не хочу держать его полностью в памяти.

Поиск интересных элементов

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

 >>> для соседа в root.iter('neighbor'):
... print(neighbor.attrib)
...
{'название': 'Австрия', 'направление': 'E'}
{'имя': 'Швейцария', 'направление': 'З'}
{'имя': 'Малайзия', 'направление': 'N'}
{'имя': 'Коста-Рика', 'направление': 'W'}
{'имя': 'Колумбия', 'направление': 'E'}
 

Element. findall() находит только элементы с прямым тегом дочерние элементы текущего элемента. Element.find() находит первых потомков с определенным тегом, а Element.text получает доступ к тексту элемента содержание. Element.get() обращается к атрибутам элемента:

 >>> для страны в root.findall('country'):
... ранг = страна.найти('ранг').текст
... имя = страна.получить('имя')
... печать (имя, звание)
...
Лихтенштейн 1
Сингапур 4
Панама 68
 

Более сложная спецификация того, какие элементы искать, возможна с помощью используя XPath.

Изменение файла XML

ElementTree предоставляет простой способ создания XML-документов и записи их в файлы. Для этой цели служит метод ElementTree.write() .

После создания объектом Element можно управлять, напрямую изменяя его поля (такие как Element.text ), добавление и изменение атрибутов ( Элемент. set() ), а также добавление новых дочерних элементов (например, с Element.append() ).

Допустим, мы хотим добавить по одному рейтингу каждой страны и добавить обновленный атрибут элемента ранга:

 >>> для ранга в root.iter('rank'):
... новый_ранг = int(rank.text) + 1
... rank.text = str(new_rank)
... rank.set('обновлено', 'да')
...
>>> tree.write('output.xml')
 

Наш XML теперь выглядит так:

 
<данные>
    <название страны="Лихтенштейн">
        2
        <год>2008
        141100
        
        
    
    <название страны="Сингапур">
        5
        <год>2011
        59900
        
    
    <название страны="Панама">
        69
        <год>2011
        13600
        
        
    

 

Мы можем удалять элементы, используя Element. remove() . Допустим, мы хотим удалить все страны рангом выше 50:

 >>> для страны в root.findall('country'):
... # использование root.findall(), чтобы избежать удаления во время обхода
... rank = int(country.find('rank').text)
... если ранг > 50:
... root.remove(страна)
...
>>> tree.write('output.xml')
 

Обратите внимание, что одновременная модификация во время итерации может привести к проблемам, точно так же, как при повторении и изменении списков или диктов Python. Поэтому в примере сначала собираются все совпадающие элементы с root.findall() , и только потом перебирает список совпадений.

Наш XML теперь выглядит так:

 
<данные>
    <название страны="Лихтенштейн">
        2
        <год>2008
        141100
        
        
    
    <название страны="Сингапур">
        5
        <год>2011
        59900
        
    

 

Создание XML-документов

Функция SubElement() также предоставляет удобный способ создания новых подэлементов для данного элемента:

 >>> а = ET. Элемент('а')
>>> b = ET.SubElement(a, 'b')
>>> c = ET.SubElement(a, 'c')
>>> d = ET.SubElement(c, 'd')
>>> ET.dump(a)

 

Разбор XML с пространствами имен

Если вход XML имеет пространства имен, теги и атрибуты с префиксами в форме префикс: какой-то тег расширяется до {uri}sometag , где префикс заменен полным URI . Кроме того, если есть пространство имен по умолчанию, этот полный URI добавляется ко всем тегам без префикса.

Вот пример XML, который включает два пространства имен, одно с префикс «вымышленный», а другой служит пространством имен по умолчанию:

 

    <актер>
        Джон Клиз
        Ланселот
        Арчи Лич
    
    <актер>
        Эрик Айдл
        Сэр Робин
        Гюнтер
        Командир Клемент
    

 

Одним из способов поиска и изучения этого примера XML является добавление вручную URI для каждого тега или атрибута в xpath найти() или найтивсе() :

 корень = из строки (xml_text)
для актера в root. findall('{http://people.example.com}actor'):
    имя = актер.найти('{http://people.example.com}имя')
    печать (имя.текст)
    для символа в act.findall('{http://characters.example.com}character'):
        печать(' |-->', символ.текст)
 

Лучшим способом поиска примера XML с пространством имен является создание словарь со своими префиксами и использовать их в функциях поиска:

 нс = {'настоящий_человек': 'http://people.example.com',
      «роль»: «http://characters.example.com»}
для актера в root.findall('real_person:actor', ns):
    имя = актер.найти('реальный_человек:имя', нс)
    печать (имя.текст)
    для символа в act.findall('role:character', ns):
        печать(' |-->', символ.текст)
 

Оба этих подхода выводят:

 Джон Клиз
 |--> Ланселот
 |--> Арчи Лич
Эрик Айдл
 |--> Сэр Робин
 |--> Гюнтер
 |--> Командир Клемент
 

Поддержка XPath

Этот модуль обеспечивает ограниченную поддержку Выражения XPath для поиска элементов в дерево. Цель состоит в том, чтобы поддерживать небольшое подмножество сокращенного синтаксиса; полный Механизм XPath выходит за рамки модуля.

Пример

Вот пример, демонстрирующий некоторые возможности XPath модуль. Мы будем использовать XML-документ countrydata из Разбор XML-раздела:

 импортировать xml.etree.ElementTree как ET
root = ET.fromstring(данные страны)
# Элементы верхнего уровня
root.findall(".")
# Все «соседские» внуки «деревенских» детей верхнего уровня
# элементы
root.findall("./страна/сосед")
# Узлы с name='Singapore', у которых есть дочерний элемент 'year'
root.findall(".//год/..[@name='Сингапур']")
# узлы 'year', которые являются дочерними элементами узлов с name='Singapore'
root.findall(".//*[@name='Сингапур']/год")
# Все «соседние» узлы, которые являются вторыми дочерними узлами своего родителя
root.findall(".//сосед [2]")
 

Для XML с пространствами имен используйте обычную обозначение {namespace}tag :

 # Все теги заголовка дублинского ядра в документе
root. findall(".//{http://purl.org/dc/elements/1.1/}название")
 

Поддерживаемый синтаксис XPath

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

Артикул

Функции

xml.etree.ElementTree. канонизировать ( xml_data=нет , * , out=Нет , from_file=Нет , **опции )

C14N 2. 0 Функция трансформации.

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

Эта функция принимает строку данных XML ( xml_data ) или путь к файлу или файловый объект ( from_file ) в качестве входных данных, преобразует его в канонический форму и записывает ее, используя файловый (подобный) объект из , если он предоставлен, или возвращает его как текстовую строку, если нет. Выходной файл получает текст, не байты. Поэтому его следует открывать в текстовом режиме с помощью utf-8 . кодирование.

Типичное использование:

 xml_data = "<корень>..."
печать (канонизировать (xml_data))
с open("c14n_output.xml", mode='w', encoding='utf-8') как out_file:
    канонизировать (xml_data, out = out_file)
с open("c14n_output. xml", mode='w', encoding='utf-8') как out_file:
    канонизировать (from_file="inputfile.xml", out=out_file)
 

Конфигурация Опции следующие:

• with_comments : установите значение true, чтобы включить комментарии (по умолчанию: false)

• strip_text : установите значение true для удаления пробелов до и после текстового содержимого

  (по умолчанию: false)

• rewrite_prefixes : установите значение true, чтобы заменить префиксы пространств имен на «n {число}»

  (по умолчанию: false)

• qname_aware_tags : набор имен тегов, поддерживающих qname, в которых префиксы

  должны быть заменены в текстовом содержимом (по умолчанию: пусто)

• qname_aware_attrs : набор имен атрибутов, поддерживающих qname, в которых префиксы

  должны быть заменены в текстовом содержимом (по умолчанию: пусто)

• exclude_attrs : набор имен атрибутов, которые не следует сериализовать

• exclude_tags : набор имен тегов, которые не следует сериализовать

В приведенном выше списке параметров «набор» относится к любой коллекции или итерации строки, порядок не ожидается.

Новое в версии 3.8.

xml.etree.ElementTree. Комментарий ( текст = Нет )

Фабрика элементов комментариев. Эта фабричная функция создает специальный элемент который будет сериализован стандартным сериализатором как XML-комментарий. Строка комментария может быть либо строкой байтов, либо строкой Unicode. текст это строка, содержащая строку комментария. Возвращает экземпляр элемента представляющий комментарий.

Обратите внимание, что XMLParser пропускает комментарии во входных данных вместо создания для них объектов комментариев. ElementTree будет содержат только узлы комментариев, если они были вставлены в дерево с использованием одного из методов Element .

xml.etree.ElementTree. дамп ( элемент )

Записывает дерево элементов или структуру элементов в sys. stdout. Эта функция следует использовать только для отладки.

Точный выходной формат зависит от реализации. В этой версии это записывается как обычный файл XML.

elem — это дерево элементов или отдельный элемент.

Изменено в версии 3.8: Функция dump() теперь сохраняет указанный порядок атрибутов. пользователем.

xml.etree.ElementTree. fromstring ( text , parser=None )

Разбирает раздел XML из строковой константы. То же, что и XML() . текст представляет собой строку, содержащую XML-данные. Парсер — необязательный экземпляр парсера. Если он не указан, используется стандартный синтаксический анализатор XMLParser . Возвращает экземпляр Element .

xml.etree.ElementTree. fromstringlist ( последовательность , парсер = нет )

Анализирует документ XML из последовательности фрагментов строки. последовательность представляет собой список или другая последовательность, содержащая фрагменты XML-данных. парсер является необязательный экземпляр парсера. Если не указано, стандартный XMLParser используется парсер. Возвращает экземпляр Element .

Новое в версии 3.2.

xml.etree.ElementTree. отступ ( дерево , пробел=’ , уровень=0 )

Добавляет пробел к поддереву для визуального отступа дерева. Это можно использовать для создания красиво напечатанного XML-вывода. дерево может быть Element или ElementTree. пробел это пробел строка, которая будет вставлена ​​для каждого уровня отступа, два пробела символов по умолчанию. Для отступа частичных поддеревьев внутри уже дерево с отступом, передайте начальный уровень отступа как level .

Новое в версии 3.9.

xml. etree.ElementTree. элемент (элемент )

Проверить, является ли объект допустимым элементом. элемент является экземпляр элемента. Возвращает True , если это элемент объекта.

xml.etree.ElementTree. iterparse ( источник , события = нет , парсер = нет )

Последовательно анализирует раздел XML в дереве элементов и сообщает, что переходит к пользователю. источник — это имя файла или файловый объект содержащие XML-данные. события — это последовательность событий для отчета. поддерживаемые события: строки "начало" , "конец" , "комментарий" , "пи" , "начало-нс" и "конец-нс" (события «ns» используются для получения подробных сведений о пространстве имен Информация). Если события опущены, сообщается только "конец" событий. Парсер — необязательный экземпляр парсера. Если не указано, стандарт XMLParser Используется анализатор . парсер должен быть подклассом XMLParser и может использовать только стандартный TreeBuilder в качестве цель. Возвращает итератор, обеспечивающий 90 140 (событие, элемент) 90 141 пары.

Обратите внимание, что хотя iterparse() строит дерево постепенно, блокировка чтения на источник (или файл, который он называет). Соответственно, не годится для приложений, в которых блокировка чтения невозможна. Для полной неблокировки разбор, см. XMLPullParser .

Примечание

iterparse() только гарантирует, что он видел символ «>» в начальный тег, когда он генерирует событие «старт», поэтому атрибуты определены, но содержимое атрибутов text и tail при этом не определено точка. То же самое относится к дочерним элементам; они могут быть или не быть подарок.

Если вам нужен полностью заполненный элемент, вместо этого ищите «конечные» события.

Устарело, начиная с версии 3.4: аргумент синтаксического анализатора .

Изменено в версии 3.8: Добавлены события comment и pi .

xml.etree.ElementTree. анализ ( источник , анализатор = нет )

Преобразует XML-раздел в дерево элементов. источник — это имя файла или файл объект, содержащий XML-данные. синтаксический анализатор является необязательным экземпляром синтаксического анализатора. Если не указан, используется стандартный синтаксический анализатор XMLParser . Возвращает Экземпляр ElementTree .

xml.etree.ElementTree. ProcessingInstruction ( цель , текст = нет )

Фабрика элементов ПИ. Эта фабричная функция создает специальный элемент, который будет сериализован как инструкция по обработке XML. цель — это строка содержащий цель PI. текст — это строка, содержащая содержимое PI, если данный. Возвращает экземпляр элемента, представляющий инструкцию обработки.

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

xml.etree.ElementTree. register_namespace ( префикс , uri )

Регистрирует префикс пространства имен. Реестр является глобальным, и любой существующий отображение либо для данного префикса, либо для URI пространства имен будет удалено. Префикс — это префикс пространства имен. uri — это uri пространства имен. Теги и атрибуты в этом пространстве имен будут сериализованы с заданным префиксом, если в все возможное.

Новое в версии 3.2.

xml.etree.ElementTree. Подэлемент ( родитель , тег , attrib={} , **добавочный )

Завод подэлементов. Эта функция создает экземпляр элемента и добавляет к существующему элементу.

Имя элемента, имена атрибутов и значения атрибутов могут быть байтовые строки или строки Unicode. parent — родительский элемент. тег есть имя подэлемента. атрибут — необязательный словарь, содержащий элемент атрибуты. extra содержит дополнительные атрибуты, заданные как ключевое слово аргументы. Возвращает экземпляр элемента.

xml.etree.ElementTree. ToString ( Элемент , Кодирование = ‘US-ASCII’ , Метод = ‘XML’ , * , XML_DECLARATION = NOTE , , XML_DECLARATION = , , .

Создает строковое представление элемента XML, включая все подэлементы. 9Элемент 0033 является экземпляром элемента . кодировка 1 есть выходная кодировка (по умолчанию US-ASCII). Используйте encoding="unicode" для создать строку Unicode (в противном случае создается строка байтов). метод либо "xml" , "html" либо "текст" (по умолчанию "xml" ). xml_declaration , default_namespace и short_empty_elements имеют то же самое значение как в ElementTree.write() . Возвращает (необязательно) закодированную строку содержащий XML-данные.

Новое в версии 3.4: параметр short_empty_elements .

Новое в версии 3.8: параметры xml_declaration и default_namespace .

Изменено в версии 3.8: функция tostring() теперь сохраняет порядок атрибутов. указанный пользователем.

xml.etree.ElementTree. tostringlist ( элемент , encoding=’us-ascii’ , method=’xml’ , * , xml_declaration=нет , default_namespace=нет , элементы short_emptye

Создает строковое представление элемента XML, включая все подэлементы. Элемент является экземпляром Element . кодировка 1 есть выходная кодировка (по умолчанию US-ASCII). Используйте encoding="unicode" для создать строку Unicode (в противном случае создается строка байтов). метод либо "xml" , "html" либо "текст" (по умолчанию "xml" ). xml_declaration , default_namespace и short_empty_elements имеют то же самое значение как в ElementTree.write() . Возвращает список (необязательно) закодированных строки, содержащие XML-данные. Это не гарантирует какой-либо конкретной последовательности, за исключением того, что b"".join(tostringlist(element)) == tostring(element) .

Новое в версии 3.2.

Новое в версии 3.4: параметр short_empty_elements .

Новое в версии 3.8: параметры xml_declaration и default_namespace .

Изменено в версии 3. 8: Функция tostringlist() теперь сохраняет порядок атрибутов. указанный пользователем.

xml.etree.ElementTree. XML ( текст , синтаксический анализатор=нет )

Разбирает раздел XML из строковой константы. Эту функцию можно использовать для встраивать «XML-литералы» в код Python. текст — это строка, содержащая XML данные. Парсер — необязательный экземпляр парсера. Если не указано, стандарт XMLParser Используется анализатор . Возвращает экземпляр Element .

xml.etree.ElementTree. XMLID ( текст , синтаксический анализатор=нет )

Разбирает раздел XML из строковой константы, а также возвращает словарь который сопоставляет идентификаторы элементов с элементами. текст — это строка, содержащая XML данные. Парсер — необязательный экземпляр парсера. Если не указано, стандарт XMLParser Используется анализатор . Возвращает кортеж, содержащий Экземпляр элемента и словарь.

XВключает опору

Этот модуль обеспечивает ограниченную поддержку Директивы XInclude через вспомогательный модуль xml.etree.ElementInclude . Этот модуль можно использовать для вставки поддеревьев и текстовых строк в деревья элементов на основе информации в дереве.

Пример

Вот пример, демонстрирующий использование модуля XInclude. Чтобы включить XML-документ в текущий документ, используйте элемент {http://www.w3.org/2001/XInclude}include и установите для атрибута parse значение "xml" и используйте атрибут href , чтобы указать документ для включения.

 
<документ xmlns:xi="http://www.w3.org/2001/XInclude">
  

 

По умолчанию атрибут href рассматривается как имя файла. Вы можете использовать пользовательские загрузчики, чтобы переопределить это поведение. Также обратите внимание, что стандартный помощник не поддерживает синтаксис XPointer.

Чтобы обработать этот файл, загрузите его как обычно и передайте корневой элемент в модуль xml.etree.ElementTree :

 из xml.etree импортировать ElementTree, ElementInclude
дерево = ElementTree.parse("document.xml")
корень = дерево.getroot()
ElementInclude.include(корень)
 

Модуль ElementInclude заменяет элемент {http://www.w3.org/2001/XInclude}include корневым элементом из документа source.xml . Результат может выглядеть примерно так:

 <документ xmlns:xi="http://www.w3.org/2001/XInclude">
  Это абзац.

 

Если атрибут parse опущен, по умолчанию используется «xml». Атрибут href обязателен.

Чтобы включить текстовый документ, используйте кнопку {http://www.w3.org/2001/XInclude}включите элемент и установите для атрибута parse значение «текст»:

  0"?>
<документ xmlns:xi="http://www.w3.org/2001/XInclude">
  Авторское право (c) .

 

Результат может выглядеть примерно так:

 <документ xmlns:xi="http://www.w3.org/2001/XInclude">
  Авторское право (с) 2003.

 

Артикул

Функции

xml.etree.ElementInclude. default_loader ( href , разбор , кодировка = Нет )

Загрузчик по умолчанию. Этот загрузчик по умолчанию считывает включенный ресурс с диска. href — это URL-адрес. синтаксический анализ для режима синтаксического анализа «xml» или «текст». кодировка является дополнительной текстовой кодировкой. Если не указано, кодировка utf-8 . Возвращает расширенный ресурс. Если режим разбора равен "xml" , это ElementTree пример. Если режим синтаксического анализа — «текст», это строка Unicode. Если загрузчик не работает, он может вернуть None или вызвать исключение.

xml.etree.ElementInclude. включает ( elem , loader = None , base_url = None , max_depth = 6 )

Эта функция расширяет директивы XInclude. elem — корневой элемент. погрузчик есть необязательный загрузчик ресурсов. Если опущено, по умолчанию default_loader() . Если задано, это должен быть вызываемый объект, который реализует тот же интерфейс, что и default_loader() . base_url — это базовый URL-адрес исходного файла для разрешения относительные ссылки на файлы. max_depth — максимальное количество рекурсивных включения. Ограничено для снижения риска взрыва вредоносного содержимого. Пройти отрицательное значение, чтобы отключить ограничение.

Возвращает расширенный ресурс. Если режим разбора "xml" , это экземпляр ElementTree. Если режим синтаксического анализа «текстовый», это строка Юникода. Если загрузчик не работает, он может вернуть None или вызвать исключение.

Новое в версии 3.9: Параметры base_url и max_depth .

Объекты-элементы

класс xml.etree.ElementTree. Элемент ( тег , attrib={} , **добавочный )

Класс элемента. Этот класс определяет интерфейс Element и предоставляет эталонная реализация этого интерфейса.

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

ярлык

Строка, определяющая, какие данные представляет этот элемент ( тип элемента, другими словами).

текст

хвост

Эти атрибуты могут использоваться для хранения дополнительных данных, связанных с элемент. Их значения обычно являются строками, но могут быть любыми. объект, специфичный для приложения. Если элемент создан из XML-файл, text Атрибут содержит либо текст между начальный тег элемента и его первый дочерний или конечный тег, или None , и атрибут tail содержит либо текст между конечный тег и следующий тег или None . Для данных XML

 1234
 

элемент a имеет None для атрибутов text и tail , b элемент имеет текст "1" и хвост "4" , элемент c имеет текст "2" и хвост None , а элемент d имеет text None и tail "3" .

Чтобы получить внутренний текст элемента, см. itertext() , для пример "".join(element.itertext()) .

Приложения могут хранить произвольные объекты в этих атрибутах.

атрибут

Словарь, содержащий атрибуты элемента. Обратите внимание, что в то время как значение attrib всегда является реальным изменяемым словарем Python, ElementTree реализация может решить использовать другое внутреннее представление, и создавайте словарь, только если кто-то попросит об этом. Чтобы воспользоваться В таких реализациях по возможности используйте приведенные ниже методы словаря.

Следующие словарные методы работают с атрибутами элемента.

прозрачный ()

Сбрасывает элемент. Эта функция удаляет все подэлементы, очищает все атрибуты и устанавливает для атрибутов text и tail значение None .

получить ( ключ , по умолчанию=нет )

Получает атрибут элемента с именем key .

Возвращает значение атрибута или по умолчанию , если атрибут не найден.

шт. ()

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

ключи ()

Возвращает имена атрибутов элементов в виде списка. Имена возвращаются в произвольном порядке.

набор ( ключ , значение )

Установите для атрибута ключ элемента значение значение .

Следующие методы работают с дочерними элементами элемента (подэлементами).

добавить ( подэлемент )

Добавляет элемент подэлемент в конец внутреннего списка этого элемента подэлементов. Вызывает TypeError , если подэлемент не является Элемент .

расширить ( подэлементов )

Дополняет подэлементов из объекта последовательности с нулем или более элементами. Вызывает TypeError , если подэлемент не является Element .

Новое в версии 3.2.

найти ( соответствует , пространства имен = нет )

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

findall ( соответствует , пространства имен = нет )

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

findtext ( соответствует , по умолчанию = нет , пространства имен = нет )

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

вставка ( индекс , подэлемент )

Вставляет подэлемент в заданную позицию в этом элементе. повышает TypeError , если подэлемент не является элементом .

iter (тег =нет )

Создает итератор дерева с текущим элементом в качестве корня. Итератор выполняет итерацию по этому элементу и всем элементам ниже него, в документ (сначала в глубину) порядок. Если тег не Нет или '*' , только элементы, у которых тег равен тегу , возвращаются из итератора. Если древовидная структура изменяется во время итерации, результат не определен.

Новое в версии 3.2.

iterfind ( совпадение , пространств имен=нет )

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

Новое в версии 3.2.

иттертекст ()

Создает текстовый итератор. Итератор перебирает этот элемент и все подэлементов в порядке документа и возвращает весь внутренний текст.

Новое в версии 3.2.

makeelement ( тег , атрибут )

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

удалить ( подэлемент )

Удаляет подэлемент из элемента. В отличие от методов find* этот метод сравнивает элементы на основе идентификатора экземпляра, а не значения тега или содержание.

Объекты Element также поддерживают следующие методы типа последовательности для работы с подэлементами: __delitem__() , __getitem__() , __setitem__() , __len__() .

Внимание! Элементы без подэлементов будут проверяться как False . Это поведение изменится в будущих версиях. Используйте специальный len(elem) или elem is Вместо теста нет.

 элемент = root.find('foo')
если не элемент: # осторожно!
    print("элемент не найден или элемент не имеет подэлементов")
если элемент отсутствует:
    print("Элемент не найден")
 

До Python 3.8 порядок сериализации XML-атрибутов элементы были искусственно сделаны предсказуемыми путем сортировки атрибутов по их название. Основываясь на теперь гарантированном порядке диктов, этот произвольный переупорядочивание было удалено в Python 3.8, чтобы сохранить порядок, в котором изначально атрибуты были проанализированы или созданы пользовательским кодом.

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

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

 определение reorder_attributes (корень):
    для el в root.iter():
        атрибут = эл.атриб
        если длина (атрибут) > 1:
            # настроить порядок атрибутов, например. путем сортировки
            атрибуты = отсортированные (атрибуты.items())
            атрибут.очистить()
            attrib.update(атрибуты)
 

Объекты ElementTree

класс xml. etree.ElementTree. ElementTree ( элемент = нет , файл = нет )

Класс оболочки ElementTree. Этот класс представляет весь элемент иерархии и добавляет некоторую дополнительную поддержку сериализации в и из стандартный XML.

элемент является корневым элементом. Дерево инициализируется содержимым файла XML , если он задан.

_setroot ( элемент )

Заменяет корневой элемент этого дерева. Это отбрасывает текущий содержимое дерева и заменяет его заданным элементом. Использовать с забота. элемент является экземпляром элемента.

найти ( соответствует , пространства имен = нет )

То же, что и Element.find() , начиная с корня дерева.

findall ( соответствует , пространства имен = нет )

То же, что и Element. findall() , начиная с корня дерева.

найти текст ( соответствует , по умолчанию = Нет , пространства имен = Нет )

То же, что и Element.findtext() , начиная с корня дерева.

получить корень ()

Возвращает корневой элемент для этого дерева.

iter (тег =нет )

Создает и возвращает итератор дерева для корневого элемента. Итератор перебирает все элементы в этом дереве в порядке секций. тег это тег искать (по умолчанию возвращаются все элементы).

iterfind ( совпадение , пространств имен=нет )

То же, что и Element.iterfind() , начиная с корня дерева.

Новое в версии 3.2.

разбор ( источник , анализатор=нет )

Загружает внешний раздел XML в это дерево элементов. источник это файл имя или файловый объект. Парсер — необязательный экземпляр парсера. Если он не указан, используется стандартный синтаксический анализатор XMLParser . Возвращает корневой элемент раздела.

Напишите ( Файл , Encoding = ‘US-ASCII’ , XML_DECLARATION = NONE , DEFAULT_NAMESPACE = NOT , Метод = ‘XML’ , * , = ‘XML’ , * , = ‘xml’ , * 4, ).

Записывает дерево элементов в файл в формате XML. файл имя файла или файловый объект, открытый для записи. кодировка 1 это вывод кодировка (по умолчанию US-ASCII). xml_declaration определяет, следует ли добавлять объявление XML в файл. Использовать False никогда, True всегда, None только если не US-ASCII или UTF-8 или Unicode (по умолчанию None ). default_namespace устанавливает пространство имен XML по умолчанию (для «xmlns»). метод либо "xml" , "html" или "текст" (по умолчанию "xml" ). Параметр short_empty_elements , содержащий только ключевое слово, управляет форматированием. элементов, не содержащих содержимого. Если True (по умолчанию), они испускаются как один самозакрывающийся тег, в противном случае они испускаются как пара начальных/конечных тегов.

Вывод представляет собой строку ( str ) или двоичный файл ( байт ). Это контролируется кодировкой аргумент. Если кодирует "unicode" , вывод представляет собой строку; в противном случае это двоичный код. Обратите внимание, что это может конфликтовать с типом файла , если он открытый файловый объект; убедитесь, что вы не пытаетесь записать строку в двоичный поток и наоборот.

Новое в версии 3.4: параметр short_empty_elements .

Изменено в версии 3.8: метод write() теперь сохраняет указанный порядок атрибутов. пользователем.

Это файл XML, который будет обработан:

 
    <голова>
        
    
    <тело>
        
Перемещено на example.org
        или example.com.
    

 

Пример изменения атрибута «цель» каждой ссылки в первом абзаце:

 >>> из xml.etree.ElementTree импортировать ElementTree
>>> дерево = ЭлементДерева()
>>> tree.parse("index.xhtml")
<Элемент 'html' по адресу 0xb77e6fac>
>>> p = tree.find("body/p") # Находит первое вхождение тега p в теле
>>> р
<Элемент 'p' по адресу 0xb77ec26c>
>>> links = list(p.iter("a")) # Возвращает список всех ссылок
>>> ссылки
[<Элемент 'a' по адресу 0xb77ec2ac>, <Элемент 'a' по адресу 0xb77ec1cc>]
>>> for i in links: # Перебирает все найденные ссылки
... i.attrib["цель"] = "пусто"
>>> tree.write("output.xhtml")
 

Объекты QName

класс xml. etree.ElementTree. QName ( text_or_uri , тег = нет )

Оболочка QName. Это можно использовать для переноса значения атрибута QName, чтобы чтобы получить правильную обработку пространства имен на выходе. text_or_uri — это строка содержащее значение QName, в форме {uri}local или, если аргумент тега дан, часть URI QName. Если задан тег , первый аргумент интерпретируется как URI, а этот аргумент интерпретируется как локальное имя. Экземпляры QName непрозрачны.

Объекты TreeBuilder

класс xml.etree.ElementTree. Treebuilder ( element_factory = none , * , Комментарий_фактор = Нет , PI_Factory = None , Insert_comments = FALSE , InSert_PIS = false_9034)

Построитель структуры общих элементов. Этот конструктор преобразует последовательность вызовы методов start, data, end, comment и pi для правильно сформированного элемента структура. Вы можете использовать этот класс для построения структуры элементов, используя пользовательский синтаксический анализатор XML или синтаксический анализатор для какого-либо другого XML-подобного формата.

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

Функции comment_factory и pi_factory , если заданы, должны вести себя как функции Comment() и ProcessingInstruction() для создавать комментарии и инструкции по обработке. Если не указано, по умолчанию будут использоваться фабрики. Когда insert_comments и/или insert_pis верно, комментарии/писи будут вставлены в дерево, если они появятся в корне элемента (но не вне его).

закрыть ()

Очищает буферы компоновщика и возвращает документ верхнего уровня элемент. Возвращает экземпляр Element .

данные ( данные )

Добавляет текст к текущему элементу. данные — это строка. Это должно быть либо строка байтов, либо строка Unicode.

конец ( тег )

Закрывает текущий элемент. тег — это имя элемента. Возвращает закрытый элемент.

начало ( тег , атрибуты )

Открывает новый элемент. тег — это имя элемента. attrs это словарь содержащие атрибуты элемента. Возвращает открытый элемент.

комментарий ( текст )

Создает комментарий с заданным текстом . Если insert_comments истинно, это также добавит его к дереву.

Новое в версии 3.8.

пи ( цель , текст )

Создает комментарий с заданным именем цели и текстом . Если insert_pis верно, это также добавит его в дерево.

Новое в версии 3.8.

Кроме того, пользовательский объект TreeBuilder может предоставлять следующие методы:

тип документа ( имя , общедоступный , система )

Обрабатывает объявление типа документа. имя — это имя типа документа. публичный есть общедоступный идентификатор. система — системный идентификатор. Этот способ не существует по умолчанию TreeBuilder класс.

Новое в версии 3.2.

start_ns ( префикс , uri )

Вызывается всякий раз, когда синтаксический анализатор встречает новое объявление пространства имен, до обратного вызова start() для открывающего элемента, который его определяет. префикс равен '' для пространства имен по умолчанию и объявленного имя префикса пространства имен в противном случае. uri — это URI пространства имен.

Новое в версии 3.8.

end_ns ( префикс )

Вызывается после обратного вызова end() элемента, объявленного сопоставление префикса пространства имен с именем префикса , который пошел вне сферы действия.

Новое в версии 3.8.

класс xml.etree.ElementTree. C14NWriterTarget ( запись , * , with_comments=False , strip_text = false , rewrite_prefixes = false , qname_aware_tags = none , qname_aware_attrs = none , excude_attrs = none , , , excude_attrs = none , , , extude_attrs = no , , extude_attrs = none , .

Писатель C14N 2.0. Аргументы – это то же, что и для функции canonicalize() . Этот класс не создает дерево, но переводит события обратного вызова непосредственно в сериализованную форму используя функцию записи .

Новое в версии 3.8.

Объекты XMLParser

класс xml.etree.ElementTree. XMLParser ( * , цель = нет , кодировка = нет )

Этот класс является низкоуровневым строительным блоком модуля. Оно использует xml.parsers.expat для эффективного синтаксического анализа XML на основе событий. Может передавать XML-данные постепенно с помощью метода feed() и синтаксического анализа события переводятся в push-API — путем вызова обратных вызовов на цель объект. Если цель опущена, используется стандартный TreeBuilder . Если задана кодировка 1, значение имеет приоритет над кодировка, указанная в файле XML.

Изменено в версии 3.8: теперь параметры содержат только ключевые слова. Аргумент html больше не поддерживается.

закрыть ()

Завершает передачу данных парсеру. Возвращает результат вызова close() метод цель пройдена при строительстве; по умолчанию, это элемент документа верхнего уровня.

подача ( данные )

Передает данные парсеру. данные — закодированные данные.

XMLParser.feed() вызывает цель start(tag, attrs_dict) метод для каждого открывающего тега, его метод end(tag) для каждого закрывающего тега и данные обрабатывается методом данные(данные) . Для дальнейшего поддерживаемого обратного вызова методы, см. класс TreeBuilder . XMLParser.close() вызов цель метод close() . XMLParser можно использовать не только для построение древовидной структуры. Это пример подсчета максимальной глубины XML-файла:

 >>> из xml.etree.ElementTree импортировать XMLParser
>>> class MaxDepth: # Целевой объект парсера
. .. максимальная глубина = 0
... глубина = 0
... def start(self, tag, attrib): # Вызывается для каждого открывающего тега.
... собственная глубина += 1
... если self.depth > self.maxDepth:
... self.maxDepth = self.depth
... def end(self, tag): # Вызывается для каждого закрывающего тега.
... собственная глубина -= 1
... определить данные (я, данные):
... pass # Нам не нужно ничего делать с данными.
... def close(self): # Вызывается, когда все данные проанализированы.
... вернуть self.maxDepth
...
>>> цель = Максимальная глубина()
>>> парсер = XMLParser(цель=цель)
>>> примерXml = """
... <а>
... <б>
... 
... <б>
... <с>
... <д>
... 
... 
... 
... """
>>> parser.feed(exampleXml)
>>> парсер.close()
4
 

Объекты XMLPullParser

класс xml.etree.ElementTree. XMLPullParser ( события = нет )

Опрашивающий анализатор, подходящий для неблокирующих приложений. Его API на стороне ввода аналогично XMLParser , но вместо отправки вызовов в цель обратного вызова, XMLPullParser собирает внутренний список синтаксического анализа события и позволяет пользователю читать из него. события — это последовательность событий, доложить. Поддерживаемые события — это строки "начало" , "конец" , "comment" , "pi" , "start-ns" и "end-ns" (события «ns» используются для получения подробной информации о пространстве имен). Если события опущены, сообщается только о "концах" событий.

подача ( данные )

Передать парсеру заданные байты данных.

закрыть ()

Сообщить синтаксическому анализатору, что поток данных завершен. в отличие XMLParser.close() , этот метод всегда возвращает None . Любые события, еще не полученные при закрытии синтаксического анализатора, все еще могут быть читать с помощью read_events() .

read_events ()

Возвращает итератор по событиям, которые были обнаружены в данные, подаваемые на парсер. Итератор выдает (событие, элемент) пар, где события — это строка, представляющая тип события (например, "конец" ) и элемент является обнаружен объект Element или другое значение контекста, как показано ниже.

• start , end : текущий элемент.

• комментарий , pi : текущий комментарий/инструкция обработки

• start-ns : кортеж (префикс, uri) , именующий объявленное пространство имен отображение.

• конец-нс : Нет (это может измениться в будущей версии)

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

Примечание

XMLPullParser гарантирует только то, что он видел «>» символ начального тега, когда он генерирует событие «старт», поэтому атрибуты определены, но содержимое текстовых и хвостовых атрибутов в этот момент не определены. То же самое относится к дочерним элементам; они могут быть, а могут и не быть.

Если вам нужен полностью заполненный элемент, вместо этого ищите «конечные» события.

Новое в версии 3.4.

Изменено в версии 3.8: Добавлены события comment и pi .

Исключения

класс xml.etree.ElementTree. ParseError

Ошибка синтаксического анализа XML, вызванная различными методами синтаксического анализа в этом модуле, когда разбор не удался. Строковое представление экземпляра этого исключения будет содержать удобное сообщение об ошибке. Кроме того, у него будет доступны следующие атрибуты:

код

Числовой код ошибки анализатора expat. См. документацию xml.parsers.expat для списка кодов ошибок и их значений.

позиция

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

Сноски

1(1,2,3,4)

Строка кодировки, включенная в вывод XML, должна соответствовать соответствующие стандарты. Например, «UTF-8» допустимо, но «UTF8» нет. См. https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-EncodingDecl. и https://www.iana.org/assignments/character-sets/character-sets.xhtml.

Как анализировать XML-файлы в Python — на примере

• Для чего используются XML-файлы в Python?
• Структура документов XML
• Теги XML и файлы XML на языке Python
• Разбор файлов XML в Python с использованием библиотеки ElementTree
• Разбор файлов XML в Python с помощью цикла for
• Резюме
• Научитесь программировать и измените свою карьеру!

Для чего используются файлы XML в Python?

XML означает расширяемый язык разметки. Это текстовый формат для структурирования и обмена данными по сетям, между программами и между людьми. Несмотря на свое сходство с HTML, который также основан на стандартах SGML, формат XML придерживается строгих правил форматирования.

 смешать новый xml_example
компакт-диск xml_example 

 
  <задача>
    Это основной элемент списка дел №1
    <приоритет>3
  
  <задача>
    Это основная часть задачи №2
    <приоритет>1
  
  <задача>
    Это основная часть задачи №3
    <приоритет>3
  
 

 iex-S микс 

 {:ok, xmldoc} = File. read(Path.expand("./example.xml")) 

 {doc, []} = xmldoc |> to_charlist() |> :xmerl_scan.string() 

 {{:xmlElement, :todos, :todos, [], {:xmlNamespace, [], []}, [], 1, [],
  [
    {:xmlText, [todos: 1], 1, [], '\n', :text},
    {:xmlElement, :todo, :todo, [], {:xmlNamespace, [], []}, [todos: 1], 2,
     [{:xmlAttribute, :id, [], [], [], [задача: 2, задача: 1], 1, [], '1', false}],
     [
       {:xmlText, [задача: 2, задача: 1], 1, [], '\n', :текст},
       {:xmlElement, :body, :body, [], {:xmlNamespace, [], []},
        [дело: 2, дело: 1], 2, [],
        [
          {:xmlText, [тело: 2, задача: 2, задача: 1], 1, [],
           'Это основная часть задачи #1', :text}
        ], [], '/Users/max/Documents/pspdfkit/xml_example', :undeclared},
       {:xmlText, [задача: 2, задача: 1], 3, [], '\n', :текст},
       {:xmlElement, :priority, :priority, [], {:xmlNamespace, [], []},
        [дело: 2, дело: 1], 4, [],
        [{:xmlText, [приоритет: 4, задача: 2, задача: 1], 1, [], '3', :текст}], [],
        '/Users/max/Documents/pspdfkit/xml_example', :undeclared},
       {:xmlText, [задача: 2, задача: 1], 5, [], '\n', :текст}
     ], [], '/Users/max/Documents/pspdfkit/xml_example', :undeclared},
     . .. 

 defmodule XML сделать
  импорт записи
  defrecord(:xmlElement, extract(:xmlElement, from_lib: "xmerl/include/xmerl.hrl"))
  defrecord(:xmlAttribute, extract(:xmlAttribute, from_lib: "xmerl/include/xmerl.hrl"))
  derecord(:xmlText, extract(:xmlText, from_lib: "xmerl/include/xmerl.hrl"))
  def get_child_elements (элемент) сделать
    Enum.filter(XML.xmlElement(элемент,: содержимое), fn дочерний элемент ->
      Record.is_record(дочерний, :xmlElement)
    конец)
  конец
  def find_child(дети, имя) сделать
    Enum. find(children, fn child -> XML.xmlElement(child, :name) == name end)
  конец
  def get_text (элемент) сделать
    Enum.find(XML.xmlElement(элемент,: содержимое), fn дочерний элемент ->
      Record.is_record(дочерний, :xmlText)
    конец)
    |> XML.xmlText(:значение)
  конец
конец
требуется XML 

 doc |> XML.get_child_elements() |> Enum.map(fn todo -> XML.get_child_elements(todo) |> XML.find_child(:body) |> XML.get_text() end)
# Возвращает:
['Это основной элемент списка дел №1',
 «Это основная часть задачи № 2»,
 'Это основная часть задачи #3'] 

 :xmerl_xpath.string('/todos/todo/body/text()', doc) |> Enum.map(&XML.xmlText(&1, :value)) 

 :xmerl_xpath.string('/todos/todo[@id=\"1\"]/body/text()', doc) |> Enum.map(&XML.xmlText(&1, :value))
# Возвращает
['Это основной элемент списка дел №1'] 

 :xmerl_xpath.string('/todos/todo[priority=\"3\"]/body/text()', doc) |> Enum.map(&XML.xmlText(&1, :value))
# Возвращает
['Это основная часть задачи #1', 'Это основная часть задачи #3'] 

 деф депс делать
  [
    {:sweet_xml, "~> 0.6.5"}
  ]
конец 

 импорт SweetXml
{:ok, xmldoc} = File.read(Path.expand("./example.xml"))
# получить основной текст всех задач, где атрибут ID равен 1, в виде списка:
xmldoc |> xpath(~x"/todos/todo[@id=\"1\"]/body/text()"l)
# Возвращает
['Это основная часть задачи #1']
# получить основной текст всех задач, где дочерний узел "priority" со значением `3` существует в виде списка:
xmldoc |> xpath(~x"/todos/todo[priority=\"3\"]/body/text()"l)
# Возвращает
['Это основная часть задачи #1', 'Это основная часть задачи #3'] 

 >>> from lxml import etree
 

 от io import StringIO, BytesIO
 

 >>> xml = ''
>>> корень = etree.fromstring(xml)
>>> etree.tostring(корень)
b''
 

 >>> tree = etree.parse(StringIO(xml))
>>> etree.tostring(tree.getroot())
b''
 

 >>> tree = etree.parse("doc/test.xml")
 

 >>> root = etree.fromstring(xml, base_url="http://where.it/is/from.xml")
 

 >>> parser = etree.XMLParser(ns_clean=True)
>>> дерево = etree.parse(StringIO(xml), парсер)
>>> etree.tostring(tree.getroot())
b''
 

 >>> parser = etree.XMLParser()
>>> print(len(parser.error_log))
0
>>> tree = etree.XML("\n", анализатор) # doctest: +ELLIPSIS
Traceback (последний последний вызов):
  ...
lxml.etree.XMLSyntaxError: несоответствие открывающего и конечного тегов: корневая строка 1 и b, строка 2, столбец 5...
>>> print(len(parser.error_log))
1
>>> ошибка = parser.error_log[0]
>>> напечатать(ошибка.сообщение)
Несоответствие открывающего и закрывающего тегов: корневая строка 1 и b
>>> печать (ошибка.строка)
2
>>> печать (ошибка. столбец)
5
 

 >>> сломанный_html = "
  
  <тело>
     
название страницы
 
  

 

 >>> html = etree.HTML(broken_html)
>>> результат = etree.tostring(html, pretty_print=True, method="html")
>>> распечатать(результат)

  <голова>
    
  
  <тело>
     
название страницы
 
  

 

 >>> class EchoTarget(object):
... def start(self, tag, attrib):
... print("start %s %r" % (тег, dict(attrib)))
... def end(self, tag):
... print("конец тега %s" %)
... определить данные (я, данные):
... печать("данные %r" % данные)
... комментарий по определению (я, текст):
... print("комментарий %s" % текст)
... закрыть (сам):
... печать ("закрыть")
... вернуть "закрыто!"
>>> parser = etree.XMLParser(target = EchoTarget())
>>> result = etree.XML("sometext",
... парсер)
начальный элемент {}
данные у'некоторые'
комментарий комментарий
данные u'текст'
конечный элемент
Закрыть
>>> распечатать(результат)
закрыто!
 

 >>> результат = etree. XML("<элемент>некоторыйтекст",
... парсер)
начальный элемент {}
данные у'некоторые'
комментарий комментарий
данные u'текст'
конечный элемент
Закрыть
>>> распечатать(результат)
закрыто!
 

 >>> класс CollectorTarget(объект):
... защита __init__(я):
... само.события = []
... def start(self, tag, attrib):
... self.events.append("start %s %r" % (tag, dict(attrib)))
... def end(self, tag):
... self.events.append("конец тега %s" %)
... определить данные (я, данные):
... self.events.append("данные %r" % данных)
... комментарий по определению (я, текст):
... self.events.append("комментарий %s" % text)
... закрыть (сам):
... self.events.append("закрыть")
... вернуть "закрыто!"
>>> parser = etree. XMLParser(target = CollectorTarget())
>>> результат = etree.XML("<элемент>какая-то",
... парсер) # doctest: +ELLIPSIS
Traceback (последний последний вызов):
  ...
lxml.etree.XMLSyntaxError: Несоответствие открывающего и конечного тегов...
>>> для события в parser.target.events:
... печать (событие)
начальный элемент {}
данные у'некоторые'
Закрыть
 

 >>> parser = etree.XMLParser(target = etree.TreeBuilder())
>>> result = etree.XML("sometext",
... парсер)
>>> печать(результат.тег)
элемент
>>> печать (результат [0].  текст)
комментарий
 

 >>> парсер = etree.XMLParser()
>>> для данных в (''):
... parser.feed(данные)
 

 >>> root = parser. close()
>>> print(root.tag)
корень
>>> print(root[0].tag)
а
 

 >>> parser = etree.XMLParser(target = EchoTarget())
>>> parser.feed("<элемент")
>>> parser.feed("nt>какой-то текст>> parser.feed("ent>")
конечный элемент
>>> результат = parser.close()
Закрыть
>>> распечатать(результат)
закрыто!
 

 >>> parser = etree.XMLPullParser(events=('начало', 'конец'))
>>> определение print_events(парсер):
... для действия, элемент в parser.read_events():
... print('%s: %s' % (действие, element.tag))
>>> parser.feed('какой-то текст')
>>> print_events(парсер)
начало: корень
>>> print_events(parser) # ну больше никаких событий, как раньше...
>>> parser.feed('<ребенок>')
>>> print_events(парсер)
начало: ребенок
начать
конец: а
>>> parser.feed('>> print_events(парсер)
конец: ребенок
>>> parser.feed('t>')
>>> print_events(парсер)
конец: корень
 

 >>> root = parser.close()
>>> etree.tostring(корень)
b'какой-то текст'
 

 >>> определение print_events(события):
... для действия, объект в событиях:
... если действие в ('начало', 'конец'):
... print("%s: %s" % (действие, obj.tag))
... действие elif == 'start-ns':
... print("%s: %s" % (действие, объект))
...         еще:
... печать (действие)
>>> event_types = ("начало", "конец", "начало-нс", "конец-нс")
>>> parser = etree.XMLPullParser(типы_событий)
>>> события = parser.read_events()
>>> parser.feed('<корень><элемент>')
>>> print_events(события)
начало: корень
начало: элемент
>>> parser.feed('тексттекст')
>>> print_events(события)
конец: элемент
начало: элемент
конец: элемент
>>> parser. feed('<пустой элемент xmlns="http://testns/" />')
>>> print_events(события)
start-ns: ('', 'http://testns/')
start: {http://testns/}пустой элемент
конец: {http://testns/}пустой элемент
конец-ns
>>> parser.feed('')
>>> print_events(события)
конец: корень
 

 >>> parser = etree.XMLPullParser()
>>> события = parser.read_events()
>>> parser.feed('текст')
>>> parser.feed('')
>>> для действия, elem в событиях:
... print('%s: %d' % (elem.tag, len(elem))) # обработка
... elem.clear(keep_tail=True) # удалить потомков
элемент: 0
ребенок: 0
элемент: 1
>>> parser.feed('<пустой элемент xmlns="http://testns/" />')
>>> для действия, elem в событиях:
... print('%s: %d' % (elem.tag, len(elem))) # обработка
... elem.clear(keep_tail=True) # удалить потомков
{http://testns/}пустой элемент: 0
корень: 3
>>> корень = parser. close()
>>> etree.tostring(корень)
б'<корень/>'
 

 >>> для события, элемент в parser.read_events():
. .. # ... сделать что-то с элементом
... element.clear(keep_tail=True) # очистить потомков
... в то время как element.getprevious() не None:
... del element.getparent()[0] # очищаем предыдущие элементы того же уровня
 

 >>> parser = etree.XMLPullParser(tag="element")
>>> parser. feed('текст')
>>> parser.feed('')
>>> parser.feed('<пустой элемент xmlns="http://testns/" />')
>>> для действия elem в parser.read_events():
... print("%s: %s" % (action, elem.tag))
конец: элемент
конец: элемент
>>> event_types = ("начало", "конец")
>>> parser = etree.XMLPullParser(event_types, tag="{http://testns/*")
>>> parser.feed('текст')
>>> parser.feed('')
>>> parser.feed('<пустой элемент xmlns="http://testns/" />')
>>> для действия elem в parser.read_events():
... print("%s: %s" % (action, elem.tag))
start: {http://testns/}пустой элемент
конец: {http://testns/}пустой элемент
 

 >>> класс Цель(объект):
... def start(self, tag, attrib):
... print('-> start(%s)' % тег)
... вернуть '>>START: %s<<' % тег
... def end(self, tag):
... print('-> end(%s)' % tag)
... вернуть '>>END: %s<<' % тег
... закрыть (сам):
... печать('-> закрыть()')
... вернуть "ЗАКРЫТО!"
>>> event_types = ('начало', 'конец')
>>> parser = etree.XMLPullParser(event_types, target=Target())
>>> parser.feed('')
-> начать (корень)
-> начать (ребенок1)
-> конец (ребенок1)
-> начать (ребенок2)
-> конец (ребенок2)
-> конец (корень)
>>> для действия значение в parser.read_events():
... print('%s: %s' % (действие, значение))
начало: >>НАЧАЛО: root<<
начало: >>НАЧАЛО: ребенок1<<
конец: >>КОНЕЦ: ребенок1<<
начало: >>НАЧАЛО: ребенок2<<
конец: >>КОНЕЦ: ребенок2<<
конец: >>КОНЕЦ: корень<<
>>> печать (parser.close())
-> закрыть()
ЗАКРЫТО!
 

 >>> class AttributeFilter(etree.TreeBuilder):
... def start(self, tag, attrib):
... атрибут = dict(атрибут)
... если 'зло' в атрибуте:
... атрибут['зло']
... вернуть super(AttributeFilter, self).start(tag, attrib)
>>> parser = etree.XMLPullParser(target=AttributeFilter())
>>> parser.feed('')
>>> для действия, элемент в parser.read_events():
... print('%s: %s(%r)' % (действие, element. tag, element.attrib))
конец: ребенок1({'тест': '123'})
конец: ребенок2({})
конец: корень({})
>>> корень = parser.close()
 

 >>> xml = '''
... <корень>
... текст
... текстхвост
... <пустой элемент xmlns="http://testns/" />
... 
... '''
>>> контекст = etree.iterparse(StringIO(xml))
>>> для действия, elem в контексте:
... print("%s: %s" % (action, elem.tag))
конец: элемент
конец: элемент
конец: {http://testns/}пустой элемент
конец: корень
 

 >>> context. root.tag
'корень'
 

 >>> events = ("start", "end")
>>> context = etree.iterparse(StringIO(xml), events=events)
>>> для действия, elem в контексте:
... print("%s: %s" % (action, elem.tag))
начало: корень
начало: элемент
конец: элемент
начало: элемент
конец: элемент
start: {http://testns/}пустой элемент
конец: {http://testns/}пустой элемент
конец: корень
 

 >>> f = StringIO(xml)
>>> контекст = etree. iterparse(
... ф, события = ("начало", "конец"), тег = "элемент")
>>> для действия, elem в контексте:
... print("%s: %s" % (action, elem.tag))
начало: элемент
конец: элемент
начало: элемент
конец: элемент
>>> корень = контекст.корень
 

 >>> context = etree.iterwalk(
... корень, события = ("начало", "конец"), тег = "элемент")
>>> для действия, elem в контексте:
... print("%s: %s" % (action, elem.tag))
начало: элемент
конец: элемент
начало: элемент
конец: элемент
 

 >>> корень = etree.XML('''
... <корень>
... <а>  
... <с />
... 
... ''')
>>> context = etree.iterwalk(root, events=("начало", "конец"))
>>> для действия, elem в контексте:
. .. print("%s: %s" % (action, elem.tag))
... если action == 'start' и elem.tag == 'a':
... context.skip_subtree() # игнорировать 
начало: корень
начать
конец: а
начало: с
конец: с
конец: корень
 

 >>> root = etree.XML( u' \uf8d1 + \uf8d2 ' )
 

 >>> etree.XML( u'\n' +
... u' \uf8d1 + \uf8d2 ' )
Traceback (последний последний вызов):
  ...
ValueError: строки Unicode с объявлением кодировки не поддерживаются.  Пожалуйста, используйте ввод байтов или фрагменты XML без объявления.
 

 >>> etree.tostring(root)
b'<тест>  +  '
>>> etree.tostring(root, encoding='UTF-8', xml_declaration=False)
b'<тест> \xef\xa3\x91 + \xef\xa3\x92 '
 

 >>> etree.tostring(root, encoding='unicode')
u'<тест> \uf8d1 + \uf8d2 '
>>> el = etree.
No related posts.