如何解析XML并获取特定节点属性的实例？

Question

我在XML中有很多行，我想获取特定节点属性的实例。

<foo>
   <bar>
      <type foobar="1"/>
      <type foobar="2"/>
   </bar>
</foo>

如何访问属性foobar的值？在这个例子中，我想要"1"和"2"。

- randombits

---

相关：如何在Python中使用字符串作为xml ElementTree的源？ - Stevoisiak

Answer 1

我建议使用ElementTree。有其他兼容的API实现，例如lxml和Python标准库中的cElementTree，但在这个上下文中，它们主要增加的是更快的速度 - 编程的易用性取决于API，而ElementTree定义了它。

首先从XML构建一个元素实例root，例如使用XML函数或使用类似以下的方法解析文件:

import xml.etree.ElementTree as ET
root = ET.parse('thefile.xml').getroot()

或者选择文档中所示的其他方法之一，详见ElementTree。然后执行以下操作：

for type_tag in root.findall('bar/type'):
    value = type_tag.get('foobar')
    print(value)

输出：

1
2

- Alex Martelli

---

你似乎忽略了 Python 自带的 xml.etree.cElementTree，它在某些方面比 lxml 更快（"lxml 的 iterparse() 比 cET 中的稍微慢一些" -- 来自 lxml 作者的电子邮件）。 - John Machin

ElementTree 可以在 Python 中使用，但是 XPath 支持有限。你不能遍历到一个元素的父节点，这可能会拖慢开发速度（特别是如果你不知道这一点）。详情请参见 python xml query get parent。 - Samuel

lxml 不仅具有高速度，还能提供方便的访问方式，例如获取父节点、XML源代码中的行号等信息，在多种情况下非常有用。 - Saheel Godhane

似乎ElementTree存在一些漏洞问题，这是文档中的引用：“警告：xml.etree.ElementTree模块不安全，无法防范恶意构造的数据。如果你需要解析不受信任或未经身份验证的数据，请参考XML漏洞。” - Cristik

大多数XML解析器似乎都存在这个问题，请参阅XML漏洞页面。 - gitaarik

Answer 2

minidom 是最快且相对直接的方法。

XML：

<data>
    <items>
        <item name="item1"></item>
        <item name="item2"></item>
        <item name="item3"></item>
        <item name="item4"></item>
    </items>
</data>

Python：

from xml.dom import minidom

dom = minidom.parse('items.xml')
elements = dom.getElementsByTagName('item')

print(f"There are {len(elements)} items:")

for element in elements:
    print(element.attributes['name'].value)

输出：

There are 4 items:
item1
item2
item3
item4

- Ryan Christensen

---

你如何获取“item1”的值？例如：<item name="item1">Value1</item>你怎么得到“item1”这个属性的值呢？以这个例子为例：<item name="item1">Value1</item> - swmcdonnell

minidom 的文档在哪里？我只找到了这个，但它并没有用：http://docs.python.org/2/library/xml.dom.minidom.html。 - amphibient

我也感到困惑，为什么它在文档的顶层找到了 "item"？如果你提供路径（data->items），那不是更好吗？因为如果你还有一个名为 "item" 的节点的 data->secondSetOfItems ，并且你只想列出其中一个集合中的 "item"，那该怎么办？ - amphibient

请参见以下链接，了解如何在Python中使用Minidom查找XML元素的特定路径：http://stackoverflow.com/questions/21124018/specific-pathing-for-finding-xml-elements-using-minidom-in-python - amphibient

语法在这里不起作用，您需要删除括号for s in itemlist: print(s.attributes['name'].value) - Alex Borsody

Answer 3

您可以使用BeautifulSoup：

from bs4 import BeautifulSoup

x="""<foo>
   <bar>
      <type foobar="1"/>
      <type foobar="2"/>
   </bar>
</foo>"""

y=BeautifulSoup(x)
>>> y.foo.bar.type["foobar"]
u'1'

>>> y.foo.bar.findAll("type")
[<type foobar="1"></type>, <type foobar="2"></type>]

>>> y.foo.bar.findAll("type")[0]["foobar"]
u'1'
>>> y.foo.bar.findAll("type")[1]["foobar"]
u'2'

- YOU

---

三年后使用bs4，这是一个很好的解决方案，非常灵活，特别是如果源代码格式不规范。 - cedbeu

BeautifulStoneSoup已经被弃用，请改用BeautifulSoup(source_xml, features="xml")来处理XML数据。请注意，在新方法中，source_xml是XML数据的字符串。 - andilabs

又过了3年，我尝试使用ElementTree加载XML，但不幸的是，除非我在源代码中进行调整，否则它无法解析。但是，BeautifulSoup可以直接使用，不需要任何更改！ - ViKiG

你的意思是“deprecated”，而非“depreciated”。在这里，“depreciated”表示价值下降，通常是由于年龄或正常使用造成的磨损。 - jpmc26

又过了3年，现在BS4已经不够快了。需要寻找更快的解决方案。 - Elvin Aghammadzada

Answer 4

有很多选择。如果速度和内存使用是问题，cElementTree看起来非常出色。与仅使用readlines读取文件相比，它几乎没有任何开销。

相关指标可以在下面的表格中找到，表格来自cElementTree网站：

library                         time    space
xml.dom.minidom (Python 2.1)    6.3 s   80000K
gnosis.objectify                2.0 s   22000k
xml.dom.minidom (Python 2.4)    1.4 s   53000k
ElementTree 1.2                 1.6 s   14500k  
ElementTree 1.2.4/1.3           1.1 s   14500k  
cDomlette (C extension)         0.540 s 20500k
PyRXPU (C extension)            0.175 s 10850k
libxml2 (C extension)           0.098 s 16000k
readlines (read as utf-8)       0.093 s 8850k
cElementTree (C extension)  --> 0.047 s 4900K <--
readlines (read as ascii)       0.032 s 5050k   

正如@jfs所指出的那样，cElementTree已经随Python捆绑:

• Python 2：from xml.etree import cElementTree as ElementTree。
• Python 3：from xml.etree import ElementTree（自动使用加速的C版本）。

- Cyrus

---

使用cElementTree是否有任何缺点？它似乎是一个毫无争议的选择。 - mayhewsw

显然他们不想在OS X上使用图书馆，因为我已经花费了15分钟以上的时间试图弄清楚从哪里下载它，而且没有一个链接有效。缺乏文档阻碍了好项目的发展，希望更多人能意识到这一点。 - Stunner

@Stunner：这个功能已经包含在 Python 标准库中，无需下载任何东西。在 Python 2 中使用以下语句：from xml.etree import cElementTree as ElementTree。在 Python 3 中使用以下语句：from xml.etree import ElementTree（自动使用加速的 C 版本）。 - jfs

@mayhewsw 对于特定任务，要想方设法高效地使用ElementTree需要付出更多的努力。对于适合存储在内存中的文档，使用minidom会更容易，并且对于较小的XML文档也可以正常工作。 - Asclepius

Answer 5

我建议使用xmltodict，以保持简单明了。

它可以将您的XML解析为OrderedDict。

>>> e = '<foo>
             <bar>
                 <type foobar="1"/>
                 <type foobar="2"/>
             </bar>
        </foo> '

>>> import xmltodict
>>> result = xmltodict.parse(e)
>>> result

OrderedDict([(u'foo', OrderedDict([(u'bar', OrderedDict([(u'type', [OrderedDict([(u'@foobar', u'1')]), OrderedDict([(u'@foobar', u'2')])])]))]))])

>>> result['foo']

OrderedDict([(u'bar', OrderedDict([(u'type', [OrderedDict([(u'@foobar', u'1')]), OrderedDict([(u'@foobar', u'2')])])]))])

>>> result['foo']['bar']

OrderedDict([(u'type', [OrderedDict([(u'@foobar', u'1')]), OrderedDict([(u'@foobar', u'2')])])])

- myildirim

---

同意。如果您不需要XPath或其他复杂功能，使用这个方法会更加简单（特别是在解释器中）；对于发布XML而不是JSON的REST API非常有用。 - Dan Passaro

请记住，OrderedDict 不支持重复的键。大多数 XML 文件都包含同类型的多个兄弟节点（比如一个章节中的所有段落，或者酒吧菜单中的所有种类）。因此，这种方法只适用于非常有限的特殊情况。 - TextGeek

在这种情况下，result["foo"]["bar"]["type"]是所有<type>元素的列表，因此它仍然有效（尽管结构可能有点出乎意料）。 - luator

自 2019 年以来没有更新。 - kolypto

我刚意识到自2019年以来没有更新了。我们需要找到一个活跃的分支。 - myildirim

Answer 6

lxml.objectify非常简单。

以您的示例文本为例：

from lxml import objectify
from collections import defaultdict

count = defaultdict(int)

root = objectify.fromstring(text)

for item in root.bar.type:
    count[item.attrib.get("foobar")] += 1

print dict(count)

输出：

{'1': 1, '2': 1}

- Ryan Ginstrom

---

count 存储每个项目的计数，使用默认键在字典中，因此您无需检查成员资格。您还可以尝试查看 collections.Counter。 - Ryan Ginstrom

Answer 7

Python提供与expat XML解析器的接口。

xml.parsers.expat

这是一个不做验证的解析器，所以无法捕获糟糕的XML文件。但如果您知道您的文件是正确的，那么这个解析器非常好用，您很可能会准确地获取到所需信息，并可以丢弃其余信息。

stringofxml = """<foo>
    <bar>
        <type arg="value" />
        <type arg="value" />
        <type arg="value" />
    </bar>
    <bar>
        <type arg="value" />
    </bar>
</foo>"""
count = 0
def start(name, attr):
    global count
    if name == 'type':
        count += 1

p = expat.ParserCreate()
p.StartElementHandler = start
p.Parse(stringofxml)

print count # prints 4

- Tor Valamo

Answer 8

还有一种可能性是使用 untangle，因为它是一个简单的将xml转换为Python对象的库。以下是一个示例：

安装：

pip install untangle

用法：

您的XML文件（稍作更改）：

<foo>
   <bar name="bar_name">
      <type foobar="1"/>
   </bar>
</foo>

使用 untangle 访问属性:

import untangle

obj = untangle.parse('/path_to_xml_file/file.xml')

print obj.foo.bar['name']
print obj.foo.bar.type['foobar']

输出结果将是：

bar_name
1

有关untangle的更多信息可以在"untangle"中找到。

此外，如果您好奇，可以在"Python和XML"中找到有关使用XML和Python的工具列表。您还会发现，最常见的工具已经被前面的回答提到了。

- jchanger

---

Untangle和minidom有什么区别？ - Aaron Mann

我无法告诉你这两者之间的区别，因为我没有使用过minidom。 - jchanger

Answer 9

我可能会建议使用declxml。

完全透明：我编写了该库，因为我正在寻找一种方法，在不需要编写数十行命令式解析/序列化代码（使用ElementTree）的情况下，在XML和Python数据结构之间进行转换。

使用declxml，您可以使用处理器来声明性地定义XML文档的结构以及如何在XML和Python数据结构之间映射。 处理器用于序列化和解析，以及基本级别的验证。

将其解析为Python数据结构很简单:

import declxml as xml

xml_string = """
<foo>
   <bar>
      <type foobar="1"/>
      <type foobar="2"/>
   </bar>
</foo>
"""

processor = xml.dictionary('foo', [
    xml.dictionary('bar', [
        xml.array(xml.integer('type', attribute='foobar'))
    ])
])

xml.parse_from_string(processor, xml_string)

它会生成以下输出：

{'bar': {'foobar': [1, 2]}}

你也可以使用相同的处理器将数据序列化为XML格式。

data = {'bar': {
    'foobar': [7, 3, 21, 16, 11]
}}

xml.serialize_to_string(processor, data, indent='    ')

会产生以下输出

<?xml version="1.0" ?>
<foo>
    <bar>
        <type foobar="7"/>
        <type foobar="3"/>
        <type foobar="21"/>
        <type foobar="16"/>
        <type foobar="11"/>
    </bar>
</foo>

如果您想使用对象而不是字典来进行工作，您也可以定义处理器来将数据转换为对象，并从对象中转换数据。

import declxml as xml

class Bar:

    def __init__(self):
        self.foobars = []

    def __repr__(self):
        return 'Bar(foobars={})'.format(self.foobars)


xml_string = """
<foo>
   <bar>
      <type foobar="1"/>
      <type foobar="2"/>
   </bar>
</foo>
"""

processor = xml.dictionary('foo', [
    xml.user_object('bar', Bar, [
        xml.array(xml.integer('type', attribute='foobar'), alias='foobars')
    ])
])

xml.parse_from_string(processor, xml_string)

它会产生以下输出

{'bar': Bar(foobars=[1, 2])}

- gatkin

Answer 10

这里是使用cElementTree的非常简单但有效的代码。

try:
    import cElementTree as ET
except ImportError:
  try:
    # Python 2.5 need to import a different module
    import xml.etree.cElementTree as ET
  except ImportError:
    exit_err("Failed to import cElementTree from any known place")      

def find_in_tree(tree, node):
    found = tree.find(node)
    if found == None:
        print "No %s in file" % node
        found = []
    return found  

# Parse a xml file (specify the path)
def_file = "xml_file_name.xml"
try:
    dom = ET.parse(open(def_file, "r"))
    root = dom.getroot()
except:
    exit_err("Unable to open and parse input definition file: " + def_file)

# Parse to find the child nodes list of node 'myNode'
fwdefs = find_in_tree(root,"myNode")

这是来自于 "Python解析XML"。

- Jan Kohila