Module Python ElementTree: Comment ignorer l'espace de noms des fichiers XML pour localiser l'élément correspondant lors de l'utilisation de la méthode «find», «findall»

Je souhaite utiliser la méthode "findall" pour localiser certains éléments du fichier xml source dans le module ElementTree.

Cependant, le fichier xml source (test.xml) a un espace de noms. Je tronque une partie du fichier xml comme exemple:

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

L'exemple de code python est ci-dessous:

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>

Bien que cela puisse fonctionner, car il existe un espace de noms "{http://www.test.com}", il est très peu pratique d'ajouter un espace de noms devant chaque balise.

Comment puis-je ignorer l'espace de noms lors de l'utilisation de la méthode "find", "findall" et ainsi de suite?

Au lieu de modifier le document XML lui-même, il est préférable de l'analyser, puis de modifier les balises dans le résultat. De cette façon, vous pouvez gérer plusieurs espaces de noms et alias d'espaces de noms:

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

Ceci est basé sur la discussion ici: http://bugs.python.org/issue18304

Mise à jour: rpartition au lieu de partitions'assure que vous obtenez le nom de la balise postfixmême s'il n'y a pas d'espace de noms. Ainsi vous pourriez le condenser:

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

Si vous supprimez l'attribut xmlns du xml avant de l'analyser, il n'y aura pas d'espace de noms ajouté à chaque balise de l'arborescence.

import re

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

Les réponses jusqu'à présent mettent explicitement la valeur de l'espace de noms dans le script. Pour une solution plus générique, je préférerais extraire l'espace de noms du xml:

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

Et utilisez-le dans la méthode de recherche:

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

Voici une extension de la réponse de nonagon, qui supprime également les espaces de noms des attributs:

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

UPDATE: ajouté list()pour que l'itérateur fonctionne (nécessaire pour Python 3)

Améliorer la réponse par ericspod:

Au lieu de changer le mode d'analyse globalement, nous pouvons envelopper cela dans un objet prenant en charge la construction 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

Cela peut ensuite être utilisé comme suit

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

La beauté de cette méthode est qu'elle ne change aucun comportement pour le code non lié en dehors du bloc with. J'ai fini par créer cela après avoir obtenu des erreurs dans des bibliothèques non liées après avoir utilisé la version d'ericspod qui utilisait également expat.

Vous pouvez également utiliser la construction de formatage de chaîne élégante:

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

ou, si vous êtes sûr que PAID_OFF n'apparaît qu'à un seul niveau de l'arborescence:

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

Si vous utilisez ElementTreeet non, cElementTreevous pouvez forcer Expat à ignorer le traitement de l'espace de noms en remplaçant ParserCreate():

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

ElementTreeessaie d'utiliser Expat en appelant ParserCreate()mais ne fournit aucune option pour ne pas fournir de chaîne de séparation d'espace de noms, le code ci-dessus le fera ignorer mais sachez que cela pourrait casser d'autres choses.

Je suis peut-être en retard pour cela, mais je ne pense pas que ce re.subsoit une bonne solution.

Cependant la réécriture xml.parsers.expatne fonctionne pas pour les versions Python 3.x,

Le principal coupable est la xml/etree/ElementTree.pyvue en bas du code source

# 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

Ce qui est un peu triste.

La solution est de s'en débarrasser d'abord.

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)

Testé sur Python 3.6.

L' tryinstruction Try est utile au cas où quelque part dans votre code vous rechargez ou importez un module deux fois, vous obtenez des erreurs étranges comme

• profondeur maximale de récursivité dépassée
• AttributeError: XMLParser

btw damn le code source etree semble vraiment désordonné.

Unissons la réponse de nonagon avec la réponse de mzjn à une question connexe :

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

En utilisant cette fonction, nous:

1. Créez un itérateur pour obtenir les deux espaces de noms et un objet d'arborescence analysé .

2. Itérez sur l'itérateur créé pour obtenir les espaces de noms dict que nous pouvons plus tard passer dans chacun find()ou findall()appeler comme suggéré par iMom0 .

3. Renvoie l'objet élément racine et les espaces de noms de l'arborescence analysée.

Je pense que c'est la meilleure approche tout autour car il n'y a aucune manipulation ni d'un XML source ni de la xml.etree.ElementTreesortie analysée résultante impliquée.

Je voudrais également attribuer à la réponse de Barny une pièce essentielle de ce puzzle (que vous pouvez obtenir la racine analysée de l'itérateur). Jusque-là, j'ai parcouru l'arborescence XML deux fois dans mon application (une fois pour obtenir des espaces de noms, une seconde pour une racine).