Chuyển đổi XML sang JSON bằng Python?

Tôi đã thấy một phần công bằng của mã XML -> JSON vô duyên trên web và đã tương tác với người dùng của Stack một chút, tôi tin rằng đám đông này có thể giúp nhiều hơn những trang kết quả Google đầu tiên có thể.

Vì vậy, chúng tôi đang phân tích một nguồn cấp dữ liệu thời tiết và chúng tôi cần phải đưa vào các tiện ích thời tiết trên vô số các trang web. Bây giờ chúng tôi đang xem xét các giải pháp dựa trên Python.

Nguồn cấp dữ liệu RSS thời tiết công cộng này là một ví dụ tốt về những gì chúng tôi sẽ phân tích cú pháp ( nguồn cấp dữ liệu Weather.com thực tế của chúng tôi có chứa thông tin bổ sung do có quan hệ đối tác với họ ).

Tóm lại, chúng ta nên chuyển đổi XML thành JSON bằng Python như thế nào?

Không có ánh xạ "một-một" giữa XML và JSON, do đó, việc chuyển đổi cái này sang cái khác nhất thiết đòi hỏi một số hiểu biết về những gì bạn muốn làm với kết quả.

Điều đó đang được nói, thư viện tiêu chuẩn của Python có một số mô-đun để phân tích cú pháp XML (bao gồm DOM, SAX và ElementTree). Kể từ Python 2.6, hỗ trợ chuyển đổi cấu trúc dữ liệu Python sang và từ JSON được bao gồm trong jsonmô-đun .

Vì vậy, cơ sở hạ tầng là có.

xmltodict (công bố đầy đủ: tôi đã viết nó) có thể giúp bạn chuyển đổi XML của bạn thành cấu trúc chuỗi dict + list +, theo "tiêu chuẩn" này . Nó dựa trên cơ sở Expat , vì vậy nó rất nhanh và không cần tải toàn bộ cây XML trong bộ nhớ.

Khi bạn có cấu trúc dữ liệu đó, bạn có thể tuần tự hóa nó thành JSON:

import xmltodict, json

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

Bạn có thể sử dụng thư viện xmljson để chuyển đổi bằng các quy ước JSON JSON khác nhau .

Ví dụ: XML này:

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

dịch thông qua quy ước BadgerFish vào đây:

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

và thông qua quy ước GData vào điều này (các thuộc tính không được hỗ trợ):

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

... và thông qua quy ước Parker vào điều này (các thuộc tính không được hỗ trợ):

{
  'p': 'text'
}

Có thể chuyển đổi từ XML sang JSON và từ JSON sang XML bằng các quy ước tương tự:

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

Tiết lộ: Tôi đã viết thư viện này. Hy vọng nó sẽ giúp người tìm kiếm trong tương lai.

Nếu đôi khi bạn chỉ nhận được mã phản hồi thay vì tất cả dữ liệu thì lỗi như json parse sẽ xuất hiện, do đó bạn cần chuyển đổi nó dưới dạng văn bản

import xmltodict

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

Đây là mã tôi xây dựng cho điều đó. Không có phân tích nội dung, chỉ chuyển đổi đơn giản.

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

Có một phương pháp để vận chuyển đánh dấu dựa trên XML dưới dạng JSON, cho phép nó được chuyển đổi một cách dễ dàng trở lại dạng ban đầu. Xem http://jsonml.org/ .

Đây là một loại XSLT của JSON. Tôi hy vọng bạn tìm thấy nó hữu ích

Đối với bất cứ ai vẫn có thể cần điều này. Đây là một mã mới hơn, đơn giản để thực hiện chuyển đổi này.

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

Bạn có thể muốn xem http://designtheory.org/l Library / extrep /designdb-1.0.pdf . Dự án này bắt đầu với một chuyển đổi XML sang JSON của một thư viện lớn các tệp XML. Đã có nhiều nghiên cứu được thực hiện trong quá trình chuyển đổi và XML trực quan đơn giản nhất -> ánh xạ JSON đã được tạo ra (nó được mô tả sớm trong tài liệu). Tóm lại, chuyển đổi mọi thứ thành một đối tượng JSON và đặt các khối lặp lại làm danh sách các đối tượng.

các đối tượng có nghĩa là các cặp khóa / giá trị (từ điển trong Python, hashmap trong Java, đối tượng trong JavaScript)

Không có ánh xạ trở lại XML để có được một tài liệu giống hệt nhau, lý do là, không biết liệu một cặp khóa / giá trị là một thuộc tính hay một <key>value</key>, do đó thông tin đó bị mất.

Nếu bạn hỏi tôi, các thuộc tính là một hack để bắt đầu; sau đó một lần nữa họ làm việc tốt cho HTML.

Chà, có lẽ cách đơn giản nhất là phân tích cú pháp XML thành từ điển và sau đó tuần tự hóa nó với Simplejson.

Tôi khuyên bạn không nên chuyển đổi trực tiếp. Chuyển đổi XML thành một đối tượng, sau đó từ đối tượng sang JSON.

Theo tôi, điều này đưa ra một định nghĩa rõ ràng hơn về cách XML và JSON tương ứng.

Phải mất thời gian để làm đúng và thậm chí bạn có thể viết các công cụ để giúp bạn tạo ra một số phần mềm, nhưng nó sẽ trông giống như thế này:

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

Tôi tìm thấy cho các đoạn trích XML đơn giản, sử dụng biểu thức chính quy sẽ tiết kiệm rắc rối. Ví dụ:

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

Để làm điều đó bằng cách phân tích cú pháp XML, như @Dan đã nói, không có giải pháp một cho tất cả vì dữ liệu là khác nhau. Đề nghị của tôi là sử dụng lxml. Mặc dù chưa kết thúc với json, lxml.objectify cho kết quả tốt yên tĩnh:

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

Mặc dù các lib tích hợp để phân tích cú pháp XML khá tốt nhưng tôi là một phần của lxml .

Nhưng để phân tích nguồn cấp dữ liệu RSS, tôi khuyên dùng Trình phân tích nguồn cấp dữ liệu chung , cũng có thể phân tích cú pháp nguyên tử. Ưu điểm chính của nó là nó có thể tiêu hóa ngay cả hầu hết các loại thức ăn không đúng định dạng.

Python 2.6 đã bao gồm một trình phân tích cú pháp JSON, nhưng một phiên bản mới hơn với tốc độ được cải thiện có sẵn dưới dạng đơn giản .

Với những công cụ này, việc xây dựng ứng dụng của bạn sẽ không quá khó khăn.

Địa chỉ câu trả lời của tôi cụ thể (và có phần chung) Trường hợp bạn không thực sự cần phải chuyển đổi toàn bộ xml để json, nhưng những gì bạn cần là traverse / truy cập phần cụ thể của xml, và bạn cần nó để được nhanh chóng , và đơn giản (sử dụng các thao tác json / dict-like).

Tiếp cận

Đối với điều này, điều quan trọng cần lưu ý là phân tích cú pháp xml sang etree bằng cách sử dụng lxmllà siêu nhanh. Phần chậm trong hầu hết các câu trả lời khác là thông qua thứ hai: đi qua cấu trúc etree (thường ở vùng đất trăn), chuyển đổi nó thành json.

Điều này dẫn tôi đến cách tiếp cận mà tôi thấy tốt nhất trong trường hợp này: phân tích xml bằng cách sử dụng lxml, sau đó gói các nút etree (một cách lười biếng), cung cấp cho chúng một giao diện giống như chính tả.

Mã

Đây là mã:

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

Việc triển khai này chưa hoàn tất, ví dụ, nó không hỗ trợ rõ ràng các trường hợp trong đó một phần tử có cả văn bản và thuộc tính hoặc cả văn bản và trẻ em (chỉ vì tôi không cần nó khi tôi viết nó ...) Thật dễ dàng để cải thiện nó, mặc dù.

Tốc độ

Trong trường hợp cụ thể sử dụng của tôi, nơi tôi cần đến các yếu tố quy trình cụ thể duy nhất của xml, phương pháp này đã đưa ra một đáng ngạc nhiên và tăng tốc ấn tượng bởi một yếu tố của 70 (!) So với sử dụng @ Martin Blech của xmltodict và sau đó đi qua các dict trực tiếp.

Tặng kem

Như một phần thưởng, vì cấu trúc của chúng tôi giống như chính tả, chúng tôi nhận được một triển khai thay thế khác xml2jsonmiễn phí. Chúng ta chỉ cần chuyển cấu trúc giống như chính tả của mình json.dumps. Cái gì đó như:

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

Nếu xml của bạn bao gồm các thuộc tính, bạn cần sử dụng một số chữ và số attr_prefix(ví dụ: "ATTR_"), để đảm bảo các khóa là các khóa json hợp lệ.

Tôi đã không điểm chuẩn phần này.

Khi tôi làm bất cứ điều gì với XML bằng python, tôi hầu như luôn sử dụng gói lxml. Tôi nghi ngờ rằng hầu hết mọi người sử dụng lxml. Bạn có thể sử dụng xmltodict nhưng bạn sẽ phải trả tiền phạt khi phân tích lại XML.

Để chuyển đổi XML thành json với lxml, bạn:

1. Phân tích tài liệu XML bằng lxml
2. Chuyển đổi lxml thành một dict
3. Chuyển đổi danh sách sang json

Tôi sử dụng các lớp sau trong các dự án của tôi. Sử dụng phương pháp 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)

Kết quả của việc xây dựng trong chính là:

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

Đó là một biến đổi của xml này:

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

jsonpickle hoặc nếu bạn đang sử dụng feedparser, bạn có thể thử feed_parser_to_json.py

Công cụ này ở đây được duy trì tích cực và cho đến nay là sở thích của tôi: xml2json trong python

kiểm tra lxml2json (tiết lộ: tôi đã viết nó)

https://github.com/rparelius/lxml2json

nó rất nhanh, nhẹ (chỉ yêu cầu lxml) và một ưu điểm là bạn có quyền kiểm soát xem các yếu tố nhất định có được chuyển đổi thành danh sách hoặc dicts không

Bạn có thể sử dụng Decxml. Nó có các tính năng nâng cao như đa thuộc tính và hỗ trợ lồng nhau phức tạp. Bạn chỉ cần viết một bộ xử lý đơn giản cho nó. Ngoài ra với cùng một mã, bạn cũng có thể chuyển đổi trở lại JSON. Nó là khá đơn giản và các tài liệu là tuyệt vời.

Liên kết: https://declxml.readthedocs.io/en/latest/index.html

Chuẩn bị dữ liệu bằng Python : Để tạo JSON trước tiên, bạn cần chuẩn bị dữ liệu bằng python. Chúng ta có thể sử dụng Danh sách và Từ điển trong Python để chuẩn bị dữ liệu.

Danh sách Python <==> Mảng JSON

Từ điển Python <==> Đối tượng JSON (Định dạng giá trị khóa) Kiểm tra điều này để biết thêm chi tiết

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

Để biểu thị dữ liệu ở định dạng JSON

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

Trong json, chúng tôi cung cấp dữ liệu ở định dạng khóa và giá trị

{
    "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"}
           ]
}

Để biểu thị dữ liệu ở định dạng 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-->