Analyser XML avec un espace de noms en Python via 'ElementTree'

J'ai le XML suivant que je veux analyser en utilisant Python ElementTree:

<rdf:RDF xml:base="http://dbpedia.org/ontology/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns="http://dbpedia.org/ontology/">

    <owl:Class rdf:about="http://dbpedia.org/ontology/BasketballLeague">
        <rdfs:label xml:lang="en">basketball league</rdfs:label>
        <rdfs:comment xml:lang="en">
          a group of sports teams that compete against each other
          in Basketball
        </rdfs:comment>
    </owl:Class>

</rdf:RDF>

Je veux trouver toutes les owl:Classbalises, puis extraire la valeur de toutes les rdfs:labelinstances qu'elles contiennent. J'utilise le code suivant:

tree = ET.parse("filename")
root = tree.getroot()
root.findall('owl:Class')

En raison de l'espace de noms, j'obtiens l'erreur suivante.

SyntaxError: prefix 'owl' not found in prefix map

J'ai essayé de lire le document à http://effbot.org/zone/element-namespaces.htm mais je ne suis toujours pas en mesure de faire fonctionner cela car le XML ci-dessus a plusieurs espaces de noms imbriqués.

Veuillez me faire savoir comment modifier le code pour trouver toutes les owl:Classbalises.

ElementTree n'est pas trop intelligent sur les espaces de noms. Vous devez donner aux méthodes .find(), findall()et iterfind()un dictionnaire d'espace de noms explicite. Ceci n'est pas très bien documenté:

namespaces = {'owl': 'http://www.w3.org/2002/07/owl#'} # add more as needed

root.findall('owl:Class', namespaces)

Les préfixes ne sont recherchés que dans le namespacesparamètre que vous passez. Cela signifie que vous pouvez utiliser n'importe quel préfixe d'espace de noms que vous souhaitez; l'API sépare la owl:partie, recherche l'URL d'espace de noms correspondante dans le namespacesdictionnaire, puis modifie la recherche pour rechercher l'expression XPath à la {http://www.w3.org/2002/07/owl}Classplace. Vous pouvez bien sûr utiliser la même syntaxe vous-même:

root.findall('{http://www.w3.org/2002/07/owl#}Class')

Si vous pouvez passer à la lxmlbibliothèque, les choses vont mieux; cette bibliothèque prend en charge la même API ElementTree, mais collecte les espaces de noms pour vous dans un .nsmapattribut sur les éléments.

Voici comment faire cela avec lxml sans avoir à coder en dur les espaces de noms ou à analyser le texte pour eux (comme le mentionne Martijn Pieters):

from lxml import etree
tree = etree.parse("filename")
root = tree.getroot()
root.findall('owl:Class', root.nsmap)

MISE À JOUR :

5 ans plus tard, je rencontre toujours des variantes de ce problème. lxml aide comme je l'ai montré ci-dessus, mais pas dans tous les cas. Les commentateurs ont peut-être un point valable concernant cette technique lorsqu'il s'agit de fusionner des documents, mais je pense que la plupart des gens ont du mal à simplement rechercher des documents.

Voici un autre cas et comment je l'ai géré:

<?xml version="1.0" ?><Tag1 xmlns="http://www.mynamespace.com/prefix">
<Tag2>content</Tag2></Tag1>

xmlns sans préfixe signifie que les balises sans préfixe obtiennent cet espace de noms par défaut. Cela signifie que lorsque vous recherchez Tag2, vous devez inclure l'espace de noms pour le trouver. Cependant, lxml crée une entrée nsmap avec Aucun comme clé, et je n'ai pas trouvé de moyen de la rechercher. J'ai donc créé un nouveau dictionnaire d'espaces de noms comme celui-ci

namespaces = {}
# response uses a default namespace, and tags don't mention it
# create a new ns map using an identifier of our choice
for k,v in root.nsmap.iteritems():
    if not k:
        namespaces['myprefix'] = v
e = root.find('myprefix:Tag2', namespaces)

Remarque : Ceci est une réponse utile pour la bibliothèque standard ElementTree de Python sans utiliser d'espaces de noms codés en dur.

Pour extraire les préfixes et l'URI de l'espace de noms des données XML, vous pouvez utiliser la ElementTree.iterparsefonction, en analysant uniquement les événements de démarrage de l'espace de noms ( start-ns ):

>>> from io import StringIO
>>> from xml.etree import ElementTree
>>> my_schema = u'''<rdf:RDF xml:base="http://dbpedia.org/ontology/"
...     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
...     xmlns:owl="http://www.w3.org/2002/07/owl#"
...     xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
...     xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
...     xmlns="http://dbpedia.org/ontology/">
... 
...     <owl:Class rdf:about="http://dbpedia.org/ontology/BasketballLeague">
...         <rdfs:label xml:lang="en">basketball league</rdfs:label>
...         <rdfs:comment xml:lang="en">
...           a group of sports teams that compete against each other
...           in Basketball
...         </rdfs:comment>
...     </owl:Class>
... 
... </rdf:RDF>'''
>>> my_namespaces = dict([
...     node for _, node in ElementTree.iterparse(
...         StringIO(my_schema), events=['start-ns']
...     )
... ])
>>> from pprint import pprint
>>> pprint(my_namespaces)
{'': 'http://dbpedia.org/ontology/',
 'owl': 'http://www.w3.org/2002/07/owl#',
 'rdf': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
 'rdfs': 'http://www.w3.org/2000/01/rdf-schema#',
 'xsd': 'http://www.w3.org/2001/XMLSchema#'}

Ensuite, le dictionnaire peut être passé en argument aux fonctions de recherche:

root.findall('owl:Class', my_namespaces)

J'ai utilisé un code similaire à celui-ci et j'ai trouvé qu'il valait toujours la peine de lire la documentation ... comme d'habitude!

findall () ne trouvera que les éléments qui sont des enfants directs de la balise courante . Donc, pas vraiment TOUS.

Cela peut valoir la peine d'essayer de faire fonctionner votre code avec les éléments suivants, surtout si vous avez affaire à des fichiers XML volumineux et complexes afin que ces sous-sous-éléments (etc.) soient également inclus. Si vous savez vous-même où se trouvent les éléments dans votre xml, alors je suppose que ça ira! Je pensais juste que cela valait la peine de se souvenir.

root.iter()

ref: https://docs.python.org/3/library/xml.etree.elementtree.html#finding-interesting-elements "Element.findall () ne trouve que les éléments avec une balise qui sont des enfants directs de l'élément courant. Element.find () trouve le premier enfant avec une balise particulière, et Element.text accède au contenu texte de l'élément. Element.get () accède aux attributs de l'élément: "

Pour obtenir l'espace de noms dans son format d'espace de noms, par exemple {myNameSpace}, vous pouvez faire ce qui suit:

root = tree.getroot()
ns = re.match(r'{.*}', root.tag).group(0)

De cette façon, vous pouvez l'utiliser plus tard dans votre code pour trouver des nœuds, par exemple en utilisant une interpolation de chaîne (Python 3).

link = root.find(f"{ns}link")

Ma solution est basée sur le commentaire de @Martijn Pieters:

register_namespace influence uniquement la sérialisation, pas la recherche.

L'astuce ici est donc d'utiliser différents dictionnaires pour la sérialisation et la recherche.

namespaces = {
    '': 'http://www.example.com/default-schema',
    'spec': 'http://www.example.com/specialized-schema',
}

Maintenant, enregistrez tous les espaces de noms pour l'analyse et l'écriture:

for name, value in namespaces.iteritems():
    ET.register_namespace(name, value)

Pour la recherche ( find(), findall(), iterfind()) nous avons besoin d' un préfixe non vide. Passez à ces fonctions un dictionnaire modifié (ici je modifie le dictionnaire original, mais cela ne doit être fait qu'après l'enregistrement des espaces de noms).

self.namespaces['default'] = self.namespaces['']

Désormais, les fonctions de la find()famille peuvent être utilisées avec le defaultpréfixe:

print root.find('default:myelem', namespaces)

mais

tree.write(destination)

n'utilise aucun préfixe pour les éléments de l'espace de noms par défaut.