Ошибка парсинга xml документа: Ошибка парсинга xml, что это — справочник цифровых значений видов зачислений Сбербанк

lxml – это сторонняя библиотека с открытым исходным кодом, построенная на базе популярного синтаксического анализатора libxml2. Она обеспечивает стопроцентную совместимость с API ElementTree, полностью поддерживает XPath 1.0 и имеет несколько других приятных фишек. Для Windows доступен установщик; пользователям Linux следует проверить наличие скомпилированных пакетов в репозиториях дистрибутива с помощью, например, yum или apt-get. В противном случае вам придётся установить lxml вручную.

>>> from lxml import etree                   ①
>>> tree = etree. parse('examples/feed.xml')  ②
>>> root = tree.getroot()                    ③
>>> root.findall('{http://www.w3.org/2005/Atom}entry')  ④
[<Element {http://www.w3.org/2005/Atom}entry at e2b4e0>,
 <Element {http://www.w3.org/2005/Atom}entry at e2b510>,
 <Element {http://www.w3.org/2005/Atom}entry at e2b540>]

1. Строка 1. При импорте lxml предоставляет абсолютно такой же API, как встроенная библиотека ElementTree.
2. Строка 2. Функция parse() такая же, как в ElementTree.
3. Строка 3. Метод getroot() тоже такой же.
4. Строка 4. Метод findall() точно такой же.

При обработке больших XML документов lxml значительно быстрее, чем встроенная библиотека ElementTree. Если вы используете только API ElementTree и хотите, чтобы обработка выполнялась как можно быстрее, то можно попробовать импортировать библиотеку lxml и, в случае её отсутствия, использовать встроенную ElementTree.

try:
    from lxml import etree
except ImportError:
    import xml.etree.ElementTree as etree

Однако библиотека lxml не только быстрее, чем ElementTree. Ее метод findall() поддерживает более сложные выражения.

>>> import lxml.etree                                                                   ①
>>> tree = lxml.etree.parse('examples/feed.xml')
>>> tree.findall('//{http://www.w3.org/2005/Atom}*[@href]')                             ②
[<Element {http://www.w3.org/2005/Atom}link at eeb8a0>,
 <Element {http://www.w3.org/2005/Atom}link at eeb990>,
 <Element {http://www.w3.org/2005/Atom}link at eeb960>,
 <Element {http://www. w3.org/2005/Atom}link at eeb9c0>]
>>> tree.findall("//{http://www.w3.org/2005/Atom}*[@href='http://diveintomark.org/']")  ③
[<Element {http://www.w3.org/2005/Atom}link at eeb930>]
>>> NS = '{http://www.w3.org/2005/Atom}'
>>> tree.findall('//{NS}author[{NS}uri]'.format(NS=NS))                                 ④
[<Element {http://www.w3.org/2005/Atom}author at eeba80>,
 <Element {http://www.w3.org/2005/Atom}author at eebba0>]

1. Строка 1. В данном примере я импортирую lxml.etree (вместо предыдущего способа: from lxml import etree), чтобы подчеркнуть, что описываемые возможности характерны именно для lxml.
2. Строка 3. Этот запрос найдёт все элементы в пространстве имён Atom (любой вложенности), которые имеют атрибут href. Двойной слеш // в начале запроса означает «элементы любой вложенности (а не только дочерние элементы корневого элемента)». {http://www.w3.org/2005/Atom} означает «только элементы пространства имён Atom». Символ * значит «элементы с любым локальным именем». И [@href] означает «элемент имеет атрибут href».
3. Строка 8. Запрос находит все элементы Atom с атрибутом href, значение которого равно http://diveintomark.org/.
4. Строка 11. После небольшого форматирования строки (иначе составные запросы становятся неимоверно длинными) данный запрос ищет элементы Atom author, имеющие дочерние элементы Atom uri. Запрос возвращает только 2 элемента author: в первом и во втором элементах entry. В последнем элементе entry элемент author содержит только name, uri у него нет.

Вам недостаточно? lxml также имеет встроенную поддержку для выражений XPath 1. 0. Мы не будем детально рассматривать синтаксис XPath, так как это тема для отдельной книги. Но мы рассмотрим пример использования XPath в lxml.

>>> import lxml.etree
>>> tree = lxml.etree.parse('examples/feed.xml')
>>> NSMAP = {'atom': 'http://www.w3.org/2005/Atom'}                    ①
>>> entries = tree.xpath("//atom:category[@term='accessibility']/..",  ②
...     namespaces=NSMAP)
>>> entries                                                            ③
[<Element {http://www.w3.org/2005/Atom}entry at e2b630>]
>>> entry = entries[0]
>>> entry.xpath('./atom:title/text()', namespaces=NSMAP)               ④
['Accessibility is a harsh mistress']

1. Строка 3. Чтобы выполнить XPath запрос элементов из пространства имён, необходимо определить отображение префикса этого пространства имен. На самом деле это обычный словарь Python.
2. Строка 4. А вот и XPath запрос. Данное выражение выполняет поиск элементов category (пространства имён Atom), содержащие атрибут term со значением accessibility. Но это не совсем то, что возвращает запрос. Посмотрите в самый конец строки запроса. Вы заметили символы /..? Это означает, «а затем верни родительский элемент элемента category, которого ты только что нашел». Таким образом, одним XPath запросом мы найдём все элементы entry с дочерними элементами <category term='accessibility'>.
3. Строка 6. Функция xpath() возвращает список объектов ElementTree. В данном документе всего один элемент entry с дочерним элементом category, у которого атрибут term равен значению accessibility.
4. Строка 9. Выражение XPath не всегда возвращает список элементов. Формально, DOM разобранного документа XML не содержит элементов, она содержит узлы (node). В зависимости от типа узлы могут быть элементами, атрибутами или даже текстовым контентом. Результатом запроса XPath всегда является список узлов. Данный запрос возвращает список текстовых узлов: текстовый контент (text()) элемента title (atom:title), который является дочерним элементом текущего элемента (./).

12.7 Создание XML

Поддержка XML в Python не ограничивается только парсингом существующих документов. Вы также можете создавать XML документы «с нуля».

>>> import xml.etree.ElementTree as etree
>>> new_feed = etree.Element('{http://www.w3.org/2005/Atom}feed',     ①
...     attrib={'{http://www.w3.org/XML/1998/namespace}lang': 'en'})  ②
>>> print(etree.tostring(new_feed))                                   ③
<ns0:feed xmlns:ns0='http://www.w3.org/2005/Atom' xml:lang='en'/>

1. Строка 2. Для создания нового элемента необходимо создать объект класса Element. В качестве первого аргумента мы передаём имя элемента (пространство имён + локальное имя). Данное выражение создаёт элемент feed в пространстве Atom. Это будет корневой элемент нашего нового XML документа.
2. Строка 3. Чтобы добавить атрибуты к только что созданному элементу, мы передаём словарь имён атрибутов и их значений во втором аргументе attrib. Обратите внимание, что имена атрибутов должны задаваться в формате ElementTree, {пространство_имён}локальное_имя.
3. Строка 4. В любой момент вы можете сериализовать элемент и его дочерние элементы с помощью функции tostring() библиотеки ElementTree.

Результат сериализации стал для вас неожиданностью? Формально ElementTree сериализует XML элементы правильно, но не оптимально. Пример XML документа в начале главы определял пространство имен по умолчанию (xmlns='http://www.w3.org/2005/Atom'). Определение пространства по умолчанию полезно для документов (таких как фидов Atom), в которых все элементы принадлежат одному пространству имен, поскольку вы можете объявить пространство один раз, а элементы объявлять, используя только их локальные имена (<feed>, <link>, <entry>). Если вы не собираетесь объявлять элементы из другого пространства имён, то нет необходимости использовать префиксы.

Синтаксический анализатор XML не «заметит» разницы между XML документом с пространством имен по умолчанию и документом, использующим префикс пространства имён перед каждым элементом. Итоговая модель DOM этой сериализации

<ns0:feed xmlns:ns0='http://www.w3.org/2005/Atom' xml:lang='en'/>

что идентична модели DOM этой сериализации

<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'/>

Единственная разница заключается в том, что второй вариант на несколько символов короче. Если мы переделаем весь наш пример, используя префикс ns0: в каждом открывающем и закрывающем тегах, это добавило бы 4 символа на открывающий тег × 79 тегов + 4 символа на объявление собственно пространства имён, всего 320 символов. В кодировке UTF-8 это составило бы 320 байт. (После архивации gzip разница уменьшается до 21 байта; однако, 21 байт – это всё еще 21 байт). Возможно, для вас это не имеет значения, но для чего-то, подобного фидам Atom, которые могут скачиваться несколько тысяч раз при каждом изменении, выигрыш нескольких байт на одном запросе может быстро разрастись.

Встроенная библиотека ElementTree не предоставляет тонкого управления над сериализацией элементов в пространствах имен. И тут снова в игру вступает lxml.

>>> import lxml.etree
>>> NSMAP = {None: 'http://www. w3.org/2005/Atom'}                     ①
>>> new_feed = lxml.etree.Element('feed', nsmap=NSMAP)                ②
>>> print(lxml.etree.tounicode(new_feed))                             ③
<feed xmlns='http://www.w3.org/2005/Atom'/>
>>> new_feed.set('{http://www.w3.org/XML/1998/namespace}lang', 'en')  ④
>>> print(lxml.etree.tounicode(new_feed))
<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'/>

1. Строка 2. Для начала определим пространство имён, используя словарь. Значения словаря – это пространства имен; ключи словаря – это задаваемый префикс. Используя объект None в качестве префикса, мы задаем пространство имен по умолчанию.
2. Строка 3. Теперь, при создании элемента, мы можем передать специфичный для lxml аргумент nsmap, используемый для передачи префиксов пространств имён.
3. Строка 4. Как и ожидалось, данная сериализация определяет пространство имён по умолчанию Atom и объявляет элемент feed без префикса пространства имён.
4. Строка 6. Упс, мы забыли добавить атрибут xml:lang. Добавить атрибут к любому элементу всегда можно с помощью метода set(). Он принимает два аргумента: имя атрибута в стандартном формате ElementTree и значение атрибута. (Данный метод не специфичен для библиотеки lxml. Единственная особенность, специфичная для lxml, в данном примере – это аргумент nsmap для управления префиксами пространств имён в сериализованном выводе.)

Разве XML документы ограничиваются только одним элементом в документе? Конечно, нет. Мы так же легко можем создавать дочерние элементы.

>>> title = lxml.etree.SubElement(new_feed, 'title',          ①
...     attrib={'type':'html'})                               ②
>>> print(lxml. etree.tounicode(new_feed))                     ③
<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'><title type='html'/></feed>
>>> title.text = 'dive into &hellip;'                         ④
>>> print(lxml.etree.tounicode(new_feed))                     ⑤
<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'><title type='html'>dive into &amp;hellip;</title></feed>
>>> print(lxml.etree.tounicode(new_feed, pretty_print=True))  ⑥
<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'>
<title type='html'>dive into&amp;hellip;</title>
</feed>

1. Строка 1. Для создания дочернего элемента существующего элемента необходимо создать объект класса SubElement. Обязательные аргументы – это родительский элемент (в данном случае new_feed) и имя нового элемента. Поскольку дочерний элемент наследует пространство имён от родителя, то здесь нет необходимости заново объявлять пространство имён или префикс.
2. Строка 2. Также вы можете передать словарь с атрибутами. Ключи – это имена атрибутов; значения словаря – это значения атрибутов.
3. Строка 3. Как и ожидалось, новый элемент title был создан в пространстве Atom, и он является дочерним элементом элемента feed. Так как элемент title не имеет текстового контента и дочерних элементов, то lxml сериализует его как пустой элемент (с помощью сокращенной записи />).
4. Строка 5. Чтобы добавить текстовый контент в элемент, просто задаём его свойство .text.
5. Строка 6. Теперь элемент title сериализуется со своим текстовым контентом. Если в тексте содержатся символы «меньше чем» или амперсанды, то при сериализации они должны быть экранированы. lxml обрабатывает это экранирование автоматически.
6. Строка 8. При сериализации вы можете применить «красивую печать» (pretty_print), при которой вставляются разрывы строки после закрывающих тегов и после открывающих тегов элементов, содержащих дочерние элементы, но не имеющих текстового контента. С технической точки зрения, lxml добавляет «незначащие пробельные символы», чтобы сделать вывод более читаемым.

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

12.8 Синтаксический анализ «сломанного» XML

Спецификация XML предписывает, что все синтаксические анализаторы XML должны выполнять «драконовскую (строгую) обработку ошибок». То есть, они должны остановиться и выкинуть исключение при обнаружении в XML документе «некорректности» любого типа. Ошибки корректности включают в себя несовпадающие открывающий и закрывающий теги, неопределённые объекты, неправильные символы Юникод и другие эзотерические ситуации. Такая обработка ошибок сильно контрастирует на фоне других известных форматов, например, HTML, – ваш браузер не останавливает отрисовку web-страницы, если вы забыли закрыть HTML тег или экранировать амперсанд в значении атрибута. (Существует распространённое заблуждение, что в HTML не оговорена обработка ошибок. На самом деле, обработка HTML ошибок отлично документирована, но она гораздо сложнее, чем просто «остановиться и выдать аварийное сообщение».)

Некоторые (и я в том числе) считают, что со стороны разработчиков формата XML было ошибкой заставлять так строго обрабатывать ошибки. Не поймите меня неправильно, я, конечно же, за упрощение правил обработки ошибок. Однако на практике понятие «корректности» оказывается коварнее, чем кажется, особенно для XML документов (таких как фиды Atom), которые публикуются в интернете и передаются по протоколу HTTP. Несмотря на зрелость XML, который стандартизовал драконовскую обработку ошибок в 1997, исследования постоянно показывают, что значительная часть фидов Atom в интернете содержат ошибки корректности.

У меня есть и теоретические, и практические причины обрабатывать XML документы «любой ценой», то есть не останавливаться и взрываться при первой ошибке. Если вы окажетесь в похожей ситуации, то lxml может вам помочь.

Ниже приведён фрагмент «битого» XML документа.

<?xml version='1.0' encoding='utf-8'?>
<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'>
  <title>dive into &hellip;</title>
...
</feed>

Здесь есть ошибка, так как последовательность … не определена в формате XML (она определена в HTML). Если попробовать разобрать этот битый фид с настройками по умолчанию, lxml споткнётся на неопределённой последовательности.

>>> import lxml.etree
>>> tree = lxml.etree.parse('examples/feed-broken.xml')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "lxml.etree.pyx", line 2693, in lxml.etree.parse (src/lxml/lxml.etree.c:52591)
  File "parser.pxi", line 1478, in lxml.etree._parseDocument (src/lxml/lxml.etree.c:75665)
  File "parser.pxi", line 1507, in lxml.etree._parseDocumentFromURL (src/lxml/lxml.etree.c:75993)
  File "parser.pxi", line 1407, in lxml.etree._parseDocFromFile (src/lxml/lxml.etree.c:75002)
  File "parser.pxi", line 965, in lxml.etree._BaseParser._parseDocFromFile (src/lxml/lxml.etree.c:72023)
  File "parser.pxi", line 539, in lxml.etree._ParserContext._handleParseResultDoc (src/lxml/lxml.etree.c:67830)
  File "parser.pxi", line 625, in lxml.etree._handleParseResult (src/lxml/lxml.etree.c:68877)
  File "parser.pxi", line 565, in lxml.etree._raiseParseError (src/lxml/lxml.etree.c:68125)
lxml.etree.XMLSyntaxError: Entity 'hellip' not defined, line 3, column 28

Чтобы обработать этот битый XML документ, необходимо создать новый синтаксический анализатор XML.

>>> parser = lxml. etree.XMLParser(recover=True)                  ①
>>> tree = lxml.etree.parse('examples/feed-broken.xml', parser)  ②
>>> parser.error_log                                             ③
examples/feed-broken.xml:3:28:FATAL:PARSER:ERR_UNDECLARED_ENTITY: Entity 'hellip' not defined
>>> tree.findall('{http://www.w3.org/2005/Atom}title')
[<Element {http://www.w3.org/2005/Atom}title at ead510>]
>>> title = tree.findall('{http://www.w3.org/2005/Atom}title')[0]
>>> title.text                                                   ④
'dive into '
>>> print(lxml.etree.tounicode(tree.getroot()))                  ⑤
<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'>
  <title>dive into </title>
.
. [rest of serialization snipped for brevity]
.

1. Строка 1. Чтобы создать новый парсер, инициализируем класс lxml.etree.XMLParser. Он может принимать ряд различных именованных аргументов. В данном случае нас интересует аргумент recover. При присвоении этому аргументу значения True парсер XML будет делать всё, чтобы «восстановить» документ и избавиться от ошибки построения.
2. Строка 2. Чтобы разобрать XML документ новым анализатором, передаём в функцию parse() объект parser в качестве второго аргумента. Обратите внимание, что lxml не выбрасывает исключение при неопределённой последовательности ….
3. Строка 3. Анализатор хранит журнал о найденных ошибках корректности (на самом деле это не зависит от включения восстановления).
4. Строка 8. Так как анализатор не знает, что делать с неопределённым …, то он просто тихо отбрасывает его. Текстовый контент элемента title превращается в ‘dive into ‘.
5. Строка 10. Как видно из сериализации, последовательность … была просто выброшена.

Важно отметить, что нет никакой гарантии совместимости «восстановления» у XML анализаторов. Другой анализатор может быть умнее и распознать, что … является корректной последовательностью HTML, и заменить её на …. «Лучше» ли это? Возможно. Является ли это «более правильным»? Нет, так как оба решения с точки зрения формата XML неверны. Правильное поведение (согласно спецификации XML) – прекратить обработку и выдать исключение. Если же вы решили не следовать спецификации, то вы делаете это на свой страх и риск.

12.9 Материалы для дальнейшего чтения

Источник:

• Mark Pilgrim. Dive Into Python 3

Теги

Сохранить или поделиться

Импорт данных XML — Excel

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

При наличии карты XML сделайте следующее для импорта данных XML в сопоставленные ячейки:

1. В карте XML выберите одну из сопоставленных ячеек.

2. На вкладке Разработчик нажмите кнопку Импорт.

   Если вкладка Разработчик не отображается, см. раздел Отображение вкладки «Разработчик».

3. В диалоговом окне Импорт XML найдите и выберите файл данных XML (XML-файл), который вы хотите импортировать, и нажмите кнопку Импорт.

Другие способы импорта данных XML

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

Импорт файла данных XML в качестве XML-таблицы

1. На вкладке Разработчик нажмите кнопку Импорт.

   Если вкладка Разработчик не отображается, см. раздел Отображение вкладки «Разработчик».

2. В диалоговом окне Импорт XML найдите и выберите файл данных XML (XML-файл), который вы хотите импортировать, и нажмите кнопку Импорт.

   Если файл данных XML не ссылается ни на какую схему, Excel создает ее на основе этого файла.

3. В диалоговом окне Импорт данных выполните одно из следующих действий:

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

   2. Выберите XML-таблицу на новом файле, чтобы импортировать содержимое файла в XML-таблицу на новом файле, начиная с ячейки A1. Карта файла данных XML отобразится в области задач Источник XML.

4. Если файл данных XML не ссылается ни на какую схему, Excel создает ее на основе этого файла.

5. Чтобы управлять поведением данных XML (например, привязки данных, формата и макета), нажмите кнопку «Свойства», чтобы отобразить диалоговое окно свойств карты XML. Например, существующие данные в таком диапазоне будут перезаписаны при импорте данных по умолчанию, но это можно изменить.

Импорт нескольких файлов данных XML

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

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

2. На вкладке Разработчик нажмите кнопку Импорт.

   Если вкладка Разработчик не отображается, см. раздел Отображение вкладки «Разработчик».

3. В диалоговом окне Импорт XML найдите и выберите файл данных XML (XML-файл), который вы хотите импортировать.

   • Если файлы являются смежными, нажмите клавишу SHIFT, а затем щелкните первый и последний файл в списке. Все данные из XML-файлов будут импортированы и добавлены в сопоставленные ячейки.

   • Если файлы не являются смежными, нажмите клавишу CTRL, а затем щелкните все файлы списка, которые вы хотите импортировать.

4. Нажмите кнопку Импорт.

   Если вы выбрали файлы, которые не являются contiguous, появится диалоговое окно <>.xml импортируемых файлов. Выберите карту XML, соответствующую импортируемому файлу данных XML.

   Чтобы использовать одну карту для всех выделенных файлов, которые еще не были импортированы, установите флажок Использовать эту карту XML для всех выбранных файлов этой схемы.

Импорт нескольких файлов данных XML в качестве внешних данных

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

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

1. Если вы используете Excel с подпискойMicrosoft 365, нажмите кнопку Data > Get Data > From File > From XML.

   Если вы используете Excel 2016 или более раннюю версию, на вкладке Данные нажмите кнопку Из других источников, а затем щелкните Из импорта данных XML.

2. Выберите диск, папку или расположение в Интернете, где находится файл данных XML (XML-файл), который вы хотите импортировать.

3. Выберите файл и нажмите кнопку Открыть.

4. В диалоговом окне Импорт данных выберите один из следующих параметров:

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

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

   • На новый лист.    Excel добавляет в книгу новый лист и автоматически помещает данные XML в его левый верхний угол. Если файл данных XML не ссылается ни на какую схему, Excel создает ее на основе этого файла.

5. Чтобы контролировать поведение данных XML, таких как привязка данных, форматирование и макет, нажмите кнопку «Свойства», чтобы отобразить диалоговое окно свойств карты XML. Например, при импорте данных по умолчанию существующие данные в таком диапазоне перезаписываются, но это можно изменить.

Открытие файла данных XML для импорта данных

1. Выберите команду Файл > Открыть.

   Если вы используете Excel 2007, нажмите Microsoft Office кнопку >«Открыть».

2. В диалоговом окне Открытие файла выберите диск, папку или веб-адрес, где расположен нужный файл.  

3. Выберите файл и нажмите кнопку Открыть.

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

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

   • Открыть файл, применив следующую таблицу стилей (выберите одну).    Выберите таблицу стилей, которую вы хотите применить, и нажмите кнопку ОК. Данные XML будут отформатированы в соответствии с выбранным листом стилей.

     Примечание: Данные XML будут открыты в Excel в режиме «только для чтения», что позволяет предотвратить случайное сохранение первоначального исходного файла в формате книги Excel с поддержкой макросов (XLSM). В этом случае схема не создается и вы не можете использовать карту XML.

5. Если появится диалоговое окно «Открытие XML», в XML-файле нет ссылок на таблицу стилей XSLT. Чтобы открыть файл, выберите один из следующих параметров:

   • Щелкните XML-таблица для создания XML-таблицы в новой книге.

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

   • Щелкните «Как книгу, которая будет только для чтения».

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

     Данные XML будут открыты в Excel в режиме «только для чтения», что позволяет предотвратить случайное сохранение первоначального исходного файла в формате книги Excel с поддержкой макросов (XLSM). В этом случае схема не создается и вы не можете использовать карту XML.

   • Щелкните Использовать область задач XML-источника.

     Карта файла данных XML отобразится в области задач Источник XML. Для сопоставления элементов схемы с листом их можно перетащить на лист.

     Если файл данных XML не ссылается ни на какую схему, Excel создает ее на основе этого файла.

Распространенные проблемы при импорте данных XML

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

Указанный XML-файл не ссылается на схему

XML-файл, который вы пытаетесь открыть, не ссылается на схему XML. Для работы с данными XML, содержащимися в файле, Excel требуется схема, основанная на его содержимом. Если такая схема неверна или не отвечает вашим требованиям, удалите ее из книги. Затем создайте файл схемы XML и измените файл данных XML так, чтобы он ссылался на схему. Дополнительные сведения см. в статье Сопоставление XML-элементов с ячейками карты XML.

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

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

1. На вкладке Разработчик выберите команду Источник.

   Если вкладка Разработчик не отображается, см. раздел Отображение вкладки «Разработчик».

2. В области задач Источник XML выберите пункт Карты XML.

3. В диалоговом окне Карты XML щелкните карту XML, созданную Excel ,и нажмите кнопку Удалить.

Возникают проблемы при импорте нескольких XML-файлов, которые используют одно пространство имен, но разные схемы

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

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

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

Отображение вкладки «Разработчик»

Если вкладка Разработчик недоступна, выполните следующие действия, чтобы открыть ее.

См. также

Просмотр XML в Excel

Сопоставление XML-элементов с ячейками карты XML

Экспорт данных XML

Записать, прочитать XML файл из DomDocument

В 1С можно распарсить XML файл с помощью COM объекта «Msxml2.DOMDocument». В зависимости от установленного программного обеспечения, доступны различные версии «Дом документа». Подробно, свойства и методы различных версий DOMDocument описаны в MSDN.

Версии DomDocument
Msxml2.DOMDocument.3.0
Msxml2.DOMDocument.4.0
Msxml2.DOMDocument.5.0
Msxml2.DOMDocument.6.0

Для того чтобы создать или парсить xml, существуют примеры написанные с использованием встроенных объектов (ЗаписьXML, ЧтениеXML) языка программирования 1С. При сложной структуре xml, объём программного кода в таких примерах может быть очень большим. При использовании «Msxml2.DOMDocument» программный код можно сделать более компактным и получить более гибкий механизм обращения к узлам XML документа.

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

Создать, записать XML файл

Функция СоздатьXML()
Попытка
DomDocument = Новый COMОбъект("MSXML2.DOMDocument.6.0"); 
Исключение
Сообщить("Ошибка: объект MSXML2.DOMDocument не создан");
Возврат Ложь;
КонецПопытки;
//Записать объявление XML	
	XML = DomDocument.createProcessingInstruction("xml", "version=""1.0"" encoding=""UTF-8""");  	
DomDocument.insertBefore(XML,);
//Создать корневой узел	
	ElementRootTag = DomDocument.createElement("RootTag");	
//Создать подчиненный узел
	ElementTag = DomDocument.createElement("Tag");	
ElementTag.setAttribute("ИмяАтрибута","ЗначениеАтрибута");	
ElementText = DomDocument.createTextNode("Текст");
ElementTag.appendChild(ElementText);
CDATA = DomDocument.createCDATASection("Значение");
ElementTag.appendChild(CDATA);
//Записать узлы
	ElementRootTag.appendChild(ElementTag);
DomDocument.appendChild(ElementRootTag);
//Записать файл
	DomDocument.Save("C:\Test.xml");
//Сформированный XML текст
	XMLТекст = DomDocument.xml;
КонецФункции 

Прочитать XML файл

Функция СчитатьXML()
Попытка
DomDocument = Новый COMОбъект("MSXML2.DOMDocument.6.0"); 
Исключение
Сообщить("Ошибка: объект MSXML2.DOMDocument не создан");
Возврат Ложь;
КонецПопытки;
//Загрузить XML из строки	
	DomDocument.loadXML("<?xml version=""1.0"" encoding=""UTF-8""?>
|<RootTag>
|<Tag Имя=""Значение"">Текст[CDATA[Значение]]</Tag>
|</RootTag>");
//Загрузить файл XML	
	DomDocument.load("C:\Test.xml");
Если DomDocument.parseError.errorCode <> 0 Тогда
Сообщить("Ошибка: XML файл не валидный");	
Возврат Ложь;
КонецЕсли;
//Выбрать узлы
	Nodes = DomDocument.SelectNodes("Tag");
Для Индекс = 0 По Nodes.Length - 1 Цикл
ЗначениеАтрибута = Nodes.Item(Индекс).getAttribute("ИмяАтрибута");
Tag = Nodes.Item(Индекс);
КонецЦикла;	
КонецФункции 

Похожие статьи:
ЗаписьXML, ЧтениеXML в 1С:Предприятии
Запись, чтение XML из ДокументDOM

XML — Погружение в Python 3

Погружение

Большинство глав в этой книге строятся на отрывках, примерах кода. Но xml это больше данные, нежели код. Один из способов применения xml это «синдикация контента» такого, как последние статьи с блога, форума или других часто обновляемых сайтов. Большинство популярного ПО для ведения блогов может создавать ленты (фиды) и обновлять их, когда новые статьи, темы публикуются. Вы можете следить за блогом подписавшись на его канал, также вы можете следить за несколькими блогами при помощи «программ-агрегаторов» таких, как Google Reader [1]

Итак, ниже представлены XML данные с которыми мы будем работать в этой главе. Это фид формата Atom syndication feed

<?xml version='1.0' encoding='utf-8'?>
<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'>
  <title>dive into mark</title>
  <subtitle>currently between addictions</subtitle>
  <id>tag:diveintomark.org,2001-07-29:/</id>
  <updated>2009-03-27T21:56:07Z</updated>
  <link rel='alternate' type='text/html' href='http://diveintomark.org/'/>
  <link rel='self' type='application/atom+xml' href='http://diveintomark.org/feed/'/>
  <entry>
    <author>
      <name>Mark</name>
      <uri>http://diveintomark.org/</uri>
    </author>
    <title>Dive into history, 2009 edition</title>
    <link rel='alternate' type='text/html'
      href='http://diveintomark.org/archives/2009/03/27/dive-into-history-2009-edition'/>
    <id>tag:diveintomark.org,2009-03-27:/archives/20090327172042</id>
    <updated>2009-03-27T21:56:07Z</updated>
    <published>2009-03-27T17:20:42Z</published>
    <category scheme='http://diveintomark.org' term='diveintopython'/>
    <category scheme='http://diveintomark.org' term='docbook'/>
    <category scheme='http://diveintomark.org' term='html'/>
  <summary type='html'>Putting an entire chapter on one page sounds
    bloated, but consider this &amp;mdash; my longest chapter so far
    would be 75 printed pages, and it loads in under 5 seconds&amp;hellip;
    On dialup.</summary>
  </entry>
  <entry>
    <author>
      <name>Mark</name>
      <uri>http://diveintomark.org/</uri>
    </author>
    <title>Accessibility is a harsh mistress</title>
    <link rel='alternate' type='text/html'
      href='http://diveintomark.org/archives/2009/03/21/accessibility-is-a-harsh-mistress'/>
    <id>tag:diveintomark.org,2009-03-21:/archives/20090321200928</id>
    <updated>2009-03-22T01:05:37Z</updated>
    <published>2009-03-21T20:09:28Z</published>
    <category scheme='http://diveintomark.org' term='accessibility'/>
    <summary type='html'>The accessibility orthodoxy does not permit people to
      question the value of features that are rarely useful and rarely used.</summary>
  </entry>
  <entry>
    <author>
      <name>Mark</name>
    </author>
    <title>A gentle introduction to video encoding, part 1: container formats</title>
    <link rel='alternate' type='text/html'
      href='http://diveintomark.org/archives/2008/12/18/give-part-1-container-formats'/>
    <id>tag:diveintomark.org,2008-12-18:/archives/20081218155422</id>
    <updated>2009-01-11T19:39:22Z</updated>
    <published>2008-12-18T15:54:22Z</published>
    <category scheme='http://diveintomark.org' term='asf'/>
    <category scheme='http://diveintomark.org' term='avi'/>
    <category scheme='http://diveintomark.org' term='encoding'/>
    <category scheme='http://diveintomark.org' term='flv'/>
    <category scheme='http://diveintomark.org' term='GIVE'/>
    <category scheme='http://diveintomark.org' term='mp4'/>
    <category scheme='http://diveintomark.org' term='ogg'/>
    <category scheme='http://diveintomark.org' term='video'/>
    <summary type='html'>These notes will eventually become part of a
      tech talk on video encoding.</summary>
  </entry>
</feed>

5-минутное введение в XML

Если Вы уже знакомы с XML, то можете пропустить эту главу.

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

① Это открывающий (начальный) тег элемента foo.

② Это соответствующий закрывающий (конечный) тег элемента foo. Как в математике и языках программирования каждая открывающая скобка должна иметь соответствующую закрывающую, в XML каждый открывающий тег должен быть закрыт соответствующим закрывающим.

Элементы могут быть неограниченно вложены друг в друга. Так как элемент bar вложен в элемент foo, то его называют подэлементом или дочерним элементом элемента foo.

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

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

<foo lang='en'>                          ①
  <bar lang="fr"></bar>  ②
</foo>

① Элемент foo имеет один атрибут именованный как lang. Значению атрибута lang присваивается строка en.

② Элемент bar имеет два атрибута: id и lang. Значение lang есть fr. Это не приводит к конфликту с атрибутом lang элемента foo, так как каждый элемент имеет свой набор атрибутов.

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

Элементы могут иметь текст (текстовое содержание).

<foo lang='en'>
  <bar lang='fr'>PapayaWhip</bar>
</foo>

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

Существует сокращённая запись пустого элемента. Поместив знак дроби / в конце открывающего тега, вы можете пропустить закрывающий тег. XML документ предыдущего примера с пустым элементов может быть записан следующим образом:

Подобно тому как функции Python могут быть объявлены в разных модулях, XML элементы могут быть объявлены в разных пространствах имён (namespaces). Пространства имён обычно выглядят как URL-пути. Для объявления пространства имён по умолчанию используется директива xmlns. Объявление пространства имён очень похоже на атрибут, но имеет специальное значение.

<feed xmlns='http://www.w3.org/2005/Atom'>  ①
  <title>dive into mark</title>             ②
</feed>

① Элемент feed находится в пространстве имён http://www.w3.org/2005/Atom.

② Элемент title также находится в пространстве имён http://www.w3.org/2005/Atom. Пространство имён применяется как к элементу в котором оно было определено так и ко всем дочерним элементам.

Вы можете объявлять пространство имён xmlns:prefix и ставить ему в соответствие префикс prefix. Тогда каждый элемент в данном пространстве имён должен быть явно объявлен с указанием префикса prefix.

<atom:feed xmlns:atom='http://www.w3.org/2005/Atom'>  ①
  <atom:title>dive into mark</atom:title>             ②
</atom:feed>

① Элемент feed находится в пространстве имён http://www.w3.org/2005/Atom.

② Элемент title также находится в пространстве имён http://www.w3.org/2005/Atom.

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

И, наконец, XML документы могут содержать информацию о кодировке символов в первой строке до корневого элемента. (Если Вам интересно как документ может содержать информацию которая должна быть известна XML-анализатору до анализа XML документа, то смотрите Catch-22 раздел F XML спецификации)

<?xml version='1.0' encoding='utf-8'?>

Теперь Вы знаете об XML достаточно чтобы «вынести» следующие разделы главы!

Структура формата синдикации фида Atom

Рассмотрим блог (weblog) или любой сайт с часто обновляемым контентом, например CNN.com. Сайт содержит заголовок («CNN.com»), подзаголовок («Breaking News, U.S., World, Weather, Entertainment & Video News»), дату последнего изменения («обновлено 12:43 p.m. EDT, Sat May 16, 2009») и список статей опубликованных в разное время. Каждая статья в свою очередь также имеет заголовок, дату первой публикации (и, возможно, дату последнего обновления, в случае если статья была корректирована) и уникальный URL.

Формат синдикации Atom разработан с целью хранить информацию подобного рода стандартным образом. Мой блог и CNN.com абсолютно разные по дизайну, содержанию и посетителям сайты, но оба имеют сходную структуру. Оба сайта имеют заголовки и публикуют статьи.

На верхнем уровне фид Atom должен иметь корневой элемент по имени feed находящийся в пространстве имен http://www.w3.org/2005/Atom.

<feed xmlns='http://www.w3.org/2005/Atom'  ①
      xml:lang='en'>                       ②

① http://www.w3.org/2005/Atom — пространство имён Atom

② Каждый элемент может содержать атрибут xml:lang который определяет язык элемента и его дочерних элементов. В данном случае атрибут xml:lang объявленный в корневом элементе задаёт английский язык для всего фида.

Фид Atom содержит дополнительную информацию о себе в дочерних элементах корневого элемента:

<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'>
  <title>dive into mark</title>                                             ①
  <subtitle>currently between addictions</subtitle>                         ②
  <id>tag:diveintomark.org,2001-07-29:/</id>                                ③
  <updated>2009-03-27T21:56:07Z</updated>                                   ④
  <link rel='alternate' type='text/html' href='http://diveintomark.org/'/>  ⑤

① Заголовок title содержит текст ‘dive into mark’.

② Подзаголовок subtitle фида есть строка ‘currently between addictions’.

③ Каждый фид должен иметь глобальный уникальный идентификатор. RFC 4151 содержит информацию как создавать такие идентификаторы.

④ Данный фид был обновлён последний раз 27 марта 2009 в 21:56 GMT. Обычно элемент updated эквивалентен дате последнего изменения какой-либо из статей на сайте.

⑤ А вот здесь начинается самое интересное. Элемент ссылки link не имеет текстового содержания, но имеет три атрибута: rel, type и href. Значение атрибута rel говорит о том какого типа ссылка. rel=’alternate’ значит, что это альтернативная ссылка этого фида. Атрибут type=’text/html’ говорит, что это ссылка на HTML страницу. И, собственно, путь ссылки содержится в атрибуте href.

Теперь мы знаем, что представленный выше фид получен с сайта «dive into mark». Сайт доступен по адресу http://diveintomark.org/ и последний раз был обновлён 27 марта 2009.

Продолжим дальше рассматривать строение фида: после метаинформации о фиде идёт список последних статей. Статья выглядит следующим образом:

<entry>
  <author>                                                                 ①
    <name>Mark</name>
    <uri>http://diveintomark.org/</uri>
  </author>
  <title>Dive into history, 2009 edition</title>                           ②
  <link rel='alternate' type='text/html'                                   ③
    href='http://diveintomark.org/archives/2009/03/27/dive-into-history-2009-edition'/>
  <id>tag:diveintomark.org,2009-03-27:/archives/20090327172042</id>        ④
  <updated>2009-03-27T21:56:07Z</updated>                                  ⑤
  <published>2009-03-27T17:20:42Z</published>
  <category scheme='http://diveintomark.org' term='diveintopython'/>       ⑥
  <category scheme='http://diveintomark.org' term='docbook'/>
  <category scheme='http://diveintomark.org' term='html'/>
  <summary type='html'>Putting an entire chapter on one page sounds        ⑦
    bloated, but consider this &amp;mdash; my longest chapter so far
    would be 75 printed pages, and it loads in under 5 seconds&amp;hellip;
    On dialup.</summary>
</entry>                                                                   ⑧

① Элемент author сообщает о том, кто написал статью: некоторый парень по имени Марк (Mark), который валяет дурака на сайте http://diveintomark.org/ (В данном случае ссылка на сайт автора совпадает с альтернативной ссылкой в метаинформации о фиде, но это не всегда правда, так как многие блоги имеют несколько авторов, у каждого из которых — свой сайт.)

② Элемент title содержит заголовок статьи «Dive into history, 2009 edition».

③ Как и с альтернативной ссылкой на фид, в элементе link находится адрес HTML версии данной статьи.

④ Элемент entry, подобно фидам, имеет уникальный идентификатор.

⑤ Элемент entry имеет две даты: дату первой публикации и дату последнего изменения.

⑥ Элементы entry могут иметь произвольное количество категорий category. Рассматриваемая статья попадёт в категории diveintopython, docbook и html.

⑦ Элемент summary даёт краткий обзор статьи. (Бывает также не представленный здесь элемент содержания content предназначенный для включения в фид полного текста статьи.) Данный элемент summary содержит специфичный для фидов Atom атрибут type=’html’ указывающий что содержимое элемента есть текст в формате HTML. Это важно, так как HTML-объекты &mdash; и &hellip; присутствующие в элементе должны отображаться как «—» и «…», а не печататься «как есть».

⑧ И, наконец, закрывающий тег элемента entry говорит о конце метаданных для этой статьи.

Синтаксический разбор XML

В Python документы XML могут быть обработаны c использованием разных библиотек. Язык имеет обычные синтаксические анализаторы DOM и SAX, но я буду использовать другую библиотеку ElementTree.

>>> import xml.etree.ElementTree as etree    ①
>>> tree = etree.parse('examples/feed.xml')  ②
>>> root = tree.getroot()                    ③
>>> root                                     ④
<Element {http://www.w3.org/2005/Atom}feed at cd1eb0>

① Модуль ElementTree входит в стандартную библиотеку Python, путь для импорта xml.etree.ElementTree.

② Функция parse() — это базовая функция модуля ElementTree. Функция принимает имя файла или файлоподобный объект. Эта функция выполняет синтаксическй анализ документа за раз. Если разрабатываемая программа должна экономить память, то можно анализировать XML документ частями.

③ Функция parse() возращает объект, который является представлением всего документа. Однако объект tree не является корневым элементом. Чтобы получить ссылку на корневой элемент, необходимо вызвать метод getroot().

④ Как и следовало ожидать, корневой элемент есть элемент фида в пространстве имён http://www.w3.org/2005/Atom. Строковое представление объекта root ещё раз подчёркивает важный момент: XML элемент — это комбинация пространства имён и его имени-тега (так же называемого локальным именем). Каждый элемент в данном документе находится в пространстве Atom, поэтому корневой элемент представлен как {http://www.w3.org/2005/Atom}feed.

Элементы XML есть списки Python

В API ElementTree элементы представляются встроенным типом Python — списком. Каждый из элементов списка представляет собой дочерние XML элементы.

# продолжение предыдущего примера
>>> root.tag                        ①
'{http://www.w3.org/2005/Atom}feed'
>>> len(root)                       ②
8
>>> for child in root:              ③
...   print(child)                  ④
...
<Element {http://www.w3.org/2005/Atom}title at e2b5d0>
<Element {http://www.w3.org/2005/Atom}subtitle at e2b4e0>
<Element {http://www.w3.org/2005/Atom}id at e2b6c0>
<Element {http://www.w3.org/2005/Atom}updated at e2b6f0>
<Element {http://www.w3.org/2005/Atom}link at e2b4b0>
<Element {http://www.w3.org/2005/Atom}entry at e2b720>
<Element {http://www.w3.org/2005/Atom}entry at e2b510>
<Element {http://www.w3.org/2005/Atom}entry at e2b750>

① Продолжим предыдущий пример: корневой элемент root — {http://www.w3.org/2005/Atom}feed

② «Длина» корневого элемента есть количество дочерних элементов root.

③ Вы можете использовать элемент как итератор по всем дочерним элементам.

④ Из сообщений видно, что в элементе root 8 дочерних элементов: 5 элементов с метаинформацией о фиде (title, subtitle, id, updated и link) и 3 элемента со статьями entry.

Вы, должно быть, уже догадались, но я хочу явно указать на следующее: список дочерних элементов содержит только прямые дочерние элементы. В свою очередь каждый дочерний элемент entry может содержать свои дочерние элементы, но они не будут включены в список. Они будут включены в список элемента entry, а не в список подэлементов элемента feed. Найти определённые элементы любого уровня вложенности можно несколькими способами; ниже мы рассмотрим 2 из них.

Атрибуты XML есть словари Python

Напомним, что документ XML это не только набор элементов; каждый элемент так же имеет набор атрибутов. Имея конкретный XML элемент, Вы можете легко получить его атрибуты как словарь Python.

# продолжение предыдущего примера
>>> root.attrib                           ①
{'{http://www.w3.org/XML/1998/namespace}lang': 'en'}
>>> root[4]                               ②
<Element {http://www.w3.org/2005/Atom}link at e181b0>
>>> root[4].attrib                        ③
{'href': 'http://diveintomark.org/',
 'type': 'text/html',
 'rel': 'alternate'}
>>> root[3]                               ④
<Element {http://www.w3.org/2005/Atom}updated at e2b4e0>
>>> root[3].attrib                        ⑤
{}

① Свойство attrib возращает словарь атрибутов элемента. Исходная разметка XML была следующая <feed xmlns=’http://www.w3.org/2005/Atom’ xml:lang=’en’>. Префикс xml: ссылается на стандартное пространство имён, которое любой XML документ может использовать без объявления.

② Пятый подэлемент есть элемент link (используется индекс [4], так как списки Python индексируются начиная с 0).

③ Подэлемент link имеет три атрибута href, type и rel.

④ Четвёртый подэлемент (с индексом [3] в списке начинающемся с 0) — это элемент updated.

⑤ Подэлемент updated не имеет атрибутов, следовательно свойство .attrib возращает пустой словарь.

Поиск узлов в XML документе

До настоящего момента мы рассматривали XML документ «сверху вниз», начиная с корневого элемента, далее к его дочерним элементы и так вглубь всего документа. Однако во многих случаях при работе с XML Вам необходимо искать конкретные элементы. Etree справится и с этой задачей.

>>> import xml.etree.ElementTree as etree
>>> tree = etree.parse('examples/feed.xml')
>>> root = tree.getroot()
>>> root.findall('{http://www.w3.org/2005/Atom}entry')    ①
[<Element {http://www.w3.org/2005/Atom}entry at e2b4e0>,
 <Element {http://www.w3.org/2005/Atom}entry at e2b510>,
 <Element {http://www.w3.org/2005/Atom}entry at e2b540>]
>>> root.tag
'{http://www.w3.org/2005/Atom}feed'
>>> root.findall('{http://www.w3.org/2005/Atom}feed')     ②
[]
>>> root.findall('{http://www.w3.org/2005/Atom}author')   ③
[]

① Метод findall() выполняет поиск дочерних элементов удовлетворяющих запросу. (Формат запроса рассматривается ниже.)

② Все элементы (включая корневой и дочерние) имеют метод findall(). Метод находит все элементы среди дочерних соответствующие запросу. Почему же метод вернул пустой список? Хотя это может показаться неочевидным, данный запрос ищет только в дочерних элементах. Так как корневой элемент feed не имеет дочерних элементов по имени feed, то запрос возвращает пустой список.

③ Этот результат также может Вас удивить. В документе XML действительно есть элемент author; на самом деле, их даже три (по одному в каждом элементе entry). Но эти элементы author не являются прямыми подэлементами (direct children) корневого элемента; они — «подподэлементы» (подэлементы подэлемента). Если Вам нужно найти элементы author любого уровня вложенности, то придётся изменить строку запроса.

>>> tree.findall('{http://www.w3.org/2005/Atom}entry')    ①
[<Element {http://www.w3.org/2005/Atom}entry at e2b4e0>,
 <Element {http://www.w3.org/2005/Atom}entry at e2b510>,
 <Element {http://www.w3.org/2005/Atom}entry at e2b540>]
>>> tree.findall('{http://www.w3.org/2005/Atom}author')   ②
[]

① Для удобства объект tree (который возвращает функция etree.parse()) имеет несколько методов идентичных методам корневого элемента. Результаты функции такие же как при вызове метода tree.getroot().findall().

② Наверное, удивлены, однако этот запрос не находит элемента author в данном документе. Почему же? Потому что, этот вызов идентичен вызову tree.getroot().findall(‘{http://www.w3.org/2005/Atom}author’), что значит «найти все элементы author, которые являются подэлементами корневого элемента». Элементы author не являются дочерними для корневого элемента; они подэлементы элементов entry. Таким образом, при выполнении запроса совпадений не найдено.

Помимо метода findall() есть метод find() который возвращает только первый найденный элемент. Метод может быть полезен в случаях когда в результате поиска Вы ожидаете только один элемент или Вам важен только первый элемент из списка найденных.

>>> entries = tree.findall('{http://www.w3.org/2005/Atom}entry')           ①
>>> len(entries)
3
>>> title_element = entries[0].find('{http://www.w3.org/2005/Atom}title')  ②
>>> title_element.text
'Dive into history, 2009 edition'
>>> foo_element = entries[0].find('{http://www.w3.org/2005/Atom}foo')      ③
>>> foo_element
>>> type(foo_element)
<class 'NoneType'>

① Как Вы видели в предыдущем примере findall() возвращает список элементов atom:entry.

② Метод find() принимает запрос ElementTree и возвращает первый удовлетворяющий запросу элемент.

③ Во элементе foo отсутствуют дочерние элементы, поэтому find() возвращает объект None.

Рассмотрим поиск внутри дочерних элементов, т.е подэлементов, подподэлементов и так далее любого уровня вложенности.

>>> all_links = tree.findall('//{http://www.w3.org/2005/Atom}link')  ①
>>> all_links
[<Element {http://www.w3.org/2005/Atom}link at e181b0>,
 <Element {http://www.w3.org/2005/Atom}link at e2b570>,
 <Element {http://www.w3.org/2005/Atom}link at e2b480>,
 <Element {http://www.w3.org/2005/Atom}link at e2b5a0>]
>>> all_links[0].attrib                                              ②
{'href': 'http://diveintomark.org/',
 'type': 'text/html',
 'rel': 'alternate'}
>>> all_links[1].attrib                                              ③
{'href': 'http://diveintomark.org/archives/2009/03/27/dive-into-history-2009-edition',
 'type': 'text/html',
 'rel': 'alternate'}
>>> all_links[2].attrib
{'href': 'http://diveintomark.org/archives/2009/03/21/accessibility-is-a-harsh-mistress',
 'type': 'text/html',
 'rel': 'alternate'}
>>> all_links[3].attrib
{'href': 'http://diveintomark.org/archives/2008/12/18/give-part-1-container-formats',
 'type': 'text/html',
 'rel': 'alternate'}

① Этот запрос — //{http://www.w3.org/2005/Atom}link — очень похож на запросы из предыдущих примеров. Отличие заключается в двух символах косой черты // в начале строки запроса. Символы // обозначают «Я хочу найти все элементы независимо от уровня вложенности, а не только непосредственные дочерние элементы». Поэтому метод возвращает список из четырёх элементов, а не из одного.

② Первый элемент результата — прямой подэлемент корневого элемента. Как мы видим из его атрибутов, это альтернативная ссылка уровня фида, которая указывает на html версию вебсайта на котором располагается фид.

③ Остальные три элемента результата есть альтернативные ссылки уровня элементов entry. Каждый из элементов entry имеет по одному подэлементу link. Так как запрос findall() содержал символы двойной черты в начале запроса, то результат поиска содержит все подэлементы link.

В целом, метод findall() библиотеки ElementTree довольно мощный инструмент поиска, однако формат запроса может быть немного непредсказуем. Официально формат запросов ElementTree описан как «ограниченная поддержка выражений XPath». XPath это стандарт организации W3C для построения запросов поиска внутри XML документа. С одной стороны формат запросов ElementTree достаточно похож на формат XPath для выполнения простейших поисков. С другой стороны он отличается настолько, что может начать раздражать если Вы уже знаете XPath. Далее мы рассмотрим сторонние библиотеки XML позволяющие расширить API ElementTree до полной поддержки стандарта XPath.

Работаем с LXML

lxml это сторонняя библиотека с открытым кодом основанная на известном синтаксическом анализаторе libxml2. Библиотека обеспечивает стопроцентную совместимость с API ElementTree, полностью поддерживает XPath 1.0 и имеет несколько других приятных фишек. Для Windows можно скачать инсталлятор; пользователям Linux следует проверить наличие скомпилированных пакетов в репозиториях дистрибутива (например, используя инструменты yum или apt-get). В противном случае придётся устанавливать lxml вручную.

>>> from lxml import etree                   ①
>>> tree = etree.parse('examples/feed.xml')  ②
>>> root = tree.getroot()                    ③
>>> root.findall('{http://www.w3.org/2005/Atom}entry')  ④
[<Element {http://www.w3.org/2005/Atom}entry at e2b4e0>,
 <Element {http://www.w3.org/2005/Atom}entry at e2b510>,
 <Element {http://www.w3.org/2005/Atom}entry at e2b540>]

① При импорте lxml предоставляет абсолютно такой же API как встроенная библиотека ElementTree.

② Функция parse(): такая же как в ElementTree.

③ Метод getroot(): такой же.

④ Метод findall(): точно такой же.

При обработке больших XML документов lxml значительно быстрее чем встроенная библиотека ElementTree. Если Вы используете функции только из API ElementTree и хотите чтобы обработка выполнялась как можно быстрее, то можно попробовать импортировать библиотеку lxml и, в случае её отсутствия, использовать ElementTree.

try:
    from lxml import etree
except ImportError:
    import xml.etree.ElementTree as etree

Однако, lxml не только быстрее чем ElementTree: метод findall() поддерживает более сложные запросы.

>>> import lxml.etree                                                                   ①
>>> tree = lxml.etree.parse('examples/feed.xml')
>>> tree.findall('//{http://www.w3.org/2005/Atom}*[@href]')                             ②
[<Element {http://www.w3.org/2005/Atom}link at eeb8a0>,
 <Element {http://www.w3.org/2005/Atom}link at eeb990>,
 <Element {http://www.w3.org/2005/Atom}link at eeb960>,
 <Element {http://www.w3.org/2005/Atom}link at eeb9c0>]
>>> tree.findall("//{http://www.w3.org/2005/Atom}*[@href='http://diveintomark.org/']")  ③
[<Element {http://www.w3.org/2005/Atom}link at eeb930>]
>>> NS = '{http://www.w3.org/2005/Atom}'
>>> tree.findall('//{NS}author[{NS}uri]'.format(NS=NS))                                 ④
[<Element {http://www.w3.org/2005/Atom}author at eeba80>,
 <Element {http://www.w3.org/2005/Atom}author at eebba0>]

① В этом примере я импортирую объект lxml.etree (вместо объекта etree: from lxml import etree) чтобы подчеркнуть, что описываемые возможности реализуемы только с lxml.

② Этот запрос найдёт все элементы в пространстве имён Atom (любой вложенности), которые имеют атрибут href. Символы // в начале запроса обозначают «элементы любой вложенности, а не только потомки корневого элемента». {http://www.w3.org/2005/Atom} обозначает «только элементы пространства имён Atom». Символ * значит «элементы с любым локальным именем». И [@href] обозначает «элемент имеет атрибут href».

③ В результате запроса найдены все элементы Atom с атрибутом href равным http://diveintomark.org/.

④ После преобразования строки (иначе эти запросы становятся неимоверно длинны) данный запрос ищет элементы Atom author имеющие подэлементы Atom uri. Запрос возвращает только 2 элемента author: в первом и во втором элементах entry. В последнем элементе entry элемент author содержит только имя name, но не uri.

Вам мало? lxml имеет встроенную поддержку для выражений XPath 1.0. Мы не будем детально рассматривать синтаксис XPath, так как это тема для отдельной книги. Однако мы рассмотрим пример использования XPath в lxml.

>>> import lxml.etree
>>> tree = lxml.etree.parse('examples/feed.xml')
>>> NSMAP = {'atom': 'http://www.w3.org/2005/Atom'}                    ①
>>> entries = tree.xpath("//atom:category[@term='accessibility']/..",  ②
...     namespaces=NSMAP)
>>> entries                                                            ③
[<Element {http://www.w3.org/2005/Atom}entry at e2b630>]
>>> entry = entries[0]
>>> entry.xpath('./atom:title/text()', namespaces=NSMAP)               ④
['Accessibility is a harsh mistress']

① Чтобы выполнить XPath запрос элементов из пространства имён, необходимо определить отображение префикса этого пространства. На самом деле это обычный словарь Python.

② А вот и XPath запрос. Данное выражение выполняет поиск элементов category (пространства имён Atom) содержащие атрибут с парой имя-значение term=’accessibility’. Но это не совсем то, что возвращает запрос. Вы заметили символы /.. в конце строки запроса? Это обозначает «верни не найденный элемент, а его родителя». И так, одним запросом мы найдём все элементы entry с дочерними элементами <category term=’accessibility’>.

③ Функция xpath() возвращает список объектов ElementTree. В анализируемом документе всего один элемент entry с атрибутом term=’accessibility’.

④ Выражение XPath не всегда возвращает список элементов. Формально, DOM разобранного документа XML не содержит элементов, она содержит узлы (nodes). В зависимости от их типа узлы могут быть элементами, атрибутами или даже текстом. Результатом запроса XPath всегда является список узлов. Этот запрос возвращает список текстовых узлов: текст text() элемента title (atom:title) есть подэлемент текущего элемента (./).

Создание XML

ElementTree умеет не только разбирать существующие XML документы, но и создавать их «с нуля».

>>> import xml.etree.ElementTree as etree
>>> new_feed = etree.Element('{http://www.w3.org/2005/Atom}feed',     ①
...     attrib={'{http://www.w3.org/XML/1998/namespace}lang': 'en'})  ②
>>> print(etree.tostring(new_feed))                                   ③
<ns0:feed xmlns:ns0='http://www.w3.org/2005/Atom' xml:lang='en'/>

① Для создания нового элемента необходимо создать объект класса Element. В качестве первого параметра в конструктор мы передаём имя элемента (пространство имён и локальное имя). Данное выражение создаёт элемент feed в пространстве Atom. Этот будет корневой элемент нашего нового документа XML.

② Для того чтобы добавить атрибуты к создаваемому элементу мы передаём словарь имён атрибутов и их значений в втором аргументе attrib. Заметьте, что имена атрибутов должны задаваться в формате ElementTree {пространство_имён}локальное_имя.

③ В любой момент Вы можете сериализовать элемент и его подэлементы используя функцию tostring() библиотеки ElementTree.

Вы удивлены результату сериализации new_feed? Формально ElementTree сериализует XML элементы правильно, но не оптимально. Пример XML документа в начале главы определён в пространстве по умолчанию xmlns=’http://www.w3.org/2005/Atom’. Определение пространства по умолчанию полезно для документов (например, фидов Atom), где все элементы принадлежат одному пространству, то есть Вы можете объявить пространство один раз, а на элементы ссылаться используя локальное имя (<feed>, <link>, <entry>). Если Вы не собираетесь объявлять элементы из другого пространства имён, то нет необходимости использовать префикс пространства по умолчанию.

Синтаксический анализатор XML не «заметит» разницы между документом XML с пространством по умолчанию и документом с использованием префикса пространства имён перед каждым элементом. Результирующая модель DOM данной сериализации выглядит как

<ns0:feed xmlns:ns0='http://www.w3.org/2005/Atom' xml:lang='en'/>

что равнозначно

<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'/>

Единственная разница в том, что второй вариант на несколько символов короче. Если мы переделаем наш пример с использованием префикса ns0: в каждом открывающем и закрывающем тэгах, это добавило бы 4 символа на открывающий тэг × 79 тэгов + 4 символа на объявление собственно пространства имён, всего 320 символов. В кодировке UTF-8 это составило бы 320 байт. (После архивации gzip разница уменьшается до 21 байта; однако 21 байт это 21 байт). Возможно, Вы бы не обратили внимания на эти десятки байтов, но для фидов Atom, которые загружаются тысячу раз при изменении, выигрыш нескольких байт на одном запросе быстро превращается в килобайты.

Ещё одно преимущество lxml: в отличие от стандартной библиотеки ElementTree lxml предоставляет более тонкое управление сериализацией элементов.

>>> import lxml.etree
>>> NSMAP = {None: 'http://www.w3.org/2005/Atom'}                     ①
>>> new_feed = lxml.etree.Element('feed', nsmap=NSMAP)                ②
>>> print(lxml.etree.tounicode(new_feed))                             ③
<feed xmlns='http://www.w3.org/2005/Atom'/>
>>> new_feed.set('{http://www.w3.org/XML/1998/namespace}lang', 'en')  ④
>>> print(lxml.etree.tounicode(new_feed))
<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'/>

① Для начала определим пространство имён используя словарь. Значения словаря и есть пространство имён; ключи словаря — задаваемый префикс. Используя объект None в качестве префикса мы задаём пространство имён по умолчанию.

② При создании элемента мы передаём специфичный для lxml аргумент nsmap, используемый для передачи префиксов пространств имён.

③ Как и ожидали, при сериализации определено пространство имён по умолчанию Atom и объявлен один элемент feed без префикса пространства имён.

④ Опа, мы забыли добавить атрибут xml:lang. Используя метод set(), можно всегда добавить атрибут к любому элементу. Метод принимает два аргумента: имя атрибута в стандартном формате ElementTree и значение атрибута. (Данный метод есть и в библиотеке ElementTree. Единственное отличие lxml и ElementTree в данном примере это передача аргумента nsmap для указания префиксов пространств имён.)

Разве наши документы ограничены только одним элементом? Конечно, нет. Мы можем запросто создать дочерние элементы.

>>> title = lxml.etree.SubElement(new_feed, 'title',          ①
...     attrib={'type':'html'})                               ②
>>> print(lxml.etree.tounicode(new_feed))                     ③
<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'><title type='html'/></feed>
>>> title.text = 'dive into &hellip;'                         ④
>>> print(lxml.etree.tounicode(new_feed))                     ⑤
<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'><title type='html'>dive into &amp;hellip;</title></feed>
>>> print(lxml.etree.tounicode(new_feed, pretty_print=True))  ⑥
<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'>
<title type='html'>dive into&amp;hellip;</title>
</feed>

① Для создания подэлемента существующего элемента необходимо создать объект класса SubElement. В конструктор класса передаются элемент родителя (в данном случае new_feed) и имя нового элемента. Мы не объявляем заново пространство имён для создаваемого потомка, так как он наследует пространство имён от родителя.

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

③ Неудивительно, что новый элемент title был создан в пространстве Atom и является подэлементом элемента feed. Так как элемент title не имеет текстового содержания и подэлементов, то lxml сериализует его как пустой элемент и закрывает символами />.

④ Для того чтобы добавить текстовое содержание, мы задаём свойство .text.

⑤ Теперь элемент title сериализуется с только что заданным текстовым содержанием. Если в тексте содержатся знаки «меньше чем» < или «амперсанд» ‘, то при сериализации они должны быть экранированы escape-последовательностью. Такие ситуации lxml обрабатывает автоматически.

⑥ При сериализации Вы можете применить «приятную печать» («pretty printing»), при которой вставляется разрыв строки после закрывающего тэга или открывающего тэга элементов с подэлементами но без текстового содержания. С технической точки зрения lxml добавляет незначащие пробелы и переносы строк («insignificant whitespace») чтобы вывести XML более читаемым.

Синтаксический разбор нецелых XML

XML спецификация предписывает, что все XML синтаксические анализаторы должны выполнять «драконову (строгую) обработку ошибок». То есть, при обнаружении в XML документе формальной ошибки или не«правильнопостроенности» (wellformedness) анализаторы должны сразу же прервать анализ и «вспыхнуть». Ошибки правильнопостроенности включают несогласованность открывающих и закрывающих тэгов, неопределённые элементы, неправильные символы Юникод и другие эзотерические ситуации. Такая обработка ошибок сильно контрастирует на фоне других известных форматов, например, HTML — браузер не останавливается отрисовывать web-страницу если в странице забыт закрывающий HTML тэг или значение атрибута тэга содержит неэкранированный амперсанд. (Существует распространённое заблуждение, что в формате HTML не оговорена обработка ошибок. На самом деле, обработка HTML ошибок отлично документирована, но она гораздо сложнее чем просто «остановиться и загореться на первой ошибке».)

Некоторые считают (и я в том числе), что это было ошибкой со стороны разработчиков формата XML заставлять так строго обрабатывать ошибки. Не поймите меня неправильно, я конечно же за упрощение правил обработки ошибок. Однако, на практике понятие «правильнопостроенности» оказывается коварнее чем кажется, особенно для XML документов которые публикуются в интернете и передаются по протоколу HTTP (например, фиды Atom). Несмотря на зрелость XML, который стандартизовал драконову обработку ошибок в 1997, исследования постоянно показывают, что значительная часть фидов Atom в интернете содержат ошибки правильнопостроенности.

Итак, у меня есть и теоретические и практические причины обрабатывать XML документы «любой ценой», то есть не останавливаться и взрываться при первой ошибке. Если Вы окажетесь в похожей ситуации, то lxml может помочь.

Ниже приведён фрагмент «битого» XML документа.

<?xml version='1.0' encoding='utf-8'?>
<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'>
  <title>dive into &hellip;</title>
...
</feed>

В фиде ошибка, так как последовательность &hellip; не определена в формате XML (она определена в HTML). Если попробовать разобрать битый фид с настройками по умолчанию, то lxml споткнётся на неопределённом вхождении hellip.

>>> import lxml.etree
>>> tree = lxml.etree.parse('examples/feed-broken.xml')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "lxml.etree.pyx", line 2693, in lxml.etree.parse (src/lxml/lxml.etree.c:52591)
  File "parser.pxi", line 1478, in lxml.etree._parseDocument (src/lxml/lxml.etree.c:75665)
  File "parser.pxi", line 1507, in lxml.etree._parseDocumentFromURL (src/lxml/lxml.etree.c:75993)
  File "parser.pxi", line 1407, in lxml.etree._parseDocFromFile (src/lxml/lxml.etree.c:75002)
  File "parser.pxi", line 965, in lxml.etree._BaseParser._parseDocFromFile (src/lxml/lxml.etree.c:72023)
  File "parser.pxi", line 539, in lxml.etree._ParserContext._handleParseResultDoc (src/lxml/lxml.etree.c:67830)
  File "parser.pxi", line 625, in lxml.etree._handleParseResult (src/lxml/lxml.etree.c:68877)
  File "parser.pxi", line 565, in lxml.etree._raiseParseError (src/lxml/lxml.etree.c:68125)
lxml.etree.XMLSyntaxError: Entity 'hellip' not defined, line 3, column 28

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

>> parser = lxml.etree.XMLParser(recover=True)                   ①
>>> tree = lxml.etree.parse('examples/feed-broken.xml', parser)  ②
>>> parser.error_log                                             ③
examples/feed-broken.xml:3:28:FATAL:PARSER:ERR_UNDECLARED_ENTITY: Entity 'hellip' not defined
>>> tree.findall('{http://www.w3.org/2005/Atom}title')
[<Element {http://www.w3.org/2005/Atom}title at ead510>]
>>> title = tree.findall('{http://www.w3.org/2005/Atom}title')[0]
>>> title.text                                                   ④
'dive into '
>>> print(lxml.etree.tounicode(tree.getroot()))                  ⑤
<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='en'>
  <title>dive into </title>
.
. [остальной вывод сериализации пропущен для краткости]
.

① Для того чтобы создать новый анализатор мы создаём новый класс lxml.etree.XMLParser. Хотя он может принимать много разных параметров, для нас представляет интерес только один — аргумент восстановления recover. При присвоении аргументу значения True lxml будет из кожи вон лезть чтобы восстановить ошибки правильнопостроенности.

② Для того чтобы разобрать XML документ новым анализатором мы передаём объект parser в качестве второго аргумента в функцию parse(). На этот раз lxml не выбрасывает исключительную ситуацию при неопределённой последовательности &hellip;.

③ Анализатор содержит сообщения обо всех найденных ошибках. (На самом деле эти сообщения сохраняются независимо от параметра recover.)

④ Так как анализатор не знает что делать с неопределённым &hellip;, то он просто выбрасывает слово. Текстовое содержание элемента title превращается в ‘dive into ‘.

⑤ И ещё раз: после сериализации последовательность &hellip; исчезла, lxml её выбросил.

Важно отметить, что нет никакой гарантии переносимости восстановления ошибок у XML анализаторов. Другой анализатор может быть умнее и распознать что &hellip; является валидной последовательностью HTML и восстановить её как амперсанд. «Лучше» ли это? Возможно. Является ли это «более правильным»? Нет, так как оба решения с точки зрения формата XML неверны. Правильное поведение (согласно XML спецификации) прекратить обработку и загореться. Если же необходимо не следовать спецификации, то Вы делаете это на свой страх и риск.

Материалы для дальнейшего чтения

XML на Википедии

The ElementTree XML API(англ.)

Elements and Element Trees — Элементы и деревья элементов(англ.)

XPath Support in ElementTree — Поддержка XPath в ElementTree(англ.)

The ElementTree iterparse Function — Функция iterparse в ElementTree(англ.)

lxml(англ.)

Parsing XML and HTML with lxml — обработка XML и HTML в lxml(англ.)

XPath and XSLT with lxml — XPath и XSLT в lxml(англ.)

xmlwitch(англ.)

java — Ошибка синтаксического анализа XML-документа

Присоединяйтесь к Stack Overflow , чтобы учиться, делиться знаниями и строить свою карьеру.

Спросил 8 лет, 11 мес. Назад

Просмотрено 542 раза

Я использую Xerces 2.11.0 для моего проекта. Но во время рома я получаю сообщение об ошибке. Трассировка стека ошибки выглядит следующим образом:

  java.lang.Exception: org.openid4java.discovery.DiscoveryException: 0x70d: ошибка синтаксического анализа XML-документа
        в org.iitk.brihaspati.modules.actions.GoogleRequest.performDiscoveryOnUserSuppliedIdentifier (GoogleRequest.java:83)
        на org.iitk.brihaspati.modules.actions.GoogleLogin.doPerform (GoogleLogin.java:86)
        в org.apache.turbine.modules.actions.VelocityAction.doPerform (VelocityAction.java:84)
        в org.apache.turbine.util.velocity.VelocityActionEvent.perform (VelocityActionEvent.java:120)
        в org.apache.turbine.modules.actions.VelocityAction.perform (VelocityAction.java:110)
        в org.apache.turbine.modules.ActionLoader.exec (ActionLoader.java:134)
        в org.apache.turbine.modules.pages.DefaultPage.doBuild (DefaultPage.java:154)
        в org.apache.turbine.modules.Page.build (Page.java:91)
        в org.apache.turbine.modules.PageLoader.exec (PageLoader.java:136)
        на org.apache.turbine.Turbine.doGet (Turbine.java:796)
        на org.apache.turbine.Turbine.doPost (Turbine.java:891)
        в javax.servlet.http.HttpServlet.service (HttpServlet.java:760)
        в javax.servlet.http.HttpServlet.service (HttpServlet.java:853)
        в org.apache.catalina.servlets.InvokerServlet.serveRequest (InvokerServlet.java:466)
        в org.apache.catalina.servlets.InvokerServlet.doPost (InvokerServlet.java:216)
        на javax.servlet.http.HttpServlet.service (HttpServlet.java:760)
        в javax.servlet.http.HttpServlet.service (HttpServlet.java:853)
        в org.apache.catalina.core.ApplicationFilterChain.internalDoFilter (ApplicationFilterChain.java:247)
        в org.apache.catalina.core.ApplicationFilterChain.doFilter (ApplicationFilterChain.java:193)
        в org.apache.catalina.core.StandardWrapperValve.invoke (StandardWrapperValve.java:256)
        в org.apache.catalina.core.StandardPipeline $ StandardPipelineValveContext.invokeNext (StandardPipeline.java:643)
        в org.apache.catalina.core.StandardPipeline.invoke (StandardPipeline.java:480)
        в org.apache.catalina.core.ContainerBase.invoke (ContainerBase.java:995)
        в org.apache.catalina.core.StandardContextValve.invoke (StandardContextValve.java:191)
        в org.apache.catalina.core.StandardPipeline $ StandardPipelineValveContext.invokeNext (StandardPipeline.java:643)
        в org.apache.catalina.authenticator.AuthenticatorBase.invoke (AuthenticatorBase.java: 494)
        в org.apache.catalina.core.StandardPipeline $ StandardPipelineValveContext.invokeNext (StandardPipeline.java:641)
        в org.apache.catalina.core.StandardPipeline.invoke (StandardPipeline.java:480)
        в org.apache.catalina.core.ContainerBase.invoke (ContainerBase.java:995)
        в org.apache.catalina.core.StandardContext.invoke (StandardContext.java:2417)
        в org.apache.catalina.core.StandardHostValve.invoke (StandardHostValve.java:180)
        на org.apache.catalina.core.StandardPipeline $ StandardPipelineValveContext.invokeNext (StandardPipeline.java:643)
        в org.apache.catalina.valves.ErrorDispatcherValve.invoke (ErrorDispatcherValve.java:171)
        в org.apache.catalina.core.StandardPipeline $ StandardPipelineValveContext.invokeNext (StandardPipeline.java:641)
        в org.apache.catalina.valves.ErrorReportValve.invoke (ErrorReportValve.java:172)
        в org.apache.catalina.core.StandardPipeline $ StandardPipelineValveContext.invokeNext (StandardPipeline.java: 641)
        в org.apache.catalina.valves.AccessLogValve.invoke (AccessLogValve.java:577)
        в org.apache.catalina.core.StandardPipeline $ StandardPipelineValveContext.invokeNext (StandardPipeline.java:641)
        в org.apache.catalina.core.StandardPipeline.invoke (StandardPipeline.java:480)
        в org.apache.catalina.core.ContainerBase.invoke (ContainerBase.java:995)
        в org.apache.catalina.core.StandardEngineValve.invoke (StandardEngineValve.java:174)
        на org.apache.catalina.core.StandardPipeline $ StandardPipelineValveContext.invokeNext (StandardPipeline.java:643)
        в org.apache.catalina.core.StandardPipeline.invoke (StandardPipeline.java:480)
        в org.apache.catalina.core.ContainerBase.invoke (ContainerBase.java:995)
        в org.apache.catalina.connector.http.HttpProcessor.process (HttpProcessor.java:1040)
        в org.apache.catalina.connector.http.HttpProcessor.run (HttpProcessor.java:1151)
        в java.lang.Thread.run (Thread.java:636)
Вызвано: org.openid4java.discovery.DiscoveryException: 0x70d: ошибка синтаксического анализа XML-документа
        в org.openid4java.discovery.xrds.XrdsParserImpl.parseXmlInput (XrdsParserImpl.java:197)
        в org.openid4java.discovery.xrds.XrdsParserImpl.parseXrds (XrdsParserImpl.java:50)
        в org.openid4java.discovery.yadis.YadisResolver.retrieveXrdsLocation (YadisResolver.java:448)
        в org.openid4java.discovery.yadis.YadisResolver.discover (YadisResolver.java:252)
        в org.openid4java.discovery.yadis.YadisResolver.обнаружить (YadisResolver.java:232)
        в org.openid4java.discovery.yadis.YadisResolver.discover (YadisResolver.java:166)
        в org.openid4java.discovery.Discovery.discover (Discovery.java:147)
        в org.openid4java.discovery.Discovery.discover (Discovery.java:129)
        в org.openid4java.consumer.ConsumerManager.discover (ConsumerManager.java:542)
        в org.iitk.brihaspati.modules.actions.GoogleRequest.performDiscoveryOnUserSuppliedIdentifier (GoogleRequest.java:74)
        ... еще 46
Вызвано: org.xml.sax.SAXParseException: s4s-att-invalid-value: недопустимое значение атрибута для 'targetNamespace' в элементе 'schema'. Записанная причина: cvc-datatype-valid.1.2.1: 'xri: // $ xrd * ($ v * 2.0)' не является допустимым значением для 'anyURI'.
        в org.apache.xerces.parsers.DOMParser.parse (неизвестный источник)
        в org.apache.xerces.jaxp.DocumentBuilderImpl.parse (неизвестный источник)
        в javax.xml.parsers.DocumentBuilder.parse (неизвестный источник)
        в org.openid4java.discovery.xrds.XrdsParserImpl.parseXmlInput (XrdsParserImpl.java: 188)
        ... еще 55
  

Я пробовал и другие версии, такие как Xerces 2.8.1 и Xerces 2.8.0. Но каждый раз я получаю одну и ту же ошибку.

9,51655 золотых знаков3939 серебряных знаков6363 бронзовых знака

задан 16 мая ’12 в 9: 222012-05-16 09:22

Проблема и возможное решение приведены здесь:

  android: text = "@ string / button_string"
  

  
<ресурсы>
     Практическое приложение 
     Настройки 
     Привет, мир! 
     я 
     aldo 
     GRA 
     AME 
     cush 
     conn 
     меню 

  

  

         <Кнопка
             android: id = "@ + id / button1"
             android: layout_width = "50sp"
             android: layout_height = "50sp"
             android: layout_above = "@ + id / button2"
             android: layout_alignLeft = "@ + id / button2"
             android: layout_marginBottom = "12dp"
             android: background = "@ drawable / round_button"
             android: gravity = "center_vertical | center_horizontal"
android: text = "@ строка / button_string"
             android: textColor = "# fff" />

...