Question

我正在寻找使用ElementTree的XML到字典解析器，我已经找到了一些但它们排除了属性，在我的例子中我有很多属性。

Answer 1

以下XML-to-Python-dict片段解析实体以及this XML-to-JSON "specification"之后的属性：

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

d = etree_to_dict(e)

pprint(d)

此示例的输出（按照上面链接的“规范”）应为：

{'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, str): root.text = d elif isinstance(d, dict): for k,v in d.items(): assert isinstance(k, str) if k.startswith('#'): assert k == '#text' and isinstance(v, str) root.text = v elif k.startswith('@'): assert isinstance(v, str) 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: assert d == 'invalid type', (type(d), d) assert isinstance(d, dict) and len(d) == 1 tag, body = next(iter(d.items())) node = ET.Element(tag) _to_etree(body, node) return node print(ET.tostring(dict_to_etree(d)))

Answer 2

def etree_to_dict(t):
    d = {t.tag : map(etree_to_dict, t.iterchildren())}
    d.update(('@' + k, v) for k, v in t.attrib.iteritems())
    d['text'] = t.text
    return d

呼叫

tree = etree.parse("some_file.xml")
etree_to_dict(tree.getroot())

只要您实际上没有属性text，这就有效;如果这样做，则更改函数体中的第三行以使用其他键。此外，您无法使用此处理混合内容。

（在LXML上测试。）

Answer 3

基于@larsmans，如果你不需要属性，这会给你一个更紧凑的字典 -

def etree_to_dict(t):
    return {t.tag : map(etree_to_dict, t.iterchildren()) or t.text}

Answer 4

为了从/到python词典转换XML，xmltodict对我来说非常有用：

import xmltodict

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>
'''

xdict = xmltodict.parse(xml)

xdict现在看起来像

OrderedDict([('root',
              OrderedDict([('e',
                            [None,
                             'text',
                             OrderedDict([('@name', 'value')]),
                             OrderedDict([('@name', 'value'),
                                          ('#text', 'text')]),
                             OrderedDict([('a', 'text'), ('b', 'text')]),
                             OrderedDict([('a', ['text', 'text'])]),
                             OrderedDict([('a', 'text'),
                                          ('#text', 'text')])])]))])

如果您的XML数据不是原始字符串/字节形式，而是在某个ElementTree对象中，则只需将其作为字符串打印出来并再次使用xmldict.parse。例如，如果您使用lxml来处理XML文档，那么

from lxml import etree
e = etree.XML(xml)
xmltodict.parse(etree.tostring(e))

将生成与上面相同的字典。

Answer 5

from lxml import etree, objectify
def formatXML(parent):
    """
    Recursive operation which returns a tree formated
    as dicts and lists.
    Decision to add a list is to find the 'List' word
    in the actual parent tag.   
    """
    ret = {}
    if parent.items(): ret.update(dict(parent.items()))
    if parent.text: ret['__content__'] = parent.text
    if ('List' in parent.tag):
        ret['__list__'] = []
        for element in parent:
            ret['__list__'].append(formatXML(element))
    else:
        for element in parent:
            ret[element.tag] = formatXML(element)
    return ret

Answer 6

在@larsmans上构建，如果生成的键包含xml命名空间信息，则可以在写入dict之前删除它。将变量xmlns设置为等于命名空间并将其值除去。

xmlns = '{http://foo.namespaceinfo.com}'

def etree_to_dict(t):
    if xmlns in t.tag:
        t.tag = t.tag.lstrip(xmlns)
    if d = {t.tag : map(etree_to_dict, t.iterchildren())}
    d.update(('@' + k, v) for k, v in t.attrib.iteritems())
    d['text'] = t.text
    return d

Answer 7

这是xml中的一个简单数据结构（另存为file.xml）：

<?xml version="1.0" encoding="UTF-8"?>
<Data>
  <Person>
    <First>John</First>
    <Last>Smith</Last>
  </Person>
  <Person>
    <First>Jane</First>
    <Last>Doe</Last>
  </Person>
</Data>

以下是从中创建字典对象列表的代码。

from lxml import etree
tree = etree.parse('file.xml')
root = tree.getroot()
datadict = []
for item in root:
    d = {}
    for elem in item:
        d[elem.tag]=elem.text
    datadict.append(d)

datadict现在包含：

[{'First': 'John', 'Last': 'Smith'},{'First': 'Jane', 'Last': 'Doe'}]

可以像这样访问：

datadict[0]['First']
'John'
datadict[1]['Last']
'Doe'

Answer 8

您可以使用此代码段直接将其从xml转换为字典

import xml.etree.ElementTree as ET

xml = ('<xml>' +
       '<first_name>Dean Christian</first_name>' +
       '<middle_name>Christian</middle_name>' +
       '<last_name>Armada</last_name>' +
       '</xml>')
root = ET.fromstring(xml)

x = {x.tag: root.find(x.tag).text  for x in root._children}
# returns {'first_name': 'Dean Christian', 'last_name': 'Armada', 'middle_name': 'Christian'}

Answer 9

lxml文档提供了how to map an XML tree into a dict of dicts的示例：

def recursive_dict(element):
    return element.tag, dict(map(recursive_dict, element)) or element.text

请注意，这个漂亮的快捷方式转换器希望子代具有唯一的标记名，并将以无提示的方式覆盖先前同级兄弟姐妹中包含的所有数据。对于xml到dict转换的任何实际应用，您最好编写自己的更长版本。

您可以创建一个自定义词典来处理以前的同名同级兄弟姐妹：

from collections import UserDict, namedtuple
from lxml.etree import QName

class XmlDict(UserDict):
    """Custom dict to avoid preceding siblings with the same name being overwritten."""

    __ROOTELM = namedtuple('RootElm', ['tag', 'node'])

    def __setitem__(self, key, value):
        if key in self:
            if type(self.data[key]) is list:
                self.data[key].append(value)
            else:
                self.data[key] = [self.data[key], value]
        else:
            self.data[key] = value

    @staticmethod
    def xml2dict(element):
        """Converts an ElementTree Element to a dictionary."""
        elm = XmlDict.__ROOTELM(
            tag=QName(element).localname,
            node=XmlDict(map(XmlDict.xml2dict, element)) or element.text,
    )
    return elm

用法

from lxml import etree
from pprint import pprint

xml_f = b"""<?xml version="1.0" encoding="UTF-8"?>
            <Data>
              <Person>
                <First>John</First>
                <Last>Smith</Last>
              </Person>
              <Person>
                <First>Jane</First>
                <Last>Doe</Last>
              </Person>
            </Data>"""

elm = etree.fromstring(xml_f)
d = XmlDict.xml2dict(elm)

输出

In [3]: pprint(d)
RootElm(tag='Data', node={'Person': [{'First': 'John', 'Last': 'Smith'}, {'First': 'Jane', 'Last': 'Doe'}]})

In [4]: pprint(d.node)
{'Person': [{'First': 'John', 'Last': 'Smith'},
            {'First': 'Jane', 'Last': 'Doe'}]}

Answer 10

已经有几个答案，但这里有一个紧凑的解决方案，它使用 dict-comprehension 映射属性、文本值和子项：

def etree_to_dict(t):
    if type(t) is ET.ElementTree: return etree_to_dict(t.getroot())
    return {
        **t.attrib,
        'text': t.text,
        **{e.tag: etree_to_dict(e) for e in t}
    }

使用ElementTree将xml转换为字典

10 个答案:

更新

用法

输出