Módulo Python ElementTree: cómo ignorar el espacio de nombres de los archivos XML para localizar elementos coincidentes cuando se utiliza el método "buscar", "findall"

Quiero utilizar el método de "findall" para localizar algunos elementos del archivo xml de origen en el módulo ElementTree.

Sin embargo, el archivo xml de origen (test.xml) tiene espacio de nombres. Trunco ​​parte del archivo xml como muestra:

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

El código de Python de muestra está abajo:

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>

Aunque puede funcionar, porque hay un espacio de nombres "{http://www.test.com}", es muy inconveniente agregar un espacio de nombres frente a cada etiqueta.

¿Cómo puedo ignorar el espacio de nombres cuando uso el método de "buscar", "findall", etc.

En lugar de modificar el documento XML en sí, es mejor analizarlo y luego modificar las etiquetas en el resultado. De esta manera puede manejar múltiples espacios de nombres y alias de espacios de nombres:

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

Esto se basa en la discusión aquí: http://bugs.python.org/issue18304

Actualización: en rpartition lugar de partitionasegurarse de obtener el nombre de la etiqueta postfixincluso si no hay espacio de nombres. Así podrías condensarlo:

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

Si elimina el atributo xmlns del xml antes de analizarlo, entonces no habrá un espacio de nombres antepuesto a cada etiqueta en el árbol.

import re

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

Las respuestas hasta ahora ponen explícitamente el valor del espacio de nombres en el script. Para una solución más genérica, prefiero extraer el espacio de nombres del xml:

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

Y úsalo en el método de búsqueda:

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

Aquí hay una extensión de la respuesta de nonagon, que también elimina los espacios de nombres de los atributos:

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

ACTUALIZACIÓN: agregado list()para que el iterador funcione (necesario para Python 3)

Mejorando la respuesta de ericspod:

En lugar de cambiar el modo de análisis globalmente, podemos envolver esto en un objeto que soporte la construcción 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

Esto se puede usar de la siguiente manera

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

La belleza de esta manera es que no cambia ningún comportamiento para el código no relacionado fuera del bloque with. Terminé creando esto después de obtener errores en bibliotecas no relacionadas después de usar la versión de ericspod que también usaba expat.

También puede usar la elegante construcción de formato de cadena:

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

o, si está seguro de que PAID_OFF solo aparece en un nivel en el árbol:

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

Si está utilizando ElementTreey no cElementTreepuede forzar a Expat a ignorar el procesamiento del espacio de nombres reemplazando ParserCreate():

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

ElementTreeintenta usar Expat llamando ParserCreate()pero no proporciona ninguna opción para no proporcionar una cadena de separación de espacio de nombres, el código anterior hará que se ignore pero se le advierte que esto podría romper otras cosas.

Podría llegar tarde a esto, pero no creo que re.subsea ​​una buena solución.

Sin embargo, la reescritura xml.parsers.expatno funciona para las versiones de Python 3.x,

El principal culpable es la xml/etree/ElementTree.pyparte inferior del código fuente.

# 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

Lo cual es un poco triste.

La solución es deshacerse de él primero.

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)

Probado en Python 3.6.

La trydeclaración de prueba es útil en caso de que en algún lugar de su código vuelva a cargar o importe un módulo dos veces y obtenga errores extraños como

• profundidad de recursión máxima excedida
• AttributeError: XMLParser

Por cierto, el código fuente de etree parece realmente desordenado.

Vamos a combinar la respuesta de nonagon con la respuesta de mzjn a una pregunta relacionada :

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 esta función nosotros:

1. Cree un iterador para obtener espacios de nombres y un objeto de árbol analizado .

2. Itere sobre el iterador creado para obtener los espacios de nombres dictados que luego podemos pasar en cada uno find()o findall()llamar como lo sugiere iMom0 .

3. Devuelve el objeto del elemento raíz del árbol analizado y los espacios de nombres.

Creo que este es el mejor enfoque en todos los aspectos, ya que no hay manipulación de un código fuente XML o de la xml.etree.ElementTreesalida analizada resultante de ningún tipo.

También me gustaría dar crédito a la respuesta de Barny al proporcionar una pieza esencial de este rompecabezas (que puede obtener la raíz analizada del iterador). Hasta ese momento, atravesé dos veces el árbol XML en mi aplicación (una vez para obtener espacios de nombres, la segunda para una raíz).