Moduł Python ElementTree: Jak zignorować przestrzeń nazw plików XML, aby zlokalizować pasujący element, używając metody „find”, „findall”

Chcę użyć metody „findall”, aby zlokalizować niektóre elementy źródłowego pliku xml w module ElementTree.

Jednak źródłowy plik xml (test.xml) ma przestrzeń nazw. Obcinam część pliku xml jako przykład:

<?xml version="1.0" encoding="iso-8859-1"?>
<XML_HEADER xmlns="http://www.test.com">
    <TYPE>Updates</TYPE>
    <DATE>9/26/2012 10:30:34 AM</DATE>
    <COPYRIGHT_NOTICE>All Rights Reserved.</COPYRIGHT_NOTICE>
    <LICENSE>newlicense.htm</LICENSE>
    <DEAL_LEVEL>
        <PAID_OFF>N</PAID_OFF>
        </DEAL_LEVEL>
</XML_HEADER>

Przykładowy kod w Pythonie znajduje się poniżej:

from xml.etree import ElementTree as ET
tree = ET.parse(r"test.xml")
el1 = tree.findall("DEAL_LEVEL/PAID_OFF") # Return None
el2 = tree.findall("{http://www.test.com}DEAL_LEVEL/{http://www.test.com}PAID_OFF") # Return <Element '{http://www.test.com}DEAL_LEVEL/PAID_OFF' at 0xb78b90>

Chociaż może to działać, ponieważ istnieje przestrzeń nazw „{http://www.test.com}”, dodawanie przestrzeni nazw przed każdym tagiem jest bardzo niewygodne.

Jak mogę zignorować przestrzeń nazw, używając metody „znajdź”, „znajdź wszystko” i tak dalej?

Zamiast modyfikować sam dokument XML, najlepiej go przeanalizować, a następnie zmodyfikować tagi w wyniku. W ten sposób możesz obsłużyć wiele przestrzeni nazw i aliasów przestrzeni nazw:

from io import StringIO  # for Python 2 import from StringIO instead
import xml.etree.ElementTree as ET

# instead of ET.fromstring(xml)
it = ET.iterparse(StringIO(xml))
for _, el in it:
    prefix, has_namespace, postfix = el.tag.partition('}')
    if has_namespace:
        el.tag = postfix  # strip all namespaces
root = it.root

Jest to oparte na dyskusji tutaj: http://bugs.python.org/issue18304

Aktualizacja: rpartition zamiast partitionzapewniać, że otrzymujesz nazwę tagu, postfixnawet jeśli nie ma przestrzeni nazw. Tak więc możesz to skondensować:

for _, el in it:
    _, _, el.tag = el.tag.rpartition('}') # strip ns

Jeśli usuniesz atrybut xmlns z xml przed jego przeanalizowaniem, nie będzie przestrzeni nazw dołączonej do każdego znacznika w drzewie.

import re

xmlstring = re.sub(' xmlns="[^"]+"', '', xmlstring, count=1)

Odpowiedzi do tej pory wyraźnie umieszczały wartość przestrzeni nazw w skrypcie. Aby uzyskać bardziej ogólne rozwiązanie, wolałbym wyodrębnić przestrzeń nazw z xml:

import re
def get_namespace(element):
  m = re.match('\{.*\}', element.tag)
  return m.group(0) if m else ''

I użyj go w metodzie find:

namespace = get_namespace(tree.getroot())
print tree.find('./{0}parent/{0}version'.format(namespace)).text

Oto rozszerzenie odpowiedzi nieokąta, które również usuwa przestrzenie nazw z atrybutów:

from StringIO import StringIO
import xml.etree.ElementTree as ET

# instead of ET.fromstring(xml)
it = ET.iterparse(StringIO(xml))
for _, el in it:
    if '}' in el.tag:
        el.tag = el.tag.split('}', 1)[1]  # strip all namespaces
    for at in list(el.attrib.keys()): # strip namespaces of attributes too
        if '}' in at:
            newat = at.split('}', 1)[1]
            el.attrib[newat] = el.attrib[at]
            del el.attrib[at]
root = it.root

AKTUALIZACJA: dodano, list()aby iterator działał (wymagany dla Pythona 3)

Poprawa odpowiedzi przez ericspod:

Zamiast globalnej zmiany trybu parsowania, możemy umieścić to w obiekcie obsługującym konstrukcję with.

from xml.parsers import expat

class DisableXmlNamespaces:
    def __enter__(self):
            self.oldcreate = expat.ParserCreate
            expat.ParserCreate = lambda encoding, sep: self.oldcreate(encoding, None)
    def __exit__(self, type, value, traceback):
            expat.ParserCreate = self.oldcreate

Można to następnie wykorzystać w następujący sposób

import xml.etree.ElementTree as ET
with DisableXmlNamespaces():
     tree = ET.parse("test.xml")

Piękno tego sposobu polega na tym, że nie zmienia on żadnego zachowania dla niepowiązanego kodu poza blokiem with. Skończyło się na tym, że utworzyłem to po otrzymaniu błędów w niepowiązanych bibliotekach po użyciu wersji przez ericspod, która również korzystała z expata.

Możesz również użyć eleganckiej konstrukcji formatowania ciągów:

ns='http://www.test.com'
el2 = tree.findall("{%s}DEAL_LEVEL/{%s}PAID_OFF" %(ns,ns))

lub, jeśli masz pewność, że PAID_OFF pojawia się tylko na jednym poziomie w drzewie:

el2 = tree.findall(".//{%s}PAID_OFF" % ns)

Jeśli używasz ElementTreei nie cElementTree, możesz zmusić Expat do ignorowania przetwarzania przestrzeni nazw, zastępując ParserCreate():

from xml.parsers import expat
oldcreate = expat.ParserCreate
expat.ParserCreate = lambda encoding, sep: oldcreate(encoding, None)

ElementTreepróbuje użyć Expat, wywołując, ParserCreate()ale nie daje opcji, aby nie podawać ciągu separatora przestrzeni nazw, powyższy kod spowoduje zignorowanie go, ale ostrzegamy, że może to zepsuć inne rzeczy.

Mogę się na to spóźnić, ale nie sądzę, żeby re.subbyło to dobre rozwiązanie.

Jednak przepisywanie xml.parsers.expatnie działa dla wersji Python 3.x,

Głównym winowajcą jest xml/etree/ElementTree.pypatrz dół kodu źródłowego

# Import the C accelerators
try:
    # Element is going to be shadowed by the C implementation. We need to keep
    # the Python version of it accessible for some "creative" by external code
    # (see tests)
    _Element_Py = Element

    # Element, SubElement, ParseError, TreeBuilder, XMLParser
    from _elementtree import *
except ImportError:
    pass

Co jest trochę smutne.

Rozwiązaniem jest pozbycie się go najpierw.

import _elementtree
try:
    del _elementtree.XMLParser
except AttributeError:
    # in case deleted twice
    pass
else:
    from xml.parsers import expat  # NOQA: F811
    oldcreate = expat.ParserCreate
    expat.ParserCreate = lambda encoding, sep: oldcreate(encoding, None)

Przetestowano w Pythonie 3.6.

tryInstrukcja try jest przydatna w przypadku, gdy gdzieś w kodzie ponownie załadujesz lub zaimportujesz moduł dwukrotnie, otrzymujesz dziwne błędy, takie jak

• przekroczono maksymalną głębokość rekurencji
• AttributeError: XMLParser

do cholery, kod źródłowy etree wygląda naprawdę niechlujnie.

Połączmy odpowiedź nonagona z odpowiedzią mzjn na powiązane pytanie :

def parse_xml(xml_path: Path) -> Tuple[ET.Element, Dict[str, str]]:
    xml_iter = ET.iterparse(xml_path, events=["start-ns"])
    xml_namespaces = dict(prefix_namespace_pair for _, prefix_namespace_pair in xml_iter)
    return xml_iter.root, xml_namespaces

Korzystając z tej funkcji:

1. Utwórz iterator, aby uzyskać zarówno przestrzenie nazw, jak i przeanalizowany obiekt drzewa .

2. Iteruj po utworzonym iteratorze, aby uzyskać przestrzenie nazw, które możemy później przekazać find()lub findall()wywołać zgodnie z sugestią iMom0 .

3. Zwraca obiekt elementu głównego i przestrzenie nazw przeanalizowanego drzewa.

Myślę, że jest to najlepsze podejście dookoła, ponieważ nie ma żadnej manipulacji ani źródłowym XML ani wynikowym przeanalizowanym xml.etree.ElementTreewyjściem.

Chciałbym również podziękować odpowiedzi Barny'ego za dostarczenie niezbędnego elementu tej układanki (że można uzyskać przeanalizowany korzeń z iteratora). Do tego czasu dwukrotnie przeszedłem drzewo XML w mojej aplikacji (raz, aby uzyskać przestrzenie nazw, drugi dla katalogu głównego).