Comment convertir une chaîne XML en dictionnaire ?

Question

J'ai un programme qui lit un document XML à partir d'un socket. Le document XML est stocké dans une chaîne de caractères que j'aimerais convertir directement en un dictionnaire Python, de la même manière que dans le programme Django simplejson bibliothèque.

Prenons un exemple :

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

Puis dic_xml ressemblerait à {'person' : { 'name' : 'john', 'age' : 20 } }

Answer 1

xmltodict (divulgation complète : je l'ai écrit) fait exactement ça :

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

Answer 2

C'est un excellent module que quelqu'un a créé. Je l'ai utilisé plusieurs fois. http://code.activestate.com/recipes/410469-xml-as-dictionary/

Voici le code du site web, au cas où le lien ne fonctionnerait pas.

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

Exemple d'utilisation :

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

//Ou, si vous voulez utiliser une chaîne XML :

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

Answer 3

L'extrait XML vers Python-dict suivant analyse les entités ainsi que les attributs suivants cette "spécification" XML-to-JSON . C'est la solution la plus générale pour traiter tous les cas de 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

Il est utilisé :

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

Le résultat de cet exemple (selon la "spécification" ci-dessus) devrait être le suivant :

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

Ce n'est pas forcément joli, mais c'est sans ambiguïté, et des entrées XML plus simples donnent un JSON plus simple :)

---

Mise à jour

Si vous voulez faire le inverser émettent un Chaîne XML à partir d'un JSON/dict vous pouvez l'utiliser :

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

Answer 4

Les versions les plus récentes des bibliothèques PicklingTools (1.3.0 et 1.3.1) prennent en charge les outils de conversion de XML en dictée Python.

Le téléchargement est disponible ici : PicklingTools 1.3.1

Il existe une documentation assez complète sur les convertisseurs. ici La documentation décrit en détail toutes les décisions et les problèmes qui se posent lors de la conversion entre XML et les dictionnaires Python (il existe un certain nombre de cas limites : attributs, listes, listes anonymes, dicts anonymes, eval, etc. que la plupart des convertisseurs ne gèrent pas). En général, cependant, les convertisseurs sont faciles à utiliser. Si un 'exemple.xml' contient :

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

Puis de le convertir en dictionnaire :

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

Il existe des outils de conversion en C++ et en Python : le C++ et le Python effectuent une conversion identique, mais le C++ est environ 60 fois plus rapide.

Answer 5

L'analyseur XML le plus facile à utiliser pour Python est ElementTree (à partir de la version 2.5x, il se trouve dans la bibliothèque standard xml.etree.ElementTree). Je ne pense pas qu'il y ait quelque chose qui fasse exactement ce que vous voulez. Il serait assez trivial d'écrire quelque chose pour faire ce que vous voulez en utilisant ElementTree, mais pourquoi convertir en dictionnaire, et pourquoi ne pas simplement utiliser ElementTree directement.