แปลง XML เป็น JSON โดยใช้ Python หรือไม่

ฉันเห็นส่วนแบ่งที่ไม่ยุติธรรมของ XML-> รหัส JSON บนเว็บและเมื่อมีการโต้ตอบกับผู้ใช้ของสแต็กสักเล็กน้อยฉันเชื่อว่าฝูงชนนี้สามารถช่วยได้มากกว่าหน้าแรก ๆ ของผลลัพธ์ Google ที่สามารถทำได้

ดังนั้นเราจึงแยกวิเคราะห์ฟีดสภาพอากาศและเราจำเป็นต้องสร้างวิดเจ็ตสภาพอากาศบนเว็บไซต์จำนวนมาก ตอนนี้เรากำลังค้นหาโซลูชันที่ใช้ Python

ฟีด RSS weather.comสาธารณะนี้เป็นตัวอย่างที่ดีของสิ่งที่เราแยกวิเคราะห์ ( ฟีด weather.com ที่แท้จริงของเรามีข้อมูลเพิ่มเติมเนื่องจากการเป็นหุ้นส่วนกับพวกเขา )

สรุปเราควรแปลง XML เป็น JSON โดยใช้ Python อย่างไร

ไม่มีการแมป "หนึ่งต่อหนึ่ง" ระหว่าง XML และ JSON ดังนั้นการแปลงรายการหนึ่งเป็นรายการอื่นจำเป็นต้องมีความเข้าใจในสิ่งที่คุณต้องการจะทำกับผลลัพธ์

ที่ถูกกล่าวว่าห้องสมุดมาตรฐาน Python มีหลายโมดูลสำหรับการแยกวิเคราะห์ XML (รวมถึง DOM, SAX และ ElementTree) ในฐานะที่เป็นของงูใหญ่ 2.6 การสนับสนุนสำหรับการแปลงงูหลามโครงสร้างข้อมูลไปและกลับจาก JSON จะรวมอยู่ในโมดูลjson

ดังนั้นโครงสร้างพื้นฐานอยู่ที่นั่น

xmltodict (การเปิดเผยเต็มรูปแบบ: ฉันเขียนไว้) สามารถช่วยคุณแปลง XML เป็นโครงสร้าง dict + list + string ตาม"มาตรฐาน"นี้ เป็นแบบExpat- based ดังนั้นมันจึงเร็วมากและไม่จำเป็นต้องโหลดทรี XML ทั้งหมดในหน่วยความจำ

เมื่อคุณมีโครงสร้างข้อมูลนั้นคุณสามารถทำให้เป็นอนุกรมกับ JSON:

import xmltodict, json

o = xmltodict.parse('<e> <a>text</a> <a>text</a> </e>')
json.dumps(o) # '{"e": {"a": ["text", "text"]}}'

คุณสามารถใช้xmljsonห้องสมุดการแปลงใช้ที่แตกต่างกันการประชุม JSON XML

ตัวอย่างเช่น XML นี้:

<p id="1">text</p>

แปลผ่านการประชุม BadgerFishเป็นสิ่งนี้:

{
  'p': {
    '@id': 1,
    '$': 'text'
  }
}

และผ่านการประชุม GDataลงในสิ่งนี้ (ไม่รองรับคุณสมบัติ):

{
  'p': {
    '$t': 'text'
  }
}

... และผ่านการประชุมของ Parkerในสิ่งนี้ (ไม่รองรับคุณสมบัติ):

{
  'p': 'text'
}

เป็นไปได้ที่จะแปลงจาก XML เป็น JSON และจาก JSON เป็น XML โดยใช้หลักการเดียวกัน:

>>> import json, xmljson
>>> from lxml.etree import fromstring, tostring
>>> xml = fromstring('<p id="1">text</p>')
>>> json.dumps(xmljson.badgerfish.data(xml))
'{"p": {"@id": 1, "$": "text"}}'
>>> xmljson.parker.etree({'ul': {'li': [1, 2]}})
# Creates [<ul><li>1</li><li>2</li></ul>]

การเปิดเผย: ฉันเขียนห้องสมุดนี้ หวังว่ามันจะช่วยผู้ค้นหาในอนาคต

หากบางครั้งคุณได้รับรหัสตอบกลับเพียงอย่างเดียวแทนที่จะเป็นข้อมูลทั้งหมดดังนั้นข้อผิดพลาดเช่น json parseจะอยู่ที่นั่นดังนั้นคุณต้องแปลงเป็นข้อความ

import xmltodict

data = requests.get(url)
xpars = xmltodict.parse(data.text)
json = json.dumps(xpars)
print json 

นี่คือรหัสที่ฉันสร้างขึ้นสำหรับสิ่งนั้น ไม่มีการแยกวิเคราะห์เนื้อหาเพียงแปลงธรรมดา

from xml.dom import minidom
import simplejson as json
def parse_element(element):
    dict_data = dict()
    if element.nodeType == element.TEXT_NODE:
        dict_data['data'] = element.data
    if element.nodeType not in [element.TEXT_NODE, element.DOCUMENT_NODE, 
                                element.DOCUMENT_TYPE_NODE]:
        for item in element.attributes.items():
            dict_data[item[0]] = item[1]
    if element.nodeType not in [element.TEXT_NODE, element.DOCUMENT_TYPE_NODE]:
        for child in element.childNodes:
            child_name, child_dict = parse_element(child)
            if child_name in dict_data:
                try:
                    dict_data[child_name].append(child_dict)
                except AttributeError:
                    dict_data[child_name] = [dict_data[child_name], child_dict]
            else:
                dict_data[child_name] = child_dict 
    return element.nodeName, dict_data

if __name__ == '__main__':
    dom = minidom.parse('data.xml')
    f = open('data.json', 'w')
    f.write(json.dumps(parse_element(dom), sort_keys=True, indent=4))
    f.close()

มีวิธีการขนส่งมาร์กอัพที่ใช้ XML เป็น JSON ซึ่งอนุญาตให้แปลงเป็นแบบดั้งเดิมโดยไม่สูญเสียไป ดูhttp://jsonml.org/

มันเป็น XSLT ของ JSON ฉันหวังว่าคุณจะพบว่ามีประโยชน์

ถึงใครก็ตามที่อาจยังต้องการสิ่งนี้ นี่คือรหัสที่ง่ายกว่าและใหม่กว่าสำหรับทำการแปลง

from xml.etree import ElementTree as ET

xml    = ET.parse('FILE_NAME.xml')
parsed = parseXmlToJson(xml)


def parseXmlToJson(xml):
  response = {}

  for child in list(xml):
    if len(list(child)) > 0:
      response[child.tag] = parseXmlToJson(child)
    else:
      response[child.tag] = child.text or ''

    # one-liner equivalent
    # response[child.tag] = parseXmlToJson(child) if len(list(child)) > 0 else child.text or ''

  return response

คุณอาจต้องการที่จะมีลักษณะที่http://designtheory.org/library/extrep/designdb-1.0.pdf โปรเจ็กต์นี้เริ่มต้นด้วยการแปลง XML เป็น JSON ของไลบรารีขนาดใหญ่ของไฟล์ XML มีการวิจัยมากมายในการแปลงและการทำแผนที่ XML ที่ใช้งานง่ายที่สุด -> JSON ถูกสร้างขึ้น (อธิบายไว้ในเอกสารก่อนหน้านี้) โดยสรุปแปลงทุกอย่างเป็นวัตถุ JSON และวางบล็อกการทำซ้ำเป็นรายการของวัตถุ

วัตถุหมายถึงคู่ของคีย์ / ค่า (พจนานุกรมใน Python, hashmap ใน Java, วัตถุใน JavaScript)

ไม่มีการแมปกลับไปที่ XML เพื่อรับเอกสารที่เหมือนกันเหตุผลคือไม่ทราบว่าคู่คีย์ / ค่าเป็นแอตทริบิวต์หรือ an <key>value</key>ดังนั้นข้อมูลจะสูญหาย

หากคุณถามฉันคุณลักษณะต่างๆจะเริ่มแฮ็ค จากนั้นอีกครั้งพวกเขาทำงานได้ดีสำหรับ HTML

วิธีที่ง่ายที่สุดอาจเป็นเพียงการแยกวิเคราะห์ XML ลงในพจนานุกรมแล้วจัดลำดับด้วย simplejson

ฉันขอแนะนำไม่ให้ทำการแปลงโดยตรง แปลง XML เป็นวัตถุจากนั้นเป็นวัตถุ JSON

ในความคิดของฉันนี้ให้คำจำกัดความสะอาดของ XML และ JSON สอดคล้อง

ต้องใช้เวลาให้ถูกต้องและคุณอาจเขียนเครื่องมือเพื่อช่วยคุณสร้างบางอย่าง แต่มันจะมีลักษณะเช่นนี้:

class Channel:
  def __init__(self)
    self.items = []
    self.title = ""

  def from_xml( self, xml_node ):
    self.title = xml_node.xpath("title/text()")[0]
    for x in xml_node.xpath("item"):
      item = Item()
      item.from_xml( x )
      self.items.append( item )

  def to_json( self ):
    retval = {}
    retval['title'] = title
    retval['items'] = []
    for x in items:
      retval.append( x.to_json() )
    return retval

class Item:
  def __init__(self):
    ...

  def from_xml( self, xml_node ):
    ...

  def to_json( self ):
    ...

ฉันพบ snips XML อย่างง่ายการใช้นิพจน์ปกติจะช่วยแก้ไขปัญหาได้ ตัวอย่างเช่น:

# <user><name>Happy Man</name>...</user>
import re
names = re.findall(r'<name>(\w+)<\/name>', xml_string)
# do some thing to names

ในการดำเนินการโดยการวิเคราะห์คำ XML ตามที่ @Dan บอกว่าไม่มีวิธีแก้ปัญหาแบบหนึ่งเดียวสำหรับข้อมูลทั้งหมดเนื่องจากข้อมูลแตกต่างกัน ข้อเสนอแนะของฉันคือการใช้ lxml แม้ว่าจะไม่เสร็จสิ้นกับ json แต่lxml.objectifyให้ผลลัพธ์ที่ดีอย่างเงียบ ๆ :

>>> from lxml import objectify
>>> root = objectify.fromstring("""
... <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
...   <a attr1="foo" attr2="bar">1</a>
...   <a>1.2</a>
...   <b>1</b>
...   <b>true</b>
...   <c>what?</c>
...   <d xsi:nil="true"/>
... </root>
... """)

>>> print(str(root))
root = None [ObjectifiedElement]
    a = 1 [IntElement]
      * attr1 = 'foo'
      * attr2 = 'bar'
    a = 1.2 [FloatElement]
    b = 1 [IntElement]
    b = True [BoolElement]
    c = 'what?' [StringElement]
    d = None [NoneElement]
      * xsi:nil = 'true'

ในขณะที่ในตัว libs สำหรับการแยก XML ค่อนข้างดีผมบางส่วนเพื่อlxml

แต่สำหรับการแยกวิเคราะห์ RSS ฟีดฉันขอแนะนำUniversal Feed Parserซึ่งสามารถแยกวิเคราะห์ Atom ได้ ข้อได้เปรียบหลักของมันคือมันสามารถย่อยฟีดที่ผิดปกติได้

งูหลาม 2.6 อยู่แล้วรวมถึงการแยกวิเคราะห์ JSON แต่รุ่นใหม่รุ่นที่มีความเร็วที่ดีขึ้นสามารถใช้ได้เป็นsimplejson

ด้วยเครื่องมือเหล่านี้ในการสร้างแอปของคุณไม่ควรยากขนาดนั้น

คำตอบของฉันพูดถึงกรณีที่เฉพาะเจาะจง (และค่อนข้างธรรมดา) ซึ่งคุณไม่จำเป็นต้องแปลง xml ทั้งหมดเป็น json แต่สิ่งที่คุณต้องใช้คือสำรวจ / เข้าถึงส่วนเฉพาะของ xml และคุณต้องการให้รวดเร็วและง่าย (โดยใช้การดำเนินการแบบ json / dict)

เข้าใกล้

สำหรับสิ่งนี้สิ่งสำคัญคือต้องทราบว่าการแยกวิเคราะห์ xml เพื่อ etree โดยใช้lxmlนั้นเร็วมาก ส่วนที่ช้าในคำตอบอื่น ๆ ส่วนใหญ่คือการผ่านครั้งที่สอง: การข้ามผ่านโครงสร้าง etree (โดยปกติคือ python-land) แปลงเป็น json

ซึ่งนำฉันไปสู่วิธีการที่ฉันพบว่าดีที่สุดสำหรับกรณีนี้: การแยกวิเคราะห์ xml โดยใช้lxml, และจากนั้นการรวมโหนด etree (อย่างเกียจคร้าน), ให้พวกมันมีส่วนต่อประสานเหมือน dict

รหัส

นี่คือรหัส:

from collections import Mapping
import lxml.etree

class ETreeDictWrapper(Mapping):

    def __init__(self, elem, attr_prefix = '@', list_tags = ()):
        self.elem = elem
        self.attr_prefix = attr_prefix
        self.list_tags = list_tags

    def _wrap(self, e):
        if isinstance(e, basestring):
            return e
        if len(e) == 0 and len(e.attrib) == 0:
            return e.text
        return type(self)(
            e,
            attr_prefix = self.attr_prefix,
            list_tags = self.list_tags,
        )

    def __getitem__(self, key):
        if key.startswith(self.attr_prefix):
            return self.elem.attrib[key[len(self.attr_prefix):]]
        else:
            subelems = [ e for e in self.elem.iterchildren() if e.tag == key ]
            if len(subelems) > 1 or key in self.list_tags:
                return [ self._wrap(x) for x in subelems ]
            elif len(subelems) == 1:
                return self._wrap(subelems[0])
            else:
                raise KeyError(key)

    def __iter__(self):
        return iter(set( k.tag for k in self.elem) |
                    set( self.attr_prefix + k for k in self.elem.attrib ))

    def __len__(self):
        return len(self.elem) + len(self.elem.attrib)

    # defining __contains__ is not necessary, but improves speed
    def __contains__(self, key):
        if key.startswith(self.attr_prefix):
            return key[len(self.attr_prefix):] in self.elem.attrib
        else:
            return any( e.tag == key for e in self.elem.iterchildren() )


def xml_to_dictlike(xmlstr, attr_prefix = '@', list_tags = ()):
    t = lxml.etree.fromstring(xmlstr)
    return ETreeDictWrapper(
        t,
        attr_prefix = '@',
        list_tags = set(list_tags),
    )

การนำไปใช้งานนี้ไม่สมบูรณ์เช่นไม่รองรับกรณีที่องค์ประกอบมีทั้งข้อความและคุณลักษณะหรือทั้งข้อความและลูก (เพราะฉันไม่ต้องการเมื่อฉันเขียนมัน ... ) มันควรจะง่าย เพื่อปรับปรุงให้ดีขึ้น

ความเร็ว

ในกรณีการใช้งานเฉพาะของฉันซึ่งฉันต้องการประมวลผลองค์ประกอบเฉพาะของ xml เท่านั้นวิธีการนี้ให้ความเร็วที่น่าทึ่งและโดดเด่นด้วยอัตรา 70 (!)เมื่อเทียบกับการใช้ xmltodict ของ @Martin Blech จากนั้นท่องไปตามคำสั่งโดยตรง

โบนัส

เป็นโบนัสเนื่องจากโครงสร้างของเราคล้าย dict อยู่แล้วเราจึงได้รับการติดตั้งใหม่xml2jsonฟรี เราก็ต้องผ่าน Dict json.dumpsเหมือนเราโครงสร้าง สิ่งที่ต้องการ:

def xml_to_json(xmlstr, **kwargs):
    x = xml_to_dictlike(xmlstr, **kwargs)
    return json.dumps(x)

หาก xml ของคุณมีแอตทริบิวต์คุณจะต้องใช้ตัวอักษรและตัวเลขattr_prefix(เช่น "ATTR_") เพื่อให้แน่ใจว่าคีย์นั้นเป็นคีย์ json ที่ถูกต้อง

ฉันไม่ได้เปรียบเทียบส่วนนี้

เมื่อฉันทำอะไรกับ XML ใน python ฉันมักจะใช้แพ็คเกจ lxml ฉันสงสัยว่าคนส่วนใหญ่ใช้ lxml คุณสามารถใช้ xmltodict ได้ แต่คุณจะต้องจ่ายค่าปรับในการแยกวิเคราะห์ XML อีกครั้ง

ในการแปลง XML เป็น json ด้วย lxml คุณ:

1. แยกวิเคราะห์เอกสารด้วย lxml
2. แปลง lxml เป็น dict
3. แปลงรายการเป็น json

ฉันใช้คลาสต่อไปนี้ในโครงงานของฉัน ใช้วิธีการ toJson

from lxml import etree 
import json


class Element:
    '''
    Wrapper on the etree.Element class.  Extends functionality to output element
    as a dictionary.
    '''

    def __init__(self, element):
        '''
        :param: element a normal etree.Element instance
        '''
        self.element = element

    def toDict(self):
        '''
        Returns the element as a dictionary.  This includes all child elements.
        '''
        rval = {
            self.element.tag: {
                'attributes': dict(self.element.items()),
            },
        }
        for child in self.element:
            rval[self.element.tag].update(Element(child).toDict())
        return rval


class XmlDocument:
    '''
    Wraps lxml to provide:
        - cleaner access to some common lxml.etree functions
        - converter from XML to dict
        - converter from XML to json
    '''
    def __init__(self, xml = '<empty/>', filename=None):
        '''
        There are two ways to initialize the XmlDocument contents:
            - String
            - File

        You don't have to initialize the XmlDocument during instantiation
        though.  You can do it later with the 'set' method.  If you choose to
        initialize later XmlDocument will be initialized with "<empty/>".

        :param: xml Set this argument if you want to parse from a string.
        :param: filename Set this argument if you want to parse from a file.
        '''
        self.set(xml, filename) 

    def set(self, xml=None, filename=None):
        '''
        Use this to set or reset the contents of the XmlDocument.

        :param: xml Set this argument if you want to parse from a string.
        :param: filename Set this argument if you want to parse from a file.
        '''
        if filename is not None:
            self.tree = etree.parse(filename)
            self.root = self.tree.getroot()
        else:
            self.root = etree.fromstring(xml)
            self.tree = etree.ElementTree(self.root)


    def dump(self):
        etree.dump(self.root)

    def getXml(self):
        '''
        return document as a string
        '''
        return etree.tostring(self.root)

    def xpath(self, xpath):
        '''
        Return elements that match the given xpath.

        :param: xpath
        '''
        return self.tree.xpath(xpath);

    def nodes(self):
        '''
        Return all elements
        '''
        return self.root.iter('*')

    def toDict(self):
        '''
        Convert to a python dictionary
        '''
        return Element(self.root).toDict()

    def toJson(self, indent=None):
        '''
        Convert to JSON
        '''
        return json.dumps(self.toDict(), indent=indent)


if __name__ == "__main__":
    xml='''<system>
    <product>
        <demod>
            <frequency value='2.215' units='MHz'>
                <blah value='1'/>
            </frequency>
        </demod>
    </product>
</system>
'''
    doc = XmlDocument(xml)
    print doc.toJson(indent=4)

เอาท์พุทจากที่สร้างขึ้นในหลักคือ:

{
    "system": {
        "attributes": {}, 
        "product": {
            "attributes": {}, 
            "demod": {
                "attributes": {}, 
                "frequency": {
                    "attributes": {
                        "units": "MHz", 
                        "value": "2.215"
                    }, 
                    "blah": {
                        "attributes": {
                            "value": "1"
                        }
                    }
                }
            }
        }
    }
}

ซึ่งเป็นการเปลี่ยนแปลงของ xml นี้:

<system>
    <product>
        <demod>
            <frequency value='2.215' units='MHz'>
                <blah value='1'/>
            </frequency>
        </demod>
    </product>
</system>

jsonpickleหรือหากคุณใช้ feedparser คุณสามารถลองfeed_parser_to_json.py

สิ่งนี้ได้รับการบำรุงรักษาอย่างแข็งขันและที่ฉันชอบ: xml2json ใน python

ตรวจสอบ lxml2json (การเปิดเผย: ฉันเขียนไว้)

https://github.com/rparelius/lxml2json

มันเร็วมากน้ำหนักเบา (ต้องใช้ lxml เท่านั้น) และข้อดีอย่างหนึ่งก็คือคุณสามารถควบคุมได้ว่าองค์ประกอบบางอย่างจะถูกแปลงเป็นรายการหรือ dicts

คุณสามารถใช้ declxml มันมีคุณสมบัติขั้นสูงเช่นคุณสมบัติหลายประการและการสนับสนุนที่ซ้อนกันที่ซับซ้อน คุณเพียงแค่ต้องเขียนโปรเซสเซอร์ง่าย ๆ ด้วยรหัสเดียวกันคุณสามารถแปลงกลับเป็น JSON ได้เช่นกัน ค่อนข้างตรงไปตรงมาและมีเอกสารประกอบที่ยอดเยี่ยม

ลิงก์: https://declxml.readthedocs.io/th/latest/index.html

เตรียมข้อมูลในPython : ในการสร้างJSONก่อนอื่นคุณต้องเตรียมข้อมูลเป็น Python เราสามารถใช้ List and Dictionary ใน Python เพื่อเตรียมข้อมูล

รายการPython <==> อาร์เรย์JSON

Python Dictionary <==> วัตถุJSON (รูปแบบค่าคีย์) ตรวจสอบรายละเอียดเพิ่มเติมได้ที่นี่

https://devstudioonline.com/article/create-json-and-xml-in-python

เพื่อแสดงข้อมูลในรูปแบบJSON

name=John
age=20
gender=male
address=Sector 12 Greater Kailash, New Delhi
Jobs=Noida,Developer | Gurugram,Tester |Faridabad,Designer

ในjsonเรานำเสนอข้อมูลในรูปแบบคีย์และค่า

{
    "name":"john",
    "age":20,
    "gender":"male",
    "address":["New kP college","Greater Kailash","New Delhi"],
    "jobs":[
               {"Place":"Noida","Title":"Developer "},
               {"Place":"Gurugram","Title":"Tester "},
               {"Place":"Faridabad","Title":"Designer"}
           ]
}

เพื่อแสดงข้อมูลในรูปแบบXML

<!-- In xml we write a code under a key you can take any key -->
<info> <!-- key open -->

<name> john </name> 
<age> 20 </age>
<gender> male </gender>

<address> 
<item> New kP college </item>
<item> Greater Kailash </item>
<item> New Delhi </item>
</address>

<jobs>
 <item>
  <title>Developer </title>
  <place>Noida</place>
 </item>

 <item>
  <title>Designer</title>
  <place>Gurugram</place>
 </item>
 
 <item>
  <title>Developer </title>
  <place>Faridabad</place>
 </item>
</jobs>

</info> <!-- key close-->