Analizando XML con espacio de nombres en Python a través de 'ElementTree'

Tengo el siguiente XML que quiero analizar usando 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>

Quiero encontrar todas las owl:Classetiquetas y luego extraer el valor de todas las rdfs:labelinstancias dentro de ellas. Estoy usando el siguiente código:

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

Debido al espacio de nombres, recibo el siguiente error.

SyntaxError: prefix 'owl' not found in prefix map

Intenté leer el documento en http://effbot.org/zone/element-namespaces.htm pero todavía no puedo hacer que esto funcione ya que el XML anterior tiene múltiples espacios de nombres anidados.

Por favor, hágame saber cómo cambiar el código para encontrar todas las owl:Classetiquetas.

ElementTree no es demasiado inteligente sobre los espacios de nombres. Es necesario dar el .find(), findall()y iterfind()los métodos de un diccionario de espacio de nombres explícito. Esto no está muy bien documentado:

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

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

Los prefijos solo se buscan en el namespacesparámetro que ingresa. Esto significa que puede usar cualquier prefijo de espacio de nombres que desee; la API se divide de la owl:parte, busca la URL del espacio de nombres correspondiente en el namespacesdiccionario, luego cambia la búsqueda para buscar la expresión XPath en su {http://www.w3.org/2002/07/owl}Classlugar. También puede usar la misma sintaxis, por supuesto:

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

Si puede cambiar a la lxmlbiblioteca, las cosas están mejor; esa biblioteca admite la misma API de ElementTree, pero recopila espacios de nombres para usted en un .nsmapatributo en los elementos.

Aquí le mostramos cómo hacer esto con lxml sin tener que codificar los espacios de nombres o escanear el texto en busca de ellos (como menciona Martijn Pieters):

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

ACTUALIZACIÓN :

5 años después todavía me encuentro con variaciones de este problema. lxml ayuda como mostré arriba, pero no en todos los casos. Los comentaristas pueden tener un punto válido con respecto a esta técnica cuando se trata de fusionar documentos, pero creo que la mayoría de las personas tienen dificultades simplemente buscando documentos.

Aquí hay otro caso y cómo lo manejé:

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

xmlns sin prefijo significa que las etiquetas no prefijadas obtienen este espacio de nombres predeterminado. Esto significa que cuando busca Tag2, debe incluir el espacio de nombres para encontrarlo. Sin embargo, lxml crea una entrada nsmap con None como clave, y no pude encontrar una manera de buscarla. Entonces, creé un nuevo diccionario de espacio de nombres como este

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)

Nota : Esta es una respuesta útil para la biblioteca estándar ElementTree de Python sin usar espacios de nombres codificados.

Para extraer los prefijos y el URI del espacio de nombres de los datos XML, puede usar la ElementTree.iterparsefunción, analizando solo los eventos de inicio del espacio de nombres ( 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#'}

Luego, el diccionario se puede pasar como argumento a las funciones de búsqueda:

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

He estado usando un código similar a este y he descubierto que siempre vale la pena leer la documentación ... ¡como siempre!

findall () solo encontrará elementos que son hijos directos de la etiqueta actual . Entonces, no TODOS.

Puede valer la pena intentar que su código funcione con lo siguiente, especialmente si se trata de archivos xml grandes y complejos para que también se incluyan esos subelementos (etc.). Si sabes dónde están los elementos en tu xml, ¡entonces supongo que estará bien! Solo pensé que valía la pena recordarlo.

root.iter()

ref: https://docs.python.org/3/library/xml.etree.elementtree.html#finding-interesting-elements "Element.findall () encuentra solo elementos con una etiqueta que son hijos directos del elemento actual. Element.find () encuentra el primer elemento secundario con una etiqueta particular y Element.text accede al contenido de texto del elemento. Element.get () accede a los atributos del elemento: "

Para obtener el espacio de nombres en su formato de espacio de nombres, por ejemplo {myNameSpace}, puede hacer lo siguiente:

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

De esta manera, puede usarlo más adelante en su código para buscar nodos, por ejemplo, usando la interpolación de cadenas (Python 3).

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

Mi solución se basa en el comentario de @Martijn Pieters:

register_namespace solo influye en la serialización, no en la búsqueda.

Entonces, el truco aquí es usar diferentes diccionarios para la serialización y la búsqueda.

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

Ahora, registre todos los espacios de nombres para analizar y escribir:

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

Para buscar ( find(), findall(), iterfind()) necesitamos un prefijo no vacío. Pase estas funciones a un diccionario modificado (aquí modifico el diccionario original, pero esto debe hacerse solo después de registrar los espacios de nombres).

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

Ahora, las funciones de la find()familia se pueden usar con el defaultprefijo:

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

pero

tree.write(destination)

no utiliza ningún prefijo para elementos en el espacio de nombres predeterminado.