Analisando XML com espaço para nome em Python via 'ElementTree'

Eu tenho o seguinte XML que eu quero analisar 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>

Quero encontrar todas as owl:Classtags e extrair o valor de todas as rdfs:labelinstâncias dentro delas. Estou usando o seguinte código:

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

Por causa do espaço para nome, estou recebendo o seguinte erro.

SyntaxError: prefix 'owl' not found in prefix map

Tentei ler o documento em http://effbot.org/zone/element-namespaces.htm, mas ainda não consigo fazer isso funcionar, pois o XML acima tem vários namespaces aninhados.

Por favor, deixe-me saber como alterar o código para encontrar todas as owl:Classtags.

O ElementTree não é muito inteligente sobre namespaces. Você precisa dar o .find(), findall()e iterfind()métodos de um dicionário namespace explícito. Isso não está muito bem documentado:

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

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

Os prefixos são procurados apenas no namespacesparâmetro que você passa. Isso significa que você pode usar qualquer prefixo de espaço para nome que desejar; a API separa a owl:parte, pesquisa o URL do espaço para nome correspondente no namespacesdicionário e altera a pesquisa para procurar a expressão XPath {http://www.w3.org/2002/07/owl}Class. Você também pode usar a mesma sintaxe, é claro:

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

Se você pode mudar para a lxmlbiblioteca, as coisas são melhores; essa biblioteca suporta a mesma API ElementTree, mas coleta espaços de nome para você em um .nsmapatributo nos elementos.

Veja como fazer isso com o lxml sem precisar codificar os namespaces ou digitalizar o texto para eles (como Martijn Pieters menciona):

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

ATUALIZAÇÃO :

Cinco anos depois, ainda estou enfrentando variações desse problema. O lxml ajuda como mostrei acima, mas não em todos os casos. Os comentaristas podem ter um ponto válido em relação a essa técnica quando se trata de mesclar documentos, mas acho que a maioria das pessoas está tendo dificuldade em simplesmente pesquisar documentos.

Aqui está outro caso e como eu lidei com isso:

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

xmlns sem prefixo significa que tags não prefixadas obtêm esse espaço de nome padrão. Isso significa que, ao procurar o Tag2, é necessário incluir o espaço para nome para encontrá-lo. No entanto, o lxml cria uma entrada nsmap com None como chave e não consegui encontrar uma maneira de procurá-la. Então, eu criei um novo dicionário de namespace 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 é uma resposta útil para a biblioteca padrão ElementTree do Python sem usar espaços para nome codificados.

Para extrair prefixos e URI do espaço para nome dos dados XML, você pode usar a ElementTree.iterparsefunção, analisando apenas os eventos start do espaço para nome ( 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#'}

Em seguida, o dicionário pode ser passado como argumento para as funções de pesquisa:

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

Eu tenho usado um código semelhante a este e descobri que sempre vale a pena ler a documentação ... como sempre!

findall () encontrará apenas elementos que são filhos diretos da tag atual . Então, não é realmente tudo.

Pode valer a pena tentar fazer com que seu código funcione com o seguinte, especialmente se você estiver lidando com arquivos xml grandes e complexos, para que os subelementos (etc.) também sejam incluídos. Se você se conhece onde estão os elementos no seu xml, acho que tudo ficará bem! Apenas pensei que valia a pena lembrar.

root.iter()

ref: https://docs.python.org/3/library/xml.etree.elementtree.html#finding-interesting-elements "Element.findall () encontra apenas elementos com uma tag que são filhos diretos do elemento atual. Element.find () localiza o primeiro filho com uma tag específica e Element.text acessa o conteúdo de texto do elemento. Element.get () acessa os atributos do elemento: "

Para obter o espaço para nome em seu formato, por exemplo {myNameSpace}, você pode fazer o seguinte:

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

Dessa forma, você pode usá-lo posteriormente em seu código para encontrar nós, por exemplo, usando interpolação de strings (Python 3).

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

Minha solução é baseada no comentário de @Martijn Pieters:

register_namespace influencia apenas a serialização, não a pesquisa.

Portanto, o truque aqui é usar dicionários diferentes para serialização e pesquisa.

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

Agora, registre todos os namespaces para análise e gravação:

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

Para pesquisar ( find(), findall(), iterfind()) precisamos de um prefixo não vazio. Passe essas funções para um dicionário modificado (aqui modifico o dicionário original, mas isso só deve ser feito após o registro dos namespaces).

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

Agora, as funções da find()família podem ser usadas com o defaultprefixo:

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

mas

tree.write(destination)

não usa nenhum prefixo para elementos no espaço para nome padrão.