Convertir XML en JSON à l'aide de Python?

Il n'y a pas de "one-to-one" mappage entre XML et JSON, donc le passage de l'un à l'autre nécessite une certaine compréhension de ce que vous voulez ne avec les résultats.

Cela étant dit, Python standard library a plusieurs modules pour l'analyse de XML (y compris les DOM, SAX, et ElementTree). Comme de Python 2.6, le soutien pour la conversion de Python structures de données vers et à partir de JSON est inclus dans le json module.

Si l'infrastructure est là.

Vous pouvez utiliser le xmljson bibliothèque pour les convertir à l'aide de différents XML JSON conventions.

Par exemple, ce XML:

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

traduit par la BadgerFish convention dans cette:

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

et via le GData convention dans ce (les attributs ne sont pas pris en charge):

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

... et par la Parker convention dans ce (les attributs ne sont pas pris en charge):

{
  'p': 'text'
}

Il est possible de convertir du XML en JSON et de JSON en XML en utilisant la même
conventions:

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

Divulgation: j'ai écrit cette bibliothèque. Espérons qu'il aidera les futurs chercheurs.

Si peu de temps, vous obtenez uniquement les code de réponse au lieu de toutes les données puis erreur comme json analyser sera là si u besoin pour le convertir en texte

import xmltodict

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

Vous voudrez peut-être avoir un coup d'oeil à http://designtheory.org/library/extrep/designdb-1.0.pdf. Ce projet commence avec un XML en JSON de la conversion d'une grande bibliothèque de fichiers XML. Il y avait beaucoup de recherche faite dans la conversion et la plus intuitive simple XML -> JSON cartographie a été produit (il est décrit au début du document). En résumé, tout convertir un objet JSON, et de mettre en répétant les blocs comme une liste d'objets.

du sens aux objets de paires clé/valeur (dictionnaire en Python, hashmap en Java, objet en JavaScript)

Il n'existe pas de cartographie de retour à XML pour obtenir un document identique, la raison en est, il est inconnu si une paire clé/valeur est un attribut ou un <key>value</key>, donc l'information est perdue.

Si vous me demandez, les attributs sont un hack pour commencer; puis, de nouveau, ils ont bien travaillé pour HTML.

Je vous suggère de ne pas aller pour une conversion directe. Convertir XML à un objet, à partir de l'objet JSON.

À mon avis, ce qui donne un nettoyeur de définition de la façon dont le XML et JSON correspondent.

Il faut du temps pour obtenir le droit et vous pouvez même écrire des outils pour vous aider avec la génération de certains, mais il devrait ressembler à peu près à ceci:

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

Tandis que le haut-libs pour l'analyse XML sont assez bon, je suis partielle de lxml.

Mais pour l'analyse des flux RSS, je vous recommande Universel D'Alimentation De L'Analyseur, qui peut également analyser l'Atome.
Son principal avantage est qu'il peut digérer encore plus mal formé flux.

Python 2.6 comprend déjà un parser JSON, mais plus récent version avec une amélioration de la vitesse est disponible en simplejson.

Avec ces outils, la construction de votre application ne devrait pas être difficile.

À toute personne qui peut encore avoir besoin de cela. Voici un nouveau code simple pour faire cette conversion.

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

Ma réponse adresses spécifiques (et quelque peu fréquent) cas où vous n'avez pas vraiment besoin de convertir l'ensemble de xml en json, mais ce que vous avez besoin est de traverser/accéder à des parties spécifiques de l'xml, et vous en avez besoin pour être rapide, et simple (en utilisant json/dict des opérations de type).

Approche

Pour cela, il est important de noter que l'analyse d'un xml à l'aide du programme etree lxml est super rapide. La partie lente dans la plupart des autres réponses est la deuxième passe: de la traversée du programme etree structure (généralement en python-terre), de la convertir en json.

Ce qui m'amène à l'approche que j'ai trouvé de mieux pour ce cas: analyse d'un xml à l'aide de lxml, puis enrouler le programme etree nœuds (paresseusement), en leur fournissant un dict-comme l'interface.

Code

Voici le code:

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

Cette mise en œuvre n'est pas complète, par exemple, il n'est pas correctement prise en charge des cas où un élément a à la fois du texte et des attributs, ou à la fois du texte et des enfants (seulement parce que je n'ai pas besoin de lui quand je l'ai écrit...), Il devrait être facile de l'améliorer, si.

Vitesse

Dans mon cas d'utilisation spécifiques, où j'avais besoin de traiter uniquement les éléments spécifiques de l'xml, cette approche a donné un surprenant et frappant de l'accélération d'un facteur 70 (!) par rapport à l'utilisation de @Martin Blech est xmltodict et puis, traversant le dict directement.

Bonus

Comme un bonus, puisque notre structure est déjà dict-comme, nous obtenons une autre variante de mise en œuvre de xml2json gratuitement. Nous avons juste besoin de passer nos dict-comme la structure de json.dumps. Quelque chose comme:

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

Si votre xml contient des attributs, vous devez utiliser certains alphanumérique attr_prefix (par exemple, "ATTR_"), pour s'assurer que les clés sont json valide clés.

Je n'ai pas comparé la présente partie.

découvrez lxml2json (divulgation: je l'ai écrit)

https://github.com/rparelius/lxml2json

il est très rapide, léger (seulement exige lxml), et un avantage, c'est que vous avez plus de contrôle si certains éléments sont convertis à des listes ou des dicts

Préparer les données dans Python:
Pour créer JSON vous devez d'abord préparer les données en python. Nous pouvons utiliser la Liste et le Dictionnaire en Python pour préparer les données.

Python Liste <==> JSON Tableau

Python Dictionnaire <==> JSON Objet (Valeur de la Clé de Format)
Cochez cette pour plus de détails

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