题 如何在Python中解析XML?


我在包含xml的数据库中有很多行,我正在尝试编写一个Python脚本,该脚本将遍历这些行并计算特定节点属性的实例数量。例如,我的树看起来像:

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

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


761
2017-12-16 05:09


起源


有关: 来自字符串源的Python xml ElementTree? - Steven Vascellaro


答案:


我建议 ElementTree。还有其他相同API的兼容实现,例如 lxml,和 cElementTree 在Python标准库本身;但是,在这种情况下,他们主要添加的是更快的速度 - 编程部分的简易性取决于API ElementTree 定义。

构建Element实例后 e 来自XML,例如随着 XML 函数,或通过解析类似的文件

import xml.etree.ElementTree
e = xml.etree.ElementTree.parse('thefile.xml').getroot()

或者显示的任何其他方式 ElementTree,你只需要做类似的事情:

for atype in e.findall('type'):
    print(atype.get('foobar'))

和类似的,通常非常简单的代码模式。


583
2017-12-16 05:21



你似乎忽略了Python附带的xml.etree.cElementTree,并且在某些方面更快tham lxml(“lxml的iterparse()比cET中的更慢” - 来自lxml作者的电子邮件)。 - John Machin
ElementTree工作并包含在Python中。虽然XPath支持有限,但您无法遍历元素的父级,这会降低开发速度(特别是如果您不知道这一点)。看到 python xml查询得到父 详情。 - Samuel
lxml 增加速度以上。它提供了对父节点,XML源中的行号等信息的轻松访问,这些信息在几种情况下非常有用。 - Saheel Godhane
似乎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
@Cristik这似乎是大多数xml解析器的情况,请参阅 XML漏洞页面。 - rednaw


minidom 是最快捷,最直接的:

XML:

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

蟒蛇:

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)

OUTPUT

4
item1
item1
item2
item3
item4

372
2017-12-16 05:30



你如何获得“item1”的价值?例如:<item name =“item1”> Value1 </ item> - swmcdonnell
我想出来,万一有人有同样的问题。它是s.childNodes [0] .nodeValue - swmcdonnell
我喜欢你的例子,我想实现它,但我在哪里可以找到minidom函数。 python minidom网站在我看来很糟糕。 - Drewdin
我也很困惑为什么会发现 item 直接从文档的顶层?如果你提供它的路径,它会不会更清洁(data->items)?因为,如果你也有 data->secondSetOfItems 也有节点命名 item 而你想只列出两组中的一组 item? - amphibient
请参见 stackoverflow.com/questions/21124018/... - amphibient


您可以使用 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'

202
2017-12-16 05:12



实际上,有 BeautifulStoneSoup 在BeautifulSoup for XML中 - YOU
三年后使用bs4这是一个很好的解决方案,非常灵活,特别是如果源不是很好的话 - cedbeu
@您 BeautifulStoneSoup 被剥夺了。只是用 BeautifulSoup(source_xml, features="xml") - andilabs
另外3年后,我只是尝试使用加载XML ElementTree,不幸的是它无法解析,除非我在地方调整源但是 BeautifulSoup 刚刚工作,没有任何变化! - ViKiG
@ jpmc26大声笑,当然:) - andilabs


那里有很多选择。 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   

正如所指出的那样 @jfscElementTree 与Python捆绑在一起:

  • Python 2: from xml.etree import cElementTree as ElementTree
  • Python 3: from xml.etree import ElementTree (自动使用加速C版本)。

76
2017-10-10 17:44



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


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}

36
2017-12-16 10:42



什么在代码中做什么? - Clayton
count 使用默认密钥存储字典中每个项目的计数,因此您不必检查成员资格。你也可以尝试一下 collections.Counter。 - Ryan Ginstrom


我建议 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')])])])

30
2018-06-12 11:57



同意。如果你不需要XPath或任何复杂的东西,这使用起来要简单得多(特别是在解释器中);方便用于发布XML而不是JSON的REST API - Dan Passaro
请记住,OrderedDict不支持重复键。大多数XML都充满了相同类型的多个兄弟(例如,节中的所有段落,或者栏中的所有类型)。所以这只适用于非常有限的特殊情况。 - TextGeek


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

17
2017-12-16 05:28



+1因为我正在寻找一个非验证解析器,它可以与奇怪的源字符一起使用。希望这会给我我想要的结果。 - Nathan C. Tresch
这个例子是在09年制作的,这就是它的完成方式。 - Tor Valamo


这里有一个非常简单但有效的代码使用 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")

资源:

http://www.snip2code.com/Snippet/991/python-xml-parse?fromPage=1


8
2017-07-08 20:35





只是为了增加另一种可能性,你可以使用 排解,因为它是一个简单的xml-to-python-object库。这里有一个例子:

安装

pip install untangle

用法

你的xml文件(稍有改动):

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

使用访问属性 排解

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的更多信息 这里
另外(如果您很好奇),您可以找到使用XML和Python的工具列表 这里 (你也会看到以前的答案提到了最常见的)。


8
2018-03-17 09:10





我可能会建议 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])}

7
2017-09-04 17:40