如何将 XML 字符串转换为字典？

小开

Python 中最容易使用的 XML 解析器是 ElementTree (截至2.5 x 及以上，它位于标准库 XML.etree 中。元素树)。我不认为有什么东西能完全达到你想要的效果。使用 ElementTree 编写一些东西来完成您想要完成的任务是相当琐碎的，但是为什么要转换成字典呢? 为什么不直接使用 ElementTree 呢。

小开

这里有一个链接到 ActiveState 解决方案-和代码，以防它再次消失。

==================================================
xmlreader.py:
==================================================
from xml.dom.minidom import parse




class NotTextNodeError:
pass




def getTextFromNode(node):
"""
scans through all children of node and gathers the
text. if node has non-text child-nodes, then
NotTextNodeError is raised.
"""
t = ""
for n in node.childNodes:
if n.nodeType == n.TEXT_NODE:
t += n.nodeValue
else:
raise NotTextNodeError
return t




def nodeToDic(node):
"""
nodeToDic() scans through the children of node and makes a
dictionary from the content.
three cases are differentiated:
- if the node contains no other nodes, it is a text-node
and {nodeName:text} is merged into the dictionary.
- if the node has the attribute "method" set to "true",
then it's children will be appended to a list and this
list is merged to the dictionary in the form: {nodeName:list}.
- else, nodeToDic() will call itself recursively on
the nodes children (merging {nodeName:nodeToDic()} to
the dictionary).
"""
dic = {}
for n in node.childNodes:
if n.nodeType != n.ELEMENT_NODE:
continue
if n.getAttribute("multiple") == "true":
# node with multiple children:
# put them in a list
l = []
for c in n.childNodes:
if c.nodeType != n.ELEMENT_NODE:
continue
l.append(nodeToDic(c))
dic.update({n.nodeName:l})
continue


try:
text = getTextFromNode(n)
except NotTextNodeError:
# 'normal' node
dic.update({n.nodeName:nodeToDic(n)})
continue


# text node
dic.update({n.nodeName:text})
continue
return dic




def readConfig(filename):
dom = parse(filename)
return nodeToDic(dom)










def test():
dic = readConfig("sample.xml")


print dic["Config"]["Name"]
print
for item in dic["Config"]["Items"]:
print "Item's Name:", item["Name"]
print "Item's Value:", item["Value"]


test()






==================================================
sample.xml:
==================================================
<?xml version="1.0" encoding="UTF-8"?>


<Config>
<Name>My Config File</Name>


<Items multiple="true">
<Item>
<Name>First Item</Name>
<Value>Value 1</Value>
</Item>
<Item>
<Name>Second Item</Name>
<Value>Value 2</Value>
</Item>
</Items>


</Config>






==================================================
output:
==================================================
My Config File


Item's Name: First Item
Item's Value: Value 1
Item's Name: Second Item
Item's Value: Value 2

小开

最佳答案

这是一个伟大的模块，有人创建。我已经使用它几次。 Http://code.activestate.com/recipes/410469-xml-as-dictionary/

这是网站的代码，以防链接出错。

from xml.etree import cElementTree as ElementTree


class XmlListConfig(list):
def __init__(self, aList):
for element in aList:
if element:
# treat like dict
if len(element) == 1 or element[0].tag != element[1].tag:
self.append(XmlDictConfig(element))
# treat like list
elif element[0].tag == element[1].tag:
self.append(XmlListConfig(element))
elif element.text:
text = element.text.strip()
if text:
self.append(text)




class XmlDictConfig(dict):
'''
Example usage:


>>> tree = ElementTree.parse('your_file.xml')
>>> root = tree.getroot()
>>> xmldict = XmlDictConfig(root)


Or, if you want to use an XML string:


>>> root = ElementTree.XML(xml_string)
>>> xmldict = XmlDictConfig(root)


And then use xmldict for what it is... a dict.
'''
def __init__(self, parent_element):
if parent_element.items():
self.update(dict(parent_element.items()))
for element in parent_element:
if element:
# treat like dict - we assume that if the first two tags
# in a series are different, then they are all different.
if len(element) == 1 or element[0].tag != element[1].tag:
aDict = XmlDictConfig(element)
# treat like list - we assume that if the first two tags
# in a series are the same, then the rest are the same.
else:
# here, we put the list in dictionary; the key is the
# tag name the list elements all share in common, and
# the value is the list itself
aDict = {element[0].tag: XmlListConfig(element)}
# if the tag has attributes, add those to the dict
if element.items():
aDict.update(dict(element.items()))
self.update({element.tag: aDict})
# this assumes that if you've got an attribute in a tag,
# you won't be having any text. This may or may not be a
# good idea -- time will tell. It works for the way we are
# currently doing XML configuration files...
elif element.items():
self.update({element.tag: dict(element.items())})
# finally, if there are no child tags and no attributes, extract
# the text
else:
self.update({element.tag: element.text})

示例用法:

tree = ElementTree.parse('your_file.xml')
root = tree.getroot()
xmldict = XmlDictConfig(root)

//或者，如果希望使用 XML 字符串:

root = ElementTree.XML(xml_string)
xmldict = XmlDictConfig(root)

小开

PicklingTools 库的最新版本(1.3.0和1.3.1)支持从 XML 转换为 Python dict 的工具。

下载地址: PicklingTools 1.3.1

对于转换器给你有相当多的文档: 文档详细描述了在 XML 和 Python 字典之间转换时将出现的所有决策和问题(有许多边缘情况: 属性、列表、匿名列表、匿名字典、 eval 等，大多数转换器都不能处理)。总的来说, 转换器很容易使用，如果‘ example.xml’包含:

<top>
<a>1</a>
<b>2.2</b>
<c>three</c>
</top>

然后把它转换成字典:

>>> from xmlloader import *
>>> example = file('example.xml', 'r')   # A document containing XML
>>> xl = StreamXMLLoader(example, 0)     # 0 = all defaults on operation
>>> result = xl.expect XML()
>>> print result
{'top': {'a': '1', 'c': 'three', 'b': '2.2'}}

有一些工具可以在 C + + 和 Python 中进行转换: C + + 和 Python 进行相同的转换，但是 C + + 的转换速度要快60倍

小开

有一次，我不得不解析和编写只由没有属性的元素组成的 XML，这样就可以轻松地实现从 XML 到 dict 的1:1映射。这是我想出来的，以防其他人也不需要属性:

def xmltodict(element):
if not isinstance(element, ElementTree.Element):
raise ValueError("must pass xml.etree.ElementTree.Element object")


def xmltodict_handler(parent_element):
result = dict()
for element in parent_element:
if len(element):
obj = xmltodict_handler(element)
else:
obj = element.text


if result.get(element.tag):
if hasattr(result[element.tag], "append"):
result[element.tag].append(obj)
else:
result[element.tag] = [result[element.tag], obj]
else:
result[element.tag] = obj
return result


return {element.tag: xmltodict_handler(element)}




def dicttoxml(element):
if not isinstance(element, dict):
raise ValueError("must pass dict type")
if len(element) != 1:
raise ValueError("dict must have exactly one root key")


def dicttoxml_handler(result, key, value):
if isinstance(value, list):
for e in value:
dicttoxml_handler(result, key, e)
elif isinstance(value, basestring):
elem = ElementTree.Element(key)
elem.text = value
result.append(elem)
elif isinstance(value, int) or isinstance(value, float):
elem = ElementTree.Element(key)
elem.text = str(value)
result.append(elem)
elif value is None:
result.append(ElementTree.Element(key))
else:
res = ElementTree.Element(key)
for k, v in value.items():
dicttoxml_handler(res, k, v)
result.append(res)


result = ElementTree.Element(element.keys()[0])
for key, value in element[element.keys()[0]].items():
dicttoxml_handler(result, key, value)
return result


def xmlfiletodict(filename):
return xmltodict(ElementTree.parse(filename).getroot())


def dicttoxmlfile(element, filename):
ElementTree.ElementTree(dicttoxml(element)).write(filename)


def xmlstringtodict(xmlstring):
return xmltodict(ElementTree.fromstring(xmlstring).getroot())


def dicttoxmlstring(element):
return ElementTree.tostring(dicttoxml(element))

小开

下面的 XML-to-Python-dict 片段解析这个 XML 到 JSON 的“规范”之后的实体和属性。它是处理所有 XML 情况的最通用的解决方案。

from collections import defaultdict


def etree_to_dict(t):
d = {t.tag: {} if t.attrib else None}
children = list(t)
if children:
dd = defaultdict(list)
for dc in map(etree_to_dict, children):
for k, v in dc.items():
dd[k].append(v)
d = {t.tag: {k:v[0] if len(v) == 1 else v for k, v in dd.items()}}
if t.attrib:
d[t.tag].update(('@' + k, v) for k, v in t.attrib.items())
if t.text:
text = t.text.strip()
if children or t.attrib:
if text:
d[t.tag]['#text'] = text
else:
d[t.tag] = text
return d

它被使用:

from xml.etree import cElementTree as ET
e = ET.XML('''
<root>
<e />
<e>text</e>
<e name="value" />
<e name="value">text</e>
<e> <a>text</a> <b>text</b> </e>
<e> <a>text</a> <a>text</a> </e>
<e> text <a>text</a> </e>
</root>
''')


from pprint import pprint
pprint(etree_to_dict(e))

这个示例的输出(根据上面链接的“规范”)应该是:

{'root': {'e': [None,
'text',
{'@name': 'value'},
{'#text': 'text', '@name': 'value'},
{'a': 'text', 'b': 'text'},
{'a': ['text', 'text']},
{'#text': 'text', 'a': 'text'}]}}

不一定漂亮，但是它是明确的，并且更简单的 XML 输入导致更简单的 JSON. :)

更新

如果你想做倒车，发射一个 来自 JSON/dict 的 XML 字符串，你可以使用:

try:
basestring
except NameError:  # python3
basestring = str


def dict_to_etree(d):
def _to_etree(d, root):
if not d:
pass
elif isinstance(d, basestring):
root.text = d
elif isinstance(d, dict):
for k,v in d.items():
assert isinstance(k, basestring)
if k.startswith('#'):
assert k == '#text' and isinstance(v, basestring)
root.text = v
elif k.startswith('@'):
assert isinstance(v, basestring)
root.set(k[1:], v)
elif isinstance(v, list):
for e in v:
_to_etree(e, ET.SubElement(root, k))
else:
_to_etree(v, ET.SubElement(root, k))
else:
raise TypeError('invalid type: ' + str(type(d)))
assert isinstance(d, dict) and len(d) == 1
tag, body = next(iter(d.items()))
node = ET.Element(tag)
_to_etree(body, node)
return ET.tostring(node)


pprint(dict_to_etree(d))

小开

Xmltodict (完全公开: 是我写的)确实做到了这一点:

xmltodict.parse("""
<?xml version="1.0" ?>
<person>
<name>john</name>
<age>20</age>
</person>""")
# {u'person': {u'age': u'20', u'name': u'john'}}

小开

def xml_to_dict(node):
u'''
@param node:lxml_node
@return: dict
'''


return {'tag': node.tag, 'text': node.text, 'attrib': node.attrib, 'children': {child.tag: xml_to_dict(child) for child in node}}

小开

@ dibrovsd: 如果 xml 有多个具有相同名称的标记，则解决方案将无法工作

根据您的想法，我稍微修改了一下代码，并将其用于一般节点而不是 root:

from collections import defaultdict
def xml2dict(node):
d, count = defaultdict(list), 1
for i in node:
d[i.tag + "_" + str(count)]['text'] = i.findtext('.')[0]
d[i.tag + "_" + str(count)]['attrib'] = i.attrib # attrib gives the list
d[i.tag + "_" + str(count)]['children'] = xml2dict(i) # it gives dict
return d

小开

来自 http://code.activestate.com/recipes/410469-xml-as-dictionary/的代码工作得很好，但是如果在层次结构中的给定位置有多个相同的元素，它就会覆盖它们。

我在它们之间添加了一个垫片，以查看在 self. update ()之前元素是否已经存在。如果是，则弹出现有条目并从现有和新的。任何后续的副本都将添加到列表中。

不确定这是否可以得到更优雅的处理，但它确实有效:

import xml.etree.ElementTree as ElementTree


class XmlDictConfig(dict):
def __init__(self, parent_element):
if parent_element.items():
self.updateShim(dict(parent_element.items()))
for element in parent_element:
if len(element):
aDict = XmlDictConfig(element)
if element.items():
aDict.updateShim(dict(element.items()))
self.updateShim({element.tag: aDict})
elif element.items():
self.updateShim({element.tag: dict(element.items())})
else:
self.updateShim({element.tag: element.text.strip()})


def updateShim (self, aDict ):
for key in aDict.keys():
if key in self:
value = self.pop(key)
if type(value) is not list:
listOfDicts = []
listOfDicts.append(value)
listOfDicts.append(aDict[key])
self.update({key: listOfDicts})


else:
value.append(aDict[key])
self.update({key: value})
else:
self.update(aDict)

小开

这个轻量级版本虽然不可配置，但是很容易根据需要进行裁剪，并且可以在旧的 Python 中工作。此外，它是严格的-这意味着结果是相同的，不管存在的属性。

import xml.etree.ElementTree as ET


from copy import copy


def dictify(r,root=True):
if root:
return {r.tag : dictify(r, False)}
d=copy(r.attrib)
if r.text:
d["_text"]=r.text
for x in r.findall("./*"):
if x.tag not in d:
d[x.tag]=[]
d[x.tag].append(dictify(x,False))
return d

所以:

root = ET.fromstring("<erik><a x='1'>v</a><a y='2'>w</a></erik>")


dictify(root)

结果:

{'erik': {'a': [{'x': '1', '_text': 'v'}, {'y': '2', '_text': 'w'}]}}

小开

使用 lxml 很容易做到这一点:

[sudo] pip install lxml

下面是我编写的一个递归函数，它为您完成了繁重的工作:

from lxml import objectify as xml_objectify




def xml_to_dict(xml_str):
""" Convert xml to dict, using lxml v3.4.2 xml processing library """
def xml_to_dict_recursion(xml_object):
dict_object = xml_object.__dict__
if not dict_object:
return xml_object
for key, value in dict_object.items():
dict_object[key] = xml_to_dict_recursion(value)
return dict_object
return xml_to_dict_recursion(xml_objectify.fromstring(xml_str))


xml_string = """<?xml version="1.0" encoding="UTF-8"?><Response><NewOrderResp>
<IndustryType>Test</IndustryType><SomeData><SomeNestedData1>1234</SomeNestedData1>
<SomeNestedData2>3455</SomeNestedData2></SomeData></NewOrderResp></Response>"""


print xml_to_dict(xml_string)

下面的变体保留了父键/元素:

def xml_to_dict(xml_str):
""" Convert xml to dict, using lxml v3.4.2 xml processing library, see http://lxml.de/ """
def xml_to_dict_recursion(xml_object):
dict_object = xml_object.__dict__
if not dict_object:  # if empty dict returned
return xml_object
for key, value in dict_object.items():
dict_object[key] = xml_to_dict_recursion(value)
return dict_object
xml_obj = objectify.fromstring(xml_str)
return {xml_obj.tag: xml_to_dict_recursion(xml_obj)}

如果您只想返回一个子树并将其转换为 dict，那么您可以使用 Element. find ()获取子树，然后将其转换为:

xml_obj.find('.//')  # lxml.objectify.ObjectifiedElement instance

请参阅 lxml 文档给你。我希望这有所帮助！

小开

从@K3——-rnc 回应(对我来说是最好的)中，我添加了一个小的修改，以便从 XML 文本中获得 OrderedDect (有时候顺序很重要) :

def etree_to_ordereddict(t):
d = OrderedDict()
d[t.tag] = OrderedDict() if t.attrib else None
children = list(t)
if children:
dd = OrderedDict()
for dc in map(etree_to_ordereddict, children):
for k, v in dc.iteritems():
if k not in dd:
dd[k] = list()
dd[k].append(v)
d = OrderedDict()
d[t.tag] = OrderedDict()
for k, v in dd.iteritems():
if len(v) == 1:
d[t.tag][k] = v[0]
else:
d[t.tag][k] = v
if t.attrib:
d[t.tag].update(('@' + k, v) for k, v in t.attrib.iteritems())
if t.text:
text = t.text.strip()
if children or t.attrib:
if text:
d[t.tag]['#text'] = text
else:
d[t.tag] = text
return d

下面是@K3——-rnc 示例，您可以使用它:

from xml.etree import cElementTree as ET
e = ET.XML('''
<root>
<e />
<e>text</e>
<e name="value" />
<e name="value">text</e>
<e> <a>text</a> <b>text</b> </e>
<e> <a>text</a> <a>text</a> </e>
<e> text <a>text</a> </e>
</root>
''')


from pprint import pprint
pprint(etree_to_ordereddict(e))

希望能有所帮助;)

小开

免责声明: 这个修改后的 XML 解析器受到了 Adam Clark的启发最初的 XML 解析器适用于大多数简单的情况。但是，它不适用于一些复杂的 XML 文件。我逐行调试了代码，最后修复了一些问题。如果你发现了一些虫子，请告诉我。我很高兴能修好它。

class XmlDictConfig(dict):
'''
Note: need to add a root into if no exising
Example usage:
>>> tree = ElementTree.parse('your_file.xml')
>>> root = tree.getroot()
>>> xmldict = XmlDictConfig(root)
Or, if you want to use an XML string:
>>> root = ElementTree.XML(xml_string)
>>> xmldict = XmlDictConfig(root)
And then use xmldict for what it is... a dict.
'''
def __init__(self, parent_element):
if parent_element.items():
self.updateShim( dict(parent_element.items()) )
for element in parent_element:
if len(element):
aDict = XmlDictConfig(element)
#   if element.items():
#   aDict.updateShim(dict(element.items()))
self.updateShim({element.tag: aDict})
elif element.items():    # items() is specialy for attribtes
elementattrib= element.items()
if element.text:
elementattrib.append((element.tag,element.text ))     # add tag:text if there exist
self.updateShim({element.tag: dict(elementattrib)})
else:
self.updateShim({element.tag: element.text})


def updateShim (self, aDict ):
for key in aDict.keys():   # keys() includes tag and attributes
if key in self:
value = self.pop(key)
if type(value) is not list:
listOfDicts = []
listOfDicts.append(value)
listOfDicts.append(aDict[key])
self.update({key: listOfDicts})
else:
value.append(aDict[key])
self.update({key: value})
else:
self.update({key:aDict[key]})  # it was self.update(aDict)

小开

我有一个递归方法从 lxml 元素获取字典

    def recursive_dict(element):
return (element.tag.split('}')[1],
dict(map(recursive_dict, element.getchildren()),
**element.attrib))

小开

我已经根据自己的喜好修改了其中一个答案，并使用具有相同标记的多个值，例如，请考虑以下保存在 XML.xml 文件中的 xml 代码

     <A>
<B>
<BB>inAB</BB>
<C>
<D>
<E>
inABCDE
</E>
<E>value2</E>
<E>value3</E>
</D>
<inCout-ofD>123</inCout-ofD>
</C>
</B>
<B>abc</B>
<F>F</F>
</A>

还有蟒蛇

import xml.etree.ElementTree as ET








class XMLToDictionary(dict):
def __init__(self, parentElement):
self.parentElement = parentElement
for child in list(parentElement):
child.text = child.text if (child.text != None) else  ' '
if len(child) == 0:
self.update(self._addToDict(key= child.tag, value = child.text.strip(), dict = self))
else:
innerChild = XMLToDictionary(parentElement=child)
self.update(self._addToDict(key=innerChild.parentElement.tag, value=innerChild, dict=self))


def getDict(self):
return {self.parentElement.tag: self}


class _addToDict(dict):
def __init__(self, key, value, dict):
if not key in dict:
self.update({key: value})
else:
identical = dict[key] if type(dict[key]) == list else [dict[key]]
self.update({key: identical + [value]})




tree = ET.parse('./XML.xml')
root = tree.getroot()
parseredDict = XMLToDictionary(root).getDict()
print(parseredDict)

输出是

{'A': {'B': [{'BB': 'inAB', 'C': {'D': {'E': ['inABCDE', 'value2', 'value3']}, 'inCout-ofD': '123'}}, 'abc'], 'F': 'F'}}

小开

我写了一个简单的递归函数:

from xml.etree import ElementTree
root = ElementTree.XML(xml_to_convert)


def xml_to_dict_recursive(root):


if len(root.getchildren()) == 0:
return {root.tag:root.text}
else:
return {root.tag:list(map(xml_to_dict_recursive, root.getchildren()))}

小开

另一种选择(为层次结构中的相同标记构建列表) :

from xml.etree import cElementTree as ElementTree


def xml_to_dict(xml, result):
for child in xml:
if len(child) == 0:
result[child.tag] = child.text
else:
if child.tag in result:
if not isinstance(result[child.tag], list):
result[child.tag] = [result[child.tag]]
result[child.tag].append(xml_to_dict(child, {}))
else:
result[child.tag] = xml_to_dict(child, {})
return result


xmlTree = ElementTree.parse('my_file.xml')
xmlRoot = xmlTree.getroot()
dictRoot = xml_to_dict(xmlRoot, {})
result = {xmlRoot.tag: dictRoot}

小开

超级简单的代码 # 按照下面的步骤，这很简单，不需要任何东西，将 XML 转换成字符串并使用 find 命令找到您正在查找的单词，如下所示 # Hope this is easy and simple

def xml_key(key, text1):
tx1 = "<" + key + ">"
tx2 = "</" + key + ">"
tx = text1.find(tx1)
ty = text1.find(tx2)
tx = tx + len(tx1)
tw = text1[tx:ty]
return(tw)


text1 = "<person><name>john</name><age>20</age></person>"
dict1 = {"name": xml_key("name",text1),"age":xml_key("age",text1)}


print(dict1)

产出: {‘ name’: ‘ john’}

小开

由 Firelion Cis发布的更新方法(因为不推荐使用 getchildren) :

from xml.etree import ElementTree
root = ElementTree.XML(xml_to_convert)


def xml_to_dict_recursive(root):


if len(list(root)) == 0:
return {root.tag:root.text}
else:
return {root.tag:list(map(xml_to_dict_recursive, list(root)))}

小开

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


def parse_xml(node):
ans = {}
for child in node:
if len(child) == 0:
ans[child.tag] = child.text
elif child.tag not in ans:
ans[child.tag] = parse_xml(child)
elif not isinstance(ans[child.tag], list):
ans[child.tag] = [ans[child.tag]]
ans[child.tag].append(parse_xml(child))
else:
ans[child.tag].append(parse_xml(child))
return ans

它将相同的字段合并到 list 中并压缩包含一个子字段的字段。