您可以使用好喝的汤：

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'

同样的API还有其他兼容的实现，比如Python标准库中的#1和cElementTree；但是，在这种情况下，它们主要增加的是更快的速度——编程的难易程度取决于API，ElementTree定义。

首先从XML构建一个Element实例root，例如使用xml函数，或者通过解析包含以下内容的文件：

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

或者#0中显示的许多其他方法中的任何一种。然后做类似的事情：

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

输出：

12

Python有一个到exatXML解析器的接口。

xml.parsers.expat

这是一个非验证解析器，所以坏的XML不会被捕获。但是，如果您知道您的文件是正确的，那么这是非常好的，您可能会得到您想要的确切信息，并且您可以随时丢弃其余的信息。

stringofxml = """<foo><bar><type arg="value" /><type arg="value" /><type arg="value" /></bar><bar><type arg="value" /></bar></foo>"""count = 0def start(name, attr):global countif name == 'type':count += 1
p = expat.ParserCreate()p.StartElementHandler = startp.Parse(stringofxml)
print count # prints 4

#0是最快和相当直接的前进。

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:item1item2item3item4

lxml.objectify真的很简单。

以您的示例文本：

from lxml import objectifyfrom 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}

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

try:import cElementTree as ETexcept ImportError:try:# Python 2.5 need to import a different moduleimport xml.etree.cElementTree as ETexcept 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" % nodefound = []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解析”。

如果速度和内存使用是一个问题，单元树看起来很棒。与简单地使用readlines读取文件相比，它的开销很小。

相关指标可以在下表中找到，从单元树网站复制：

library                         time    spacexml.dom.minidom (Python 2.1)    6.3 s   80000Kgnosis.objectify                2.0 s   22000kxml.dom.minidom (Python 2.4)    1.4 s   53000kElementTree 1.2                 1.6 s   14500kElementTree 1.2.4/1.3           1.1 s   14500kcDomlette (C extension)         0.540 s 20500kPyRXPU (C extension)            0.175 s 10850klibxml2 (C extension)           0.098 s 16000kreadlines (read as utf-8)       0.093 s 8850kcElementTree (C extension)  --> 0.047 s 4900K <--readlines (read as ascii)       0.032 s 5050k

正如@陈志立所指出的，cElementTree与Python捆绑在一起：

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

为了简单起见，我建议XML字典。

它将您的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')])])])

import xml.etree.ElementTree as ETdata = '''<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属性的值。

只是为了增加另一种可能性，您可以使用解开，因为它是一个简单的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_name1

有关untangle的更多信息可以在“解开”中找到。

此外，如果您好奇，您可以在“python和xml”中找到使用XML和Python的工具列表。您还会看到前面的答案提到了最常见的工具。

我建议Decxml。

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

使用Decxml，您可以使用处理器以声明方式定义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])}

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.tagprint(root_tag)
for form in root.findall("./bar/type"):x=(form.attrib)z=list(x)for i in z:print(x[i])

输出：

foo12

xml.etree.ElementTree vs. lxml

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

xml.etree.元素树：

1. 从标准库开始：不需要安装任何模块

lxml

1. 轻松编写xml声明：例如，您需要添加standalone="no"吗？
2. 印得真漂亮：您可以拥有一个不错的缩进 XML，而无需额外的代码。
3. 目标化功能：它允许您像处理普通Python对象层次结构.node一样使用XML。
4. sourceline允许轻松获取您正在使用的XML元素的行。
5. 您还可以使用内置的XSD模式检查器。

如果您使用python-benedict，则有无需使用lib特定的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 supportedfor t in t_list:print(t['@foobar'])

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

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

#If the xml is in the form of a string as shown below thenfrom 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 hereroot = etree.fromstring(message, parser) #parsing of xml happens hereprint ('******Parsing completed************')

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

如果源是一个xml文件，比如这个示例

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

您可以尝试以下代码

from lxml import etree, objectifymetadata = 'C:\\Users\\PROCS.xml' # this is sample xml file the contents are shown aboveparser = etree.XMLParser(remove_blank_text=True) # this line removes the  name space from the xml in this sample the name space is --> http://ssssstree = etree.parse(metadata, parser) # this line parses the xml file which is PROCS.xmlroot = tree.getroot() # we get the root of xml which is process and iterate using a for loopfor 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 declaredfor elem in tree.iter(): #iterating through the xml tree using a for loopif elem.tag =="firsttag": # if the tag name matches the name that is equated then the text in the tag is stored into the dictionarydict["FIRST_TAG"]=str(elem.text)print(dict)

输出将是

{'FIRST_TAG': 'SAMPLE'}

如果您不想使用任何外部库或第三方工具，请尝试以下代码。

• 这将解析xml到pythondictionary
• 这也将解析xml attrbutes
• 这也将解析像<tag/>这样的空标签和只有像<tag var=val/>这样的属性的标签

代码

import re
def getdict(content):res=re.findall("<(?P<var>\S*)(?P<attr>[^/>]*)(?:(?:>(?P<val>.*?)</(?P=var)>)|(?:/>))",content)if len(res)>=1:attreg="(?P<avr>\S+?)(?:(?:=(?P<quote>['\"])(?P<avl>.*?)(?P=quote))|(?:=(?P<avl1>.*?)(?:\s|$))|(?P<avl2>[\s]+)|$)"if len(res)>1:return [{i[0]:[{"@attributes":[{j[0]:(j[2] or j[3] or j[4])} for j in re.findall(attreg,i[1].strip())]},{"$values":getdict(i[2])}]} for i in res]else:return {res[0]:[{"@attributes":[{j[0]:(j[2] or j[3] or j[4])} for j in re.findall(attreg,res[1].strip())]},{"$values":getdict(res[2])}]}else:return content
with open("test.xml","r") as f:print(getdict(f.read().replace('\n','')))

样本输入

<details class="4b" count=1 boy><name type="firstname">John</name><age>13</age><hobby>Coin collection</hobby><hobby>Stamp collection</hobby><address><country>USA</country><state>CA</state></address></details><details empty="True"/><details/><details class="4a" count=2 girl><name type="firstname">Samantha</name><age>13</age><hobby>Fishing</hobby><hobby>Chess</hobby><address current="no"><country>Australia</country><state>NSW</state></address></details>

产出（美化）

[{"details": [{"@attributes": [{"class": "4b"},{"count": "1"},{"boy": ""}]},{"$values": [{"name": [{"@attributes": [{"type": "firstname"}]},{"$values": "John"}]},{"age": [{"@attributes": []},{"$values": "13"}]},{"hobby": [{"@attributes": []},{"$values": "Coin collection"}]},{"hobby": [{"@attributes": []},{"$values": "Stamp collection"}]},{"address": [{"@attributes": []},{"$values": [{"country": [{"@attributes": []},{"$values": "USA"}]},{"state": [{"@attributes": []},{"$values": "CA"}]}]}]}]}]},{"details": [{"@attributes": [{"empty": "True"}]},{"$values": ""}]},{"details": [{"@attributes": []},{"$values": ""}]},{"details": [{"@attributes": [{"class": "4a"},{"count": "2"},{"girl": ""}]},{"$values": [{"name": [{"@attributes": [{"type": "firstname"}]},{"$values": "Samantha"}]},{"age": [{"@attributes": []},{"$values": "13"}]},{"hobby": [{"@attributes": []},{"$values": "Fishing"}]},{"hobby": [{"@attributes": []},{"$values": "Chess"}]},{"address": [{"@attributes": [{"current": "no"}]},{"$values": [{"country": [{"@attributes": []},{"$values": "Australia"}]},{"state": [{"@attributes": []},{"$values": "NSW"}]}]}]}]}]}]

simplified_scrapy：一个新的lib，我用过之后就爱上了它。我推荐给你。

from simplified_scrapy import SimplifiedDocxml = '''<foo><bar><type foobar="1"/><type foobar="2"/></bar></foo>'''
doc = SimplifiedDoc(xml)types = doc.selects('bar>type')print (len(types)) # 2print (types.foobar) # ['1', '2']print (doc.selects('bar>type>foobar()')) # ['1', '2']

这里是更多示例。这个库很容易使用。