konvertieren von xml-python-dict

Ich versuche, mich ein dict-Klasse zur Verarbeitung eines xml-aber nicht weiterkommen, habe ich wirklich die Ideen ausgehen. Wenn jemand könnte die Anleitung zu diesem Thema wäre toll.

code so weit entwickelt:

class XMLResponse(dict):
    def __init__(self, xml):
        self.result = True
        self.message = ''
        pass

    def __setattr__(self, name, val):
        self[name] = val

    def __getattr__(self, name):
        if name in self:
            return self[name]
        return None

message="<?xml version="1.0"?><note><to>Tove</to><from>Jani</from><heading>Reminder</heading><body>Don't forget me this weekend!</body></note>"
XMLResponse(message)

Es scheint, dass diese Frage beantwortet wurde, bevor: stackoverflow.com/questions/2148119/...
Was ist Ihre gewünschte Ergebnis?
Ich verstehe nicht deine Idee Freund
finden Sie die Lösung, es vor, aber ich hatte keine positive
so etwas wie dieses: {"":"Tove", "from":"Jani", "Position":"Erinnerung", "body":"vergiss mich nicht an diesem Wochenende!"}

InformationsquelleAutor Alfredo | 2013-06-18

18

Können Sie Gebrauch machen von xmltodict Modul:
```
import xmltodict

message = """<?xml version="1.0"?><note><to>Tove</to><from>Jani</from><heading>Reminder</heading><body>Don't forget me this weekend!</body></note>"""
print xmltodict.parse(message)['note']
```
ergibt ein OrderedDict:
```
OrderedDict([(u'to', u'Tove'), (u'from', u'Jani'), (u'heading', u'Reminder'), (u'body', u"Don't forget me this weekend!")])
```
die umgewandelt werden können, dict, wenn die Reihenfolge egal:
```
print dict(xmltodict.parse(message)['note'])
```
Drucke:
```
{u'body': u"Don't forget me this weekend!", u'to': u'Tove', u'from': u'Jani', u'heading': u'Reminder'}
```
vielen Dank für die Hilfe, die ich wirklich zu schätzen, aber ich denke immer noch, oder vielmehr zu schauen, wie es durchgeführt, ohne dass ein zusätzliches Modul, ich werde es trotzdem versuchen.
Wenn Sie sehen wollen, wie es zu tun, ohne ein zusätzliches Modul, warum nicht einen Blick auf die Quelle für xmltodict? Es ist ein paar hundert Zeilen sauber, gut kommentiert Python-code. Und es ist mit Sicherheit besser als jede quick & dirty hack, jemand kommt mit für eine Antwort auf SO.
war nur zu sehen wie Sie sich entwickeln, das Modul, vielleicht ist es ein guter Weg, um zu starten.
Angesichts der Lizenzierung und dev Geschichte der Modul, wahrscheinlich der beste Weg zu beginnen ist, nur Gabel und spielen mit Ihrer Gabel. Auf diese Weise, wenn Sie mit etwas kommen, fehlte in der ursprünglichen, und, die Sie freigeben möchten mit der Welt, können Sie stellen Sie einfach einen pull-request zurück flussaufwärts.
wenn ich einige code entwickelt, für diese habe ich kein problem, Sie teilen keine Informationen mit der community.

InformationsquelleAutor alecxe
6

Sollten Sie checkout

https://github.com/martinblech/xmltodict

Ich denke, es ist einer der besten standard-Handler für xml dict, die ich gesehen habe.

Aber ich sollte Sie warnen, xml und dict sind absolut nicht kompatibel Datenstrukturen

danke für deine Antwort. Ich denke auch nicht vollständig kompatibel Strukturen, und es ist keine Lösung so schnell wie in der Vergangenheit.
Die einzige große Ausgabe für einfache Fälle ist, dass die XML-Knoten können Attribute haben als auch sub-Knoten, und Sie haben zu entscheiden, wie Sie zu vertreten. xmltodict stellt Attribute als Knoten mit einer @ Präfix auf den Namen, das ist eine Möglichkeit, um das problem zu lösen, aber es gibt auch andere Möglichkeiten—z.B. die, die Sie behandeln können Knoten mit __getitem__ und attrs mit __getattr__.

InformationsquelleAutor dusual

Würden Sie denken, jetzt hätten wir eine gute Antwort auf diesen einen, aber wir offenbar nicht.
Nach der überprüfung halben Dutzend ähnliche Fragen auf stackoverflow, hier ist was für mich gearbeitet:

from lxml import etree
# arrow is an awesome lib for dealing with dates in python
import arrow


# converts an etree to dict, useful to convert xml to dict
def etree2dict(tree):
    root, contents = recursive_dict(tree)
    return {root: contents}


def recursive_dict(element):
    if element.attrib and 'type' in element.attrib and element.attrib['type'] == "array":
        return element.tag, [(dict(map(recursive_dict, child)) or getElementValue(child)) for child in element]
    else:
        return element.tag, dict(map(recursive_dict, element)) or getElementValue(element)


def getElementValue(element):
    if element.text:
        if element.attrib and 'type' in element.attrib:
            attr_type = element.attrib.get('type')
            if attr_type == 'integer':
                return int(element.text.strip())
            if attr_type == 'float':
                return float(element.text.strip())
            if attr_type == 'boolean':
                return element.text.lower().strip() == 'true'
            if attr_type == 'datetime':
                return arrow.get(element.text.strip()).timestamp
        else:
            return element.text
    elif element.attrib:
        if 'nil' in element.attrib:
            return None
        else:
            return element.attrib
    else:
        return None

und dies ist, wie Sie es verwenden:

from lxml import etree

message="""<?xml version="1.0"?><note><to>Tove</to><from>Jani</from><heading>Reminder</heading><body>Don't forget me this weekend!</body></note>"''
tree = etree.fromstring(message)
etree2dict(tree)

Hoffe es hilft 🙂

Dieser arbeitete für mich. Ich hatte, um .getroot() zu tree im Aufruf, wie in etree2dict(tree.getroot()). Vielleicht deshalb, weil ich Lesen von XML aus einer Datei und nicht aus einem string? In jedem Fall, großartige Antwort.

InformationsquelleAutor Fred

Können Sie die lxml-Bibliothek. Konvertieren Sie die Zeichenfolge in ein xml-Objekt mit objectify.fromstring und dann schauen die Objekte, die dir Methode. Zum Beispiel:

from lxml import objectify

xml_string = """<?xml version="1.0" encoding="UTF-8"?><NewOrderResp><IndustryType></IndustryType><MessageType>R</MessageType><MerchantID>700000005894</MerchantID><TerminalID>0031</TerminalID><CardBrand>AMEX</CardBrand><AccountNum>3456732800000010</AccountNum><OrderID>TESTORDER1</OrderID><TxRefNum>55A69B278025130CD36B3A95435AA84DC45363</TxRefNum><TxRefIdx>10</TxRefIdx><ProcStatus>0</ProcStatus><ApprovalStatus>1</ApprovalStatus><RespCode></RespCode><AVSRespCode></AVSRespCode><CVV2RespCode></CVV2RespCode><AuthCode></AuthCode><RecurringAdviceCd></RecurringAdviceCd><CAVVRespCode></CAVVRespCode><StatusMsg></StatusMsg><RespMsg></RespMsg><HostRespCode></HostRespCode><HostAVSRespCode></HostAVSRespCode><HostCVV2RespCode></HostCVV2RespCode><CustomerRefNum>A51C5B2B1811E5991208</CustomerRefNum><CustomerName>BOB STEVEN</CustomerName><ProfileProcStatus>0</ProfileProcStatus><CustomerProfileMessage>Profile Created</CustomerProfileMessage><RespTime>13055</RespTime><PartialAuthOccurred></PartialAuthOccurred><RequestedAmount></RequestedAmount><RedeemedAmount></RedeemedAmount><RemainingBalance></RemainingBalance><CountryFraudFilterStatus></CountryFraudFilterStatus><IsoCountryCode></IsoCountryCode></NewOrderResp>"""

xml_object = objectify.fromstring(xml_string)

print xml_object.__dict__

Konvertierung der xml-Objekt dict zurückkehren würde, ein dict:

{'RemainingBalance': u'', 'AVSRespCode': u'', 'RequestedAmount': u'', 'AccountNum': 3456732800000010, 'IsoCountryCode': u'', 'HostCVV2RespCode': u'', 'TerminalID': 31, 'CVV2RespCode': u'', 'RespMsg': u'', 'CardBrand': 'AMEX', 'MerchantID': 700000005894, 'RespCode': u'', 'ProfileProcStatus': 0, 'CustomerName': 'BOB STEVEN', 'PartialAuthOccurred': u'', 'MessageType': 'R', 'ProcStatus': 0, 'TxRefIdx': 10, 'RecurringAdviceCd': u'', 'IndustryType': u'', 'OrderID': 'TESTORDER1', 'StatusMsg': u'', 'ApprovalStatus': 1, 'RedeemedAmount': u'', 'CountryFraudFilterStatus': u'', 'TxRefNum': '55A69B278025130CD36B3A95435AA84DC45363', 'CustomerRefNum': 'A51C5B2B1811E5991208', 'CustomerProfileMessage': 'Profile Created', 'AuthCode': u'', 'RespTime': 13055, 'HostAVSRespCode': u'', 'CAVVRespCode': u'', 'HostRespCode': u''}

Den xml-string den ich verwendet ist eine Antwort von paymentech payment-gateway nur zu zeigen, dass eine Reale Welt Beispiel.

Beachten Sie auch, dass das obige Beispiel ist nicht rekursiv, also wenn es dicts innerhalb dicts Sie haben zu tun, einige Rekursion. Finden Sie die rekursive Funktion, die ich schrieb, die Sie verwenden können:

from lxml import objectify

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

def xml_to_dict(xml_str):
    return xml_to_dict_recursion(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)

Hier eine Variante, die die Beibehaltung der übergeordneten Schlüssel /element:

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

Und wenn Sie wollen, liefern nur einen Teilbaum und konvertieren Sie es in dict, können Sie Element.finden() :

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

Gibt es viele Möglichkeiten, dies zu erreichen, aber dieses ist groß, wenn Sie bereits mit lxml. In diesem Beispiel lxml-3.4.2 verwendet wurde.Prost!

InformationsquelleAutor radtek

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.