Sérialiser Python dictionnaire XML [fermé]

il y a huTools.structured.dict2xml qui tente d'être compatible avec simplejson dans l'esprit. Vous pouvez lui donner des conseils sur la façon d'envelopper les sous-structures imbriquées. Vérifiez la documentation pour huTools.structured.dict2et qui retourne des objets ElementTree à la place si les chaînes retournées par dict2xml .

>>> data = {"kommiauftragsnr":2103839, "anliefertermin":"2009-11-25", "prioritaet": 7,
... "ort": u"Hücksenwagen",
... "positionen": [{"menge": 12, "artnr": "14640/XL", "posnr": 1},],
... "versandeinweisungen": [{"guid": "2103839-XalE", "bezeichner": "avisierung48h",
...                          "anweisung": "48h vor Anlieferung unter 0900-LOGISTIK avisieren"},
... ]}

>>> print ET.tostring(dict2et(data, 'kommiauftrag',
... listnames={'positionen': 'position', 'versandeinweisungen': 'versandeinweisung'}))
'''<kommiauftrag>
<anliefertermin>2009-11-25</anliefertermin>
<positionen>
    <position>
        <posnr>1</posnr>
        <menge>12</menge>
        <artnr>14640/XL</artnr>
    </position>
</positionen>
<ort>H&#xC3;&#xBC;cksenwagen</ort>
<versandeinweisungen>
    <versandeinweisung>
        <bezeichner>avisierung48h</bezeichner>
        <anweisung>48h vor Anlieferung unter 0900-LOGISTIK avisieren</anweisung>
        <guid>2103839-XalE</guid>
    </versandeinweisung>
</versandeinweisungen>
<prioritaet>7</prioritaet>
<kommiauftragsnr>2103839</kommiauftragsnr>
</kommiauftrag>'''

essayez celui-ci. seul problème je n'utilise pas les attributs (parce que je ne les aime pas)

dict2xml on pynuggets.wordpress.com

dict2xml sur activestate

from xml.dom.minidom import Document
import copy

class dict2xml(object):
    doc     = Document()

    def __init__(self, structure):
        if len(structure) == 1:
            rootName    = str(structure.keys()[0])
            self.root   = self.doc.createElement(rootName)

            self.doc.appendChild(self.root)
            self.build(self.root, structure[rootName])

    def build(self, father, structure):
        if type(structure) == dict:
            for k in structure:
                tag = self.doc.createElement(k)
                father.appendChild(tag)
                self.build(tag, structure[k])

        elif type(structure) == list:
            grandFather = father.parentNode
            tagName     = father.tagName
            grandFather.removeChild(father)
            for l in structure:
                tag = self.doc.createElement(tagName)
                self.build(tag, l)
                grandFather.appendChild(tag)

        else:
            data    = str(structure)
            tag     = self.doc.createTextNode(data)
            father.appendChild(tag)

    def display(self):
        print self.doc.toprettyxml(indent="  ")

if __name__ == '__main__':
    example = {'auftrag':{"kommiauftragsnr":2103839, "anliefertermin":"2009-11-25", "prioritaet": 7,"ort": u"Huecksenwagen","positionen": [{"menge": 12, "artnr": "14640/XL", "posnr": 1},],"versandeinweisungen": [{"guid": "2103839-XalE", "bezeichner": "avisierung48h","anweisung": "48h vor Anlieferung unter 0900-LOGISTIK avisieren"},]}}
    xml = dict2xml(example)
    xml.display()

j'ai écrit une fonction simple qui sérialise les dictionnaires en xml (moins de 30 lignes).

Utilisation:

mydict = {
    'name': 'The Andersson\'s',
    'size': 4,
    'children': {
        'total-age': 62,
        'child': [
            {
                'name': 'Tom',
                'sex': 'male',
            },
            {
                'name': 'Betty',
                'sex': 'female',
            }
        ]
    },
}
print(dict2xml(mydict, 'family'))

résultat:

<family name="The Andersson's" size="4">
        <children total-age="62">
                <child name="Tom" sex="male"/>
                <child name="Betty" sex="female"/>
        </children>
</family>

la source complète (y compris un exemple) peut être trouvée sur https://gist.github.com/reimund/5435343/

Note: cette fonction sérialisera les entrées du dictionnaire en attributs plutôt qu'en noeuds de texte. Il serait très facile de le modifier pour qu'il soutienne le texte.

la plupart des objets en Python sont représentés sous forme de dicts:

>>> class Fred(object) : 
...    def __init__(self, n) : self.n = n 
... 
>>> a = Fred(100)
>>> print a.__dict__ 
{'n': 100}

donc c'est similaire à se demander comment convertir dicts en XML. Il existe des outils pour convertir DACT en/de XML à:

http://www.picklingtools.com

voici un exemple simple:

    >>> import xmltools

    >>> d = {'a':1, 'b':2.2, 'c':'three' }
    >>> xx = xmltools.WriteToXMLString(d)
    >>> print xx
    <?xml version="1.0" encoding="UTF-8"?>
    <top>
      <a>1</a>
      <b>2.2</b>
      <c>three</c>
    </top>

il y a beaucoup de documentation sur le site web qui montre des exemples:

XML Manuel d'Outils

il est difficile de convertir" exactement " entre dicts et XML: Qu'est-ce qu'une liste? Que faites-vous avec les attributs? Comment manipulez-vous les clés numériques? Beaucoup de ces questions ont été abordées et sont discutés dans la documentation des outils XML (ci-dessus).

est-ce que la vitesse vous importe? Ou ne la facilité d'utilisation de la matière? Il y a un module C++ pur (tout est écrit en C++), un module Python pur (tout est écrit en Python), et un Python C Extension module (écrit en C++, mais enveloppé pour que Python puisse l'appeler). Le C++ et le module D'Extension C de Python sont des ordres de grandeur plus rapides, mais il faut bien sûr compiler pour aller de l'avant. Le module Python devrait fonctionner, mais est plus lent: