Modulo Python ElementTree: come ignorare lo spazio dei nomi dei file XML per individuare l'elemento corrispondente quando si utilizza il metodo "find", "findall"

Voglio usare il metodo di "findall" per individuare alcuni elementi del file XML di origine nel modulo ElementTree.

Tuttavia, il file XML di origine (test.xml) ha spazio dei nomi. Troncare parte del file XML come esempio:

<?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>

Il codice di esempio di Python è di seguito:

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>

Sebbene possa funzionare, poiché esiste uno spazio dei nomi "{http://www.test.com}", è molto scomodo aggiungere uno spazio dei nomi davanti a ciascun tag.

Come posso ignorare lo spazio dei nomi quando uso il metodo di "trova", "trova tutto" e così via?

Invece di modificare il documento XML stesso, è meglio analizzarlo e quindi modificare i tag nel risultato. In questo modo è possibile gestire più spazi dei nomi e alias dello spazio dei nomi:

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

Questo si basa sulla discussione qui: http://bugs.python.org/issue18304

Aggiornamento: rpartition invece di partitionassicurarti di ottenere il nome del tag postfixanche se non c'è spazio dei nomi. Quindi potresti condensarlo:

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

Se rimuovi l'attributo xmlns dall'xml prima di analizzarlo, non ci sarà uno spazio dei nomi anteposto a ciascun tag nella struttura.

import re

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

Le risposte finora hanno esplicitamente inserito il valore dello spazio dei nomi nello script. Per una soluzione più generica, preferirei estrarre lo spazio dei nomi dall'xml:

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

E usalo nel metodo find:

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

Ecco un'estensione alla risposta di nonagon, che elimina anche gli spazi dei nomi dagli attributi:

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

AGGIORNAMENTO: aggiunto in list()modo che l'iteratore funzioni (necessario per Python 3)

Migliorare la risposta di ericspod:

Invece di cambiare la modalità di analisi a livello globale, possiamo racchiuderlo in un oggetto che supporta il costrutto 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

Questo può quindi essere usato come segue

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

Il bello di questo modo è che non cambia alcun comportamento per il codice non correlato al di fuori del blocco with. Ho finito per crearlo dopo aver ricevuto errori nelle librerie non correlate dopo aver utilizzato la versione di ericspod, che è stata utilizzata anche da expat.

Puoi anche usare l'elegante costrutto di formattazione delle stringhe:

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

oppure, se sei sicuro che PAID_OFF appare solo in un livello nella struttura:

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

Se stai utilizzando ElementTreee non cElementTreepuoi forzare Expat a ignorare l'elaborazione dello spazio dei nomi sostituendo ParserCreate():

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

ElementTreetenta di usare Expat chiamando ParserCreate()ma non fornisce alcuna opzione per non fornire una stringa di separazione dello spazio dei nomi, il codice sopra lo farà ignorare ma ti avviserà che ciò potrebbe interrompere altre cose.

Potrei essere in ritardo per questo, ma non credo re.subsia una buona soluzione.

Tuttavia, la riscrittura xml.parsers.expatnon funziona per le versioni 3.x di Python,

Il principale colpevole è la parte xml/etree/ElementTree.pyinferiore del codice sorgente

# 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

Che è un po 'triste.

La soluzione è di sbarazzarsene prima.

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)

Testato su Python 3.6.

L' tryistruzione Try è utile nel caso in cui da qualche parte nel tuo codice ricarichi o importi un modulo due volte ottieni strani errori come

• superata la profondità massima di ricorsione
• AttributeError: XMLParser

tra l'altro il codice sorgente di etree sembra davvero disordinato.

Uniamo la risposta di nonagon con la risposta di mzjn a una domanda correlata :

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

Usando questa funzione noi:

1. Crea un iteratore per ottenere sia gli spazi dei nomi sia un oggetto albero analizzato .

2. Scorri sull'iteratore creato per ottenere il comando degli spazi dei nomi che possiamo in seguito passare in ciascuno find()o findall()chiamare come suggerito da iMom0 .

3. Restituisce l'oggetto e gli spazi dei nomi dell'elemento radice dell'albero analizzato.

Penso che questo sia l'approccio migliore in quanto non vi è alcuna manipolazione di un XML di origine o di un risultato analizzato risultante di xml.etree.ElementTreequalunque tipo.

Vorrei anche dare credito alla risposta di Barny fornendo un pezzo essenziale di questo puzzle (che puoi ottenere la radice analizzata dall'iteratore). Fino a quel momento in realtà ho attraversato due volte l'albero XML nella mia applicazione (una volta per ottenere spazi dei nomi, secondo per una radice).