Як перетворити рядок XML у словник?


125

У мене є програма, яка читає XML-документ із сокета. У мене документ xml зберігається в рядку, який я хотів би перетворити безпосередньо в словник Python, так само, як це робиться в simplejsonбібліотеці Django .

Візьмемо як приклад:

str ="<?xml version="1.0" ?><person><name>john</name><age>20</age></person"
dic_xml = convert_to_dic(str)

Тоді dic_xmlбуло б схоже{'person' : { 'name' : 'john', 'age' : 20 } }


str має кілька синтаксичних помилок. спробуйте: str = '<? xml version = "1.0"?> <person> <name> john </name> <age> 20 </age> </person>'
Кейр,

Відповіді:


58

Це чудовий модуль, який хтось створив. Я використовував його кілька разів. 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)

4
Ви можете використовувати "xmltodict" альтернативно
mrash

7
Я спробував це, і це набагато швидше, ніж xmltodict. Для розбору 80-міліметрового файлу xml знадобилося 7s, а xmltodict
Eddy

1
Підтверджено ... Я не перевіряв це на кожному крайовому випадку, але для моїх досить нескладних рядків XML це досить швидко (приблизно в 8 разів швидше, ніж xmltodictбібліотека). Недоліком є ​​те, що вам доведеться влаштовувати його самостійно в рамках свого проекту.
Дірк

10
Привіт, це прекрасно працює, додасть лише фрагмент для тих, хто не може знайти cElementTree, просто змініть перший рядок на: from xml.etree import cElementTree as ElementTree
Рафаель Агілар

2
Зниження голосування, оскільки є кращі відповіді, розміщені нижче, особливо в обробці декількох тегів з однаковою назвою.
Максим

280

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

22
Це фантастичний модуль.
zekel

2
ти щойно врятував мені багато зусиль. Зробив мій день.
LRE

3
також, для майбутніх googlenauts - я зміг використовувати це в App Engine, який, як я вважав, не дуже добре грав з більшістю xml-бібліотек в Python.
LRE

2
U просто вказує, що це збережений рядок unicode. Це ніяк не впливає на значення рядка.
Джошуа Олсон

2
Приємно. І так, @ypercube, є функція xmldict.unparse () для реверсу.
Датер

47

Наступні фрагменти фрагмента 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. :)


Оновлення

Якщо ви хочете зробити реверс , випромінювати рядок XML з JSON / dict , ви можете використовувати:

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

1
Thx для цього коду! Додаткова інформація: якщо ви використовуєте python 2.5, ви не можете використовувати розуміння словника, тому вам доведеться змінити рядок d = {t.tag: {k:v[0] if len(v) == 1 else v for k, v in dd.iteritems()}} на d = { t.tag: dict( (k, v[0] if len(v) == 1 else v) for k, v in dd.iteritems() ) }
M--

2
Для цього я протестував майже 10 фрагментів / модулів python / тощо. Цей найкращий я знайшов. Згідно з моїми тестами, це: 1) набагато швидше, ніж github.com/martinblech/xmltodict (на основі XML SAX api) 2) краще, ніж github.com/mcspring/XML2Dict, у якого є деякі проблеми, коли кілька дітей мають однакові імена 3 ) краще, ніж code.activestate.com/recipes/410469-xml-as-dictionary, який також мав невеликі проблеми і важливіше: 4) набагато коротший код, ніж усі попередні! Дякую @ K3 --- rnc
Basj

Це, безумовно, найбільш вичерпна відповідь, і вона працює на> 2.6, і досить гнучка. моє єдине питання полягає в тому, що текст може змінюватися там, де він знаходиться, залежно від того, є атрибут чи ні). Я також розмістив ще менше і жорстке рішення.
Ерік Аронесті

1
Якщо вам потрібно отримати впорядкований Dict з файлу XML, будь ласка, ви можете використовувати цей же приклад з деякими змінами (див моя відповідь нижче): stackoverflow.com/questions/2148119 / ...
serfer2

Це також досить витончено і швидко при використанні з cElementTreeабо lxml.etree. Зауважте, що при використанні Python 3 все .iteritems()потрібно змінити на .items()(те саме поведінка, але ключове слово змінилося з Python 2 на 3).
Дірк

25

Ця легка версія, хоч і не налаштовується, досить легко підлаштувати її за потребою та працює у старих пітонах. Також він жорсткий - значить, результати однакові незалежно від існування атрибутів.

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

2
Мені подобається це рішення. Простий і не вимагає зовнішніх губок.
MattK

6

Найновіші версії бібліотек PicklingTools (1.3.0 та 1.3.1) підтримують інструменти для перетворення з XML в диктофон Python.

Завантаження доступне тут: PicklingTools 1.3.1

Існує досить багато документації для перетворювачів тут : документація докладно описує всі рішень і проблем , які будуть виникати при перетворенні між XML і словниками Python (існує цілий ряд крайових випадків: атрибути, списки, анонімні списки, анонімні dicts, 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 разів швидше


Звичайно, тоді, якщо є 2 а, це не гарний формат.
Ерік Аронесті

1
Виглядає цікаво, але я ще не зрозумів, як призначено використовувати PicklingTools - це просто тарілка файлів вихідного коду, з яких я повинен знайти потрібні для своєї роботи, а потім скопіювати їх у свій проект? Немає модулів для завантаження чи нічого простішого?
Дірк

Я отримую: in peekIntoNextNWSChar c = self.is .read (1) AttributeError: 'str' об’єкт не має атрибута 'read'
sqp_125

5

Ви можете зробити це досить легко за допомогою 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 тут . Я сподіваюся, що це допомагає!


5

Відмова: Цей модифікований аналізатор XML був натхненний Адамом Кларком . Оригінальний аналізатор 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)    

3
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}}

2

Найпростіший у використанні XML-аналізатор для Python - ElementTree (станом на 2,5 рази і вище він знаходиться в стандартній бібліотеці xml.etree.ElementTree). Я не думаю, що є щось, що робить саме те, що ви хочете, з коробки. Було б досить тривіально написати щось, щоб робити те, що ви хочете, використовуючи ElementTree, але навіщо перетворювати на словник, а чому не просто використовувати ElementTree безпосередньо.


2

Код з 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)

2

З @ K3 --- rnc відповідь (найкраще для мене) Я додав невеликі модифікації, щоб отримати OrdersDict з XML-тексту (якийсь час має значення):

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

Сподіваюся, це допомагає;)


1

Ось посилання на рішення 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

Так. Тут відтворено код, якщо він повториться.
Джеймі Булл

0

Одного разу мені довелося проаналізувати та записати XML, який складався лише з елементів без атрибутів, тому відображення 1: 1 з XML у диктат було можливим легко. Це те, що я придумав у випадку, якщо комусь також не потрібні атрибути:

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

0

@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

0

Я змінив один із відповідей на свій смак і для роботи з декількома значеннями з одним і тим же тегом, наприклад, врахуйте наступний код 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'}}

-2

У мене є рекурсивний метод отримання словника з елемента lxml

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

1
У цьому рішенні відсутній деякий код, наприклад, імпорт та налаштування. Я отримав повідомлення 'str' об’єкт не має атрибута 'tag'
Кріс Нільсен
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.