如何在Python中解析XML?


Answers:


780

我建议ElementTree。相同的API还有其他兼容的实现,例如lxmlcElementTree在Python标准库本身中。但是在这种情况下,他们主要添加的是更高的速度-编程的难易程度取决于ElementTree定义的API 。

首先root从XML 构建Element实例,例如,使用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)

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


41
您似乎忽略了Python随附的xml.etree.cElementTree,并且在某些方面比lxml更快(“ lxml的iterparse()比cET中的慢一些” –来自lxml作者的电子邮件)。
约翰·马钦

7
ElementTree可以使用,并且包含在Python中。尽管XPath支持有限,但您无法遍历元素的父级,这会减慢开发速度(尤其是如果您不知道的话)。有关详细信息,请参见python xml查询获取父项
塞缪尔

11
lxml增加的不仅仅是速度。它提供了对诸如父节点,XML源中的行号之类的信息的轻松访问,这在某些情况下非常有用。
Saheel Godhane,2015年

13
似乎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 2015年

5
@Cristik大多数XML解析器似乎都是这种情况,请参见XML漏洞页面
gitaarik 2015年

427

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)

输出:

4
item1
item1
item2
item3
item4

9
您如何获得“ item1”的值?例如:<item name =“ item1”> Value1 </ item>
swmcdonnell 2013年

88
我想通了,以防万一有人有同样的问题。它是s.childNodes [0] .nodeValue
swmcdonnell

1
我喜欢您的示例,我想实现它,但在哪里可以找到可用的最小函数。我认为python minidom网站很烂。
德鲁丁

1
我也感到困惑,为什么它item直接从文档的顶层找到?如果提供路径(data->items),会不会更干净?因为,如果您也有data->secondSetOfItems一个也命名了节点item并且只想列出两组的其中之一,该item怎么办?
两栖动物2014年


240

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

感谢您提供@ibz信息,是的,实际上,如果源的格式不正确,解析器也将很难解析。

45
三年后,使用bs4,这是一个很好的解决方案,非常灵活,尤其是在源
格式

8
@YOU BeautifulStoneSoup已弃用。只需使用BeautifulSoup(source_xml, features="xml")
andilabs

5
再过了三年,我只是尝试使用来加载XML ElementTree,不幸的是,除非我在适当的地方调整源,但它无法解析,但是可以立即BeautifulSoup工作而不做任何更改!
ViKiG '16

8
@andi你的意思是“已弃用”。“折旧”是指其价值下降,通常是由于使用年限或正常使用引起的磨损。
jpmc26 2009年

98

有很多选择。如果速度和内存使用成为问题,则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所指出的那样cElementTreePython捆绑了它:

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

9
使用cElementTree有不利之处吗?这似乎很容易。
mayhewsw 2014年

6
显然,他们不想在OS X上使用该库,因为我花了15分钟以上的时间来弄清楚从何处下载该库,并且没有任何链接。缺少文档会阻止好的项目蓬勃发展,希望更多的人会意识到这一点。
Stunner 2014年

8
@Stunner:它在stdlib中,即,您无需下载任何内容。在Python 2上:from xml.etree import cElementTree as ElementTree。在Python 3上:(from xml.etree import ElementTree自动使用加速的C版本)
jfs

1
@mayhewsw花费更多的精力弄清楚如何有效地ElementTree用于特定任务。对于适合内存的文档,它使用minidom起来容易得多,并且对于较小的XML文档也可以正常工作。
Acumenus

44

我建议 为了简单起见, 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')])])])

3
同意 如果您不需要XPath或任何复杂的东西,则使用起来会容易得多(尤其是在解释器中);方便发布XML而不是JSON的REST API
Dan Passaro 2014年

4
请记住,OrderedDict不支持重复键。大多数XML充满了相同类型的多个同级兄弟(例如,一节中的所有段落,或栏中的所有类型)。因此,这仅适用于非常有限的特殊情况。
TextGeek

2
@TextGeek在这种情况下,result["foo"]["bar"]["type"]是所有<type>元素的列表,因此它仍然有效(即使结构可能有点意外)。
luator

38

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
瑞安·金斯特罗姆

20

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

+1是因为我正在寻找一个非验证的解析器,该解析器可用于奇怪的源字符。希望这会给我我想要的结果。
内森·T·雷施

1
该示例创建于'09,这就是它的完成方式。
Tor Valamo

13

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

13

为了增加另一种可能性,您可以使用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

有关解缠的更多信息,请参见“解 ”。

另外,如果您好奇,可以在“ Python和XML ”中找到使用XML和Python的工具列表。您还将看到以前的答案提到了最常见的答案。


是什么使解开与琐事不同?
亚伦·曼

我无法告诉您这两者之间的区别,因为我没有做过小事。
jchanger

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 ”。


7

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

6

xml.etree.ElementTree与lxml

这些是我会在选择它们之前使用的两个最常用库的一些优点。

xml.etree.ElementTree:

  1. 来自标准库:无需安装任何模块

xml文件

  1. 轻松编写XML声明:例如,您需要添加standalone="no"吗?
  2. 印刷精美:无需额外代码即可拥有漂亮的缩进 XML。
  3. 对象化功能:它使您可以像处理普通的Python对象层次结构一样使用XML .node

6
import xml.etree.ElementTree as ET
data = '''<foo>
           <bar>
               <type foobar="1"/>
               <type foobar="2"/>
          </bar>
       </foo>'''
tree = ET.fromstring(data)
lst = tree.findall('bar/type')
for item in lst:
    print item.get('foobar')

这将打印foobar属性的值。


5

我发现Python xml.domxml.dom.minidom非常简单。请记住,DOM不适用于大量XML,但是如果您的输入很小,那么它将很好用。


2

没有必要使用一个lib特定的API,如果你使用python-benedict。只需从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操作多种格式:Base64CSVJSONTOMLXMLYAMLquery-string

它已在GitHub上经过良好测试和开源。


0
#If the xml is in the form of a string as shown below then
from lxml  import etree, objectify
'''sample xml as a string with a name space {http://xmlns.abc.com}'''
message =b'<?xml version="1.0" encoding="UTF-8"?>\r\n<pa:Process xmlns:pa="http://xmlns.abc.com">\r\n\t<pa:firsttag>SAMPLE</pa:firsttag></pa:Process>\r\n'  # this is a sample xml which is a string


print('************message coversion and parsing starts*************')

message=message.decode('utf-8') 
message=message.replace('<?xml version="1.0" encoding="UTF-8"?>\r\n','') #replace is used to remove unwanted strings from the 'message'
message=message.replace('pa:Process>\r\n','pa:Process>')
print (message)

print ('******Parsing starts*************')
parser = etree.XMLParser(remove_blank_text=True) #the name space is removed here
root = etree.fromstring(message, parser) #parsing of xml happens here
print ('******Parsing completed************')


dict={}
for child in root: # parsed xml is iterated using a for loop and values are stored in a dictionary
    print(child.tag,child.text)
    print('****Derving from xml tree*****')
    if child.tag =="{http://xmlns.abc.com}firsttag":
        dict["FIRST_TAG"]=child.text
        print(dict)


### output
'''************message coversion and parsing starts*************
<pa:Process xmlns:pa="http://xmlns.abc.com">

    <pa:firsttag>SAMPLE</pa:firsttag></pa:Process>
******Parsing starts*************
******Parsing completed************
{http://xmlns.abc.com}firsttag SAMPLE
****Derving from xml tree*****
{'FIRST_TAG': 'SAMPLE'}'''

还请提供一些上下文,解释您的答案如何解决问题。不鼓励仅使用代码的答案。
Pedram Parsian

-1

如果源是xml文件,请像下面的示例一样说

<pa:Process xmlns:pa="http://sssss">
        <pa:firsttag>SAMPLE</pa:firsttag>
    </pa:Process>

您可以尝试以下代码

from lxml import etree, objectify
metadata = 'C:\\Users\\PROCS.xml' # this is sample xml file the contents are shown above
parser = etree.XMLParser(remove_blank_text=True) # this line removes the  name space from the xml in this sample the name space is --> http://sssss
tree = etree.parse(metadata, parser) # this line parses the xml file which is PROCS.xml
root = tree.getroot() # we get the root of xml which is process and iterate using a for loop
for elem in root.getiterator():
    if not hasattr(elem.tag, 'find'): continue  # (1)
    i = elem.tag.find('}')
    if i >= 0:
        elem.tag = elem.tag[i+1:]

dict={}  # a python dictionary is declared
for elem in tree.iter(): #iterating through the xml tree using a for loop
    if elem.tag =="firsttag": # if the tag name matches the name that is equated then the text in the tag is stored into the dictionary
        dict["FIRST_TAG"]=str(elem.text)
        print(dict)

输出将是

{'FIRST_TAG': 'SAMPLE'}
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.