【问题标题】：How to parse XML and count instances of a particular node attribute?如何解析 XML 并计算特定节点属性的实例？
【发布时间】：2010-12-27 02:43:41
【问题描述】：

我在包含 XML 的数据库中有很多行，我正在尝试编写 Python 脚本来计算特定节点属性的实例。

我的树看起来像：

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

如何使用 Python 访问 XML 中的属性 "1" 和 "2"？

【问题讨论】：

相关：Python xml ElementTree from a string source?

标签： python xml

【解决方案1】：

我建议ElementTree。同一API还有其他兼容的实现，如Python标准库本身的lxml、cElementTree；但是，在这种情况下，他们主要增加的是更快的速度——编程部分的易用性取决于 ElementTree 定义的 API。

首先从 XML 构建一个 Element 实例 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)

还有类似的，通常非常简单的代码模式。

【讨论】：

您似乎忽略了 Python 附带的 xml.etree.cElementTree，并且在某些方面比 lxml 更快（“lxml 的 iterparse() 比 cET 中的稍慢”——来自的电子邮件lxml作者）。
ElementTree 工作并包含在 Python 中。虽然 XPath 支持有限，并且您不能遍历元素的父元素，这会减慢开发速度（尤其是如果您不知道这一点）。详情请见python xml query get parent。
lxml 增加的不仅仅是速度。它提供了对父节点、XML 源中的行号等信息的轻松访问，这些信息在多种情况下都非常有用。
似乎 ElementTree 存在一些漏洞问题，这是来自文档的引用：Warning The xml.etree.ElementTree module is not secure against maliciously constructed data. If you need to parse untrusted or unauthenticated data see XML vulnerabilities.
@Cristik 这似乎是大多数 xml 解析器的情况，请参阅XML vulnerabilities page。

【解决方案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
xmldoc = minidom.parse('items.xml')
itemlist = xmldoc.getElementsByTagName('item')
print(len(itemlist))
print(itemlist[0].attributes['name'].value)
for s in itemlist:
    print(s.attributes['name'].value)

输出：

4
item1
item1
item2
item3
item4

【讨论】：

如何获得“item1”的值？例如：Value1
minidom 的文档在哪里？我只发现了这个，但没有：docs.python.org/2/library/xml.dom.minidom.html
我也很困惑，为什么它直接从文档的顶层找到item？如果您提供路径 (data->items) 会不会更干净？因为，如果您也有 data->secondSetOfItems，它也有名为 item 的节点，并且您只想列出两组 item 中的一组，该怎么办？
请看stackoverflow.com/questions/21124018/…
语法在这里不起作用你需要删除括号for s in itemlist: print(s.attributes['name'].value)

【解决方案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'

【讨论】：

三年后使用 bs4，这是一个很好的解决方案，非常灵活，尤其是在源格式不正确的情况下
@YOU BeautifulStoneSoup 已弃用。只需使用BeautifulSoup(source_xml, features="xml")
又过了 3 年，我只是尝试使用 ElementTree 加载 XML，不幸的是它无法解析，除非我在某些地方调整源但 BeautifulSoup 立即工作而没有任何更改！
@andi 您的意思是“已弃用”。 “折旧”是指价值下降，通常是由于老化或正常使用造成的磨损。
再过 3 年，现在 BS4 还不够快。需要年龄。寻找更快的解决方案

【解决方案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 版本）。

【讨论】：

使用 cElementTree 有什么缺点吗？这似乎是一个明智的选择。
显然他们不想在 OS X 上使用该库，因为我花了超过 15 分钟试图找出从哪里下载它并且没有链接有效。缺乏文档会阻碍好的项目蓬勃发展，希望更多人能够意识到这一点。
@Stunner：它在 stdlib 中，也就是说，你不需要下载任何东西。在 Python 2 上：from xml.etree import cElementTree as ElementTree。在 Python 3 上：from xml.etree import ElementTree（自动使用加速的 C 版本）
@mayhewsw 要想清楚如何有效地将ElementTree 用于特定任务，需要付出更多的努力。对于适合内存的文档，使用minidom 会容易得多，并且对于较小的 XML 文档也适用。

【解决方案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')])])])

【讨论】：

同意。如果您不需要 XPath 或任何复杂的东西，使用起来会简单得多（尤其是在解释器中）；对于发布 XML 而不是 JSON 的 REST API 很方便
请记住 OrderedDict 不支持重复键。大多数 XML 都充满了相同类型的多个同级（例如，一个部分中的所有段落，或者您的栏中的所有类型）。所以这只适用于非常有限的特殊情况。
@TextGeek 在这种情况下，result["foo"]["bar"]["type"] 是所有 <type> 元素的列表，因此它仍然有效（尽管结构可能有点出乎意料）。
自 2019 年以来没有更新
我刚刚意识到自 2019 年以来没有更新。我们需要找到一个活跃的分叉。

【解决方案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}

【讨论】：

count 使用默认键将每个项目的计数存储在字典中，因此您不必检查成员资格。您也可以尝试查看collections.Counter。

【解决方案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

【讨论】：

【解决方案8】：

只是为了增加另一种可能性，您可以使用 untangle，因为它是一个简单的 xml-to-python-object 库。这里有一个例子：

安装：

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 and XML”中找到用于处理 XML 和 Python 的工具列表。您还会看到之前的答案中提到了最常见的。

【讨论】：

是什么让 untangle 与 minidom 不同？
我无法告诉你这两者之间的区别，因为我没有使用过 minidom。

【解决方案9】：

我可能会建议declxml。

完全披露：我编写这个库是因为我正在寻找一种在 XML 和 Python 数据结构之间进行转换的方法，而无需使用 ElementTree 编写数十行命令式解析/序列化代码。

使用 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])}

【讨论】：

【解决方案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 parse”。

【讨论】：

【解决方案11】：

XML：

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

Python 代码：

import xml.etree.cElementTree as ET

tree = ET.parse("foo.xml")
root = tree.getroot() 
root_tag = root.tag
print(root_tag) 

for form in root.findall("./bar/type"):
    x=(form.attrib)
    z=list(x)
    for i in z:
        print(x[i])

输出：

foo
1
2

【讨论】：

【解决方案12】：

如果您使用python-benedict，则无需使用特定于库的 API。只需从您的 XML 初始化一个新实例并轻松管理它，因为它是 dict 子类。

安装很简单：pip install python-benedict

from benedict import benedict as bdict

# data-source can be an url, a filepath or data-string (as in this example)
data_source = """
<foo>
   <bar>
      <type foobar="1"/>
      <type foobar="2"/>
   </bar>
</foo>"""

data = bdict.from_xml(data_source)
t_list = data['foo.bar'] # yes, keypath supported
for t in t_list:
   print(t['@foobar'])

它支持并规范化多种格式的 I/O 操作：Base64、CSV、JSON、TOML、XML、YAML 和 query-string。

它在GitHub 上经过良好测试和开源。披露：我是作者。

【讨论】：

【解决方案13】：

xml.etree.ElementTree 与 lxml

这些是两个最常用的库的一些优点，在选择它们之前我会有所了解。