parsing XML con spazio dei nomi in Python via 'ElementTree'

Question

ho il seguente codice XML, che voglio analizzare utilizzando 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> 

Voglio trovare tutti owl:Class tag e quindi estrarre il valore di tutti rdfs:label istanze dentro di loro. Sto usando il seguente codice:

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

A causa dello spazio dei nomi, ricevo il seguente errore.

SyntaxError: prefix 'owl' not found in prefix map 

ho provato leggendo il documento in http://effbot.org/zone/element-namespaces.htm ma non sono ancora in grado di ottenere questo lavoro in quanto il sopra XML ha più spazi dei nomi nidificati.

Gentilmente fammi sapere come modificare il codice per trovare tutti i tag owl:Class.

Answer 1

ElementTree non è troppo intelligente sui namespace. È necessario fornire i metodi .find(), findall() e iterfind() a un dizionario dello spazio dei nomi esplicito. . Questo non è documentato molto bene:

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

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

prefissi sono solo alzò gli occhi nel parametro namespaces si passa in questo modo è possibile utilizzare qualsiasi prefisso namespace che ti piace; l'API divide la parte owl:, cerca l'URL dello spazio dei nomi corrispondente nel dizionario namespaces, quindi modifica la ricerca per cercare l'espressione XPath {http://www.w3.org/2002/07/owl}Class. È possibile utilizzare la stessa sintassi te troppo, naturalmente:

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

Se è possibile passare alle lxml library le cose vanno meglio; quella libreria supporta la stessa API ElementTree, ma raccoglie gli spazi dei nomi per voi in un attributo .nsmap sugli elementi.

Answer 2

Ecco come fare questo con lxml senza dover codificare gli spazi dei nomi o la scansione del testo per loro (come cita Martijn Pieters):

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

Answer 3

Nota: Questa è una risposta utile per La libreria standard ElementTree di Python senza utilizzare spazi dei nomi codificati.

Per estrarre i prefissi di namespace e URI da dati XML è possibile utilizzare ElementTree.iterparse la funzione, l'analisi solo namespace avviare eventi (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#'} 

Poi il dizionario può essere passato come argomento al funzioni di ricerca:

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

Answer 4

so di un paio di anni di ritardo, ma ho solo creato un pacchetto che consente di gestire la conversione di un dizionario per XML valido con spazio dei nomi S. Il pacchetto è ospitato su PyPi @https://pypi.python.org/pypi/xmler.

Con questo pacchetto è possibile prendere un dizionario che assomiglia a questo:

myDict = { 
    "RootTag": {      # The root tag. Will not necessarily be root. (see #customRoot) 
     "@ns": "soapenv",   # The namespace for the RootTag. The RootTag will appear as <soapenv:RootTag ...> 
     "@attrs": {      # @attrs takes a dictionary. each key-value pair will become an attribute 
      { "xmlns:soapenv": "http://schemas.xmlsoap.org/soap/envelope/" } 
     }, 
     "childTag": { 
      "@attrs": { 
       "someAttribute": "colors are nice" 
      }, 
      "grandchild": "This is a text tag" 
     } 
    } 
} 

e ottenere output XML che assomiglia a questo:

<soapenv:RootTag xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"> 
    <childTag someAttribute="colors are nice"> 
     <grandchild>This is a text tag</grandchild> 
    </childTag> 
</soapenv:RootTag> 

Spero che questo è utile per le persone in futuro

Answer 5

Ho usato un codice simile a questo e ho trovato che vale sempre la pena leggere la documentazione ... come al solito!

findall() trova solo elementi che sono figli diretti del tag corrente. Quindi, non proprio TUTTO.

Potrebbe valere la pena provare a far funzionare il codice con quanto segue, in particolare se si hanno a che fare con file xml grandi e complessi, in modo da includere anche questi sotto-elementi secondari (ecc.). Se conosci te stesso dove gli elementi sono nel tuo xml, allora suppongo che andrà bene! Pensavo che valesse la pena di ricordare.

root.iter() 

ref:. https://docs.python.org/3/library/xml.etree.elementtree.html#finding-interesting-elements "Element.findall() trova solo gli elementi con un tag, che sono figli diretti dell'elemento corrente Element.find() trova il primo figlio con una particolare etichetta, e Element.text accede al contenuto del testo dell'elemento. Element.get() accede agli attributi dell'elemento: "