用python中的名称空间解析XML通过＆＃x27; ElementTree＆＃x27;

Question

我有以下XML，我想使用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>

我想查找所有 owl：class 标签，然后提取所有 rdfs：rdfs：label的值内部实例。我使用以下代码：

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

由于名称空间，我会遇到以下错误。

SyntaxError: prefix 'owl' not found in prefix map

我尝试在，但我仍然无法正常工作，因为上述XML具有多个嵌套名称空间。

请让我知道如何更改代码以查找所有 OWL：class 标签。

Answer 1

您需要给出 .find（）， findall（） and iterfind（）方法一个显式命名空间词典：

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

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

前缀是仅是 在命名空间您传递的参数中查找。这意味着您可以使用您喜欢的任何名称空间前缀； API将 OWL分开：部分，在 namespaces 字典中查找相应的名称空间URL，然后更改搜索以查找XPath Expression {http：http：http：http：http：http：http：http：http：http：http： //www.w3.org/2002/07/owl} class 而不是。您当然也可以自己使用相同的语法：

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

另请参阅 用名称空间 e节解析xml。

如果您可以切换到 lxml library 情况更好；该库支持相同的ElementTree API，但在 .nsmap 属性中为您收集名称空间，并且通常具有较高的命名空间支持。

Answer 2

以下是如何使用 lxml 执行此操作，而无需对名称空间进行硬编码或扫描文本（正如 Martijn Pieters 提到的那样）：

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

更新：

5 年后我仍然遇到此问题的变体。正如我上面所示，lxml 有帮助，但并非在所有情况下都有帮助。在合并文档时，评论者对于这种技术可能有正确的观点，但我认为大多数人在简单地搜索文档时都遇到困难。

这是另一种情况以及我的处理方式：

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

没有前缀的 xmlns 意味着无前缀的标记获得此默认名称空间。这意味着当您搜索 Tag2 时，您需要包含命名空间才能找到它。但是，lxml 创建了一个以 None 作为键的 nsmap 条目，我找不到搜索它的方法。所以，我创建了一个像这样的新名称空间字典

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)

Answer 3

ElementTree标准库有用的答案

Note ：这是对Python的 elementTree.iterParse 函数，仅解析名称空间开始事件（ 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#'}

然后可以将字典作为参数传递给搜索函数：

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

Answer 4

要以其命名空间格式获取名称空间，例如 {myNamespace} ，您可以执行以下操作：

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

这样，您可以在代码中以后在代码上使用它来查找节点，例如使用字符串插值（Python 3） ）。

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

Answer 5

我一直在使用与此类似的代码，并发现它总是值得阅读文档......像往常一样！

findall() 只会查找当前标记的直接子元素的元素。所以，并不是全部。

尝试让代码与以下内容一起工作可能是值得的，特别是如果您正在处理大型且复杂的 xml 文件，以便子子元素（等）也包含在内。
如果您知道元素在 xml 中的位置，那么我想那就没问题了！只是觉得这值得记住。

root.iter()

参考： https://docs.python.org /3/library/xml.etree.elementtree.html#finding-interesting-elements
“Element.findall() 仅查找带有当前元素直接子元素的标记的元素。Element.find() 查找带有特定标记的第一个子元素，Element.text 访问元素的文本内容。Element.get()访问元素的属性：”

Answer 6

这基本上是戴维德·布鲁纳托（Davide Brunato）的答案，但是我发现他的答案存在严重的问题，默认名称空间是空字符串，至少在我的python 3.6安装中。我从他的代码中提取的功能对我有用：

from io import StringIO
from xml.etree import ElementTree
def get_namespaces(xml_string):
    namespaces = dict([
            node for _, node in ElementTree.iterparse(
                StringIO(xml_string), events=['start-ns']
            )
    ])
    namespaces["ns0"] = namespaces[""]
    return namespaces

其中 ns0 只是空名称空间的占位符，您可以替换为任何随机字符串。

如果我这样做：

my_namespaces = get_namespaces(my_schema)
root.findall('ns0:SomeTagWithDefaultNamespace', my_namespaces)

它还使用默认名称空间为标签提供了正确的答案。

Answer 7

我的解决方案基于@Martijn Pieters 的评论：

register_namespace 仅影响序列化，而不影响搜索。

所以这里的技巧是使用不同的字典进行序列化和搜索。

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

现在，注册所有命名空间以进行解析和写入：

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

为了搜索（find()、findall()、iterfind()），我们需要一个非-空前缀。向这些函数传递一个修改后的字典（这里我修改了原始字典，但这必须在命名空间注册后才能进行）。

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

现在，find() 系列中的函数可以与 default 前缀一起使用：

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

但

tree.write(destination)

不对默认命名空间中的元素使用任何前缀。

Answer 8

一个稍长的替代方法是创建另一个类 ElementNS ，它继承 ET.Element 并包含命名空间，然后为该类创建一个构造函数，并将其传递给解析器：

import xml.etree.ElementTree as ET


def parse_namespaces(source):
    return dict(node for _e, node in ET.iterparse(source, events=['start-ns']))


def create_element_factory(namespaces):
    def element_factory(tag, attrib):
        el = ElementNS(tag, attrib)
        el.namespaces = namespaces
        return el
    return element_factory


class ElementNS(ET.Element):
    namespaces = None

    # Patch methods to include namespaces
    def find(self, path):
        return super().find(path, self.namespaces)

    def findtext(self, path, default=None):
        return super().findtext(path, default, self.namespaces)

    def findall(self, path):
        return super().findall(path, self.namespaces)

    def iterfind(self, path):
        return super().iterfind(path, self.namespaces)


def parse(source):
    # Set up parser with namespaced element factory
    namespaces = parse_namespaces(source)
    element_factory = create_element_factory(namespaces)
    tree_builder = ET.TreeBuilder(element_factory=element_factory)
    parser = ET.XMLParser(target=tree_builder)
    element_tree = ET.ElementTree()

    return element_tree.parse(source, parser=parser)

然后 < code>findall 可以在不传递名称空间的情况下使用：

document = parse("filename")
document.findall("owl:Class")