write - xml python datacamp




Traitement XML en Python (8)

Je suis sur le point de construire un élément d'un projet qui devra créer et publier un document XML sur un service Web. J'aimerais le faire en Python, afin de développer mes compétences dans ce domaine.

Malheureusement, bien que je connaisse assez bien le modèle XML dans .NET, je ne sais pas quels sont les avantages et les inconvénients des modèles XML en Python.

Quelqu'un at-il de l'expérience dans le traitement XML en Python? Où suggérez-vous que je commence? Les fichiers XML que je vais créer seront assez simples.


Pour un travail sérieux avec XML en Python, utilisez lxml

Python est livré avec la bibliothèque intégrée ElementTree, mais lxml l'étend en termes de vitesse et de fonctionnalités (validation de schéma, analyse de sax, XPath, diverses sortes d'itérateurs et de nombreuses autres fonctionnalités).

Vous devez l'installer, mais dans de nombreux endroits, il est déjà supposé faire partie d'un équipement standard (par exemple, Google AppEngine n'autorise pas les packages Python en C, mais crée une exception pour lxml, pyyaml ​​et quelques autres).

Construction de documents XML avec E-factory (à partir de lxml)

Votre question concerne la création d'un document XML.

Avec lxml, il existe de nombreuses méthodes et il m'a fallu un certain temps pour trouver celle qui semble être facile à utiliser et à lire.

Exemple de code de la documentation lxml sur l’utilisation de E-factory (légèrement simplifié):

E-factory fournit une syntaxe simple et compacte pour la génération de XML et HTML:

>>> from lxml.builder import E

>>> html = page = (
...   E.html(       # create an Element called "html"
...     E.head(
...       E.title("This is a sample document")
...     ),
...     E.body(
...       E.h1("Hello!"),
...       E.p("This is a paragraph with ", E.b("bold"), " text in it!"),
...       E.p("This is another paragraph, with a", "\n      ",
...         E.a("link", href="http://www.python.org"), "."),
...       E.p("Here are some reserved characters: <spam&egg>."),
...     )
...   )
... )

>>> print(etree.tostring(page, pretty_print=True))
<html>
  <head>
    <title>This is a sample document</title>
  </head>
  <body>
    <h1>Hello!</h1>
    <p>This is a paragraph with <b>bold</b> text in it!</p>
    <p>This is another paragraph, with a
      <a href="http://www.python.org">link</a>.</p>
    <p>Here are some reserved characters: &lt;spam&amp;egg&gt;.</p>
  </body>
</html>

J'apprécie sur E-factory les choses suivantes

Le code se lit presque comme le document XML résultant

La lisibilité compte.

Permet la création de tout contenu XML

Prend en charge des choses comme:

  • utilisation des espaces de noms
  • début et fin des nœuds de texte dans un élément
  • fonctions de mise en forme du contenu de l'attribut (voir func CLASS dans l'exemple complet lxml )

Permet des constructions très lisibles avec des listes

par exemple:

from lxml import etree
from lxml.builder import E
lst = ["alfa", "beta", "gama"]
xml = E.root(*[E.record(itm) for itm in lst])
etree.tostring(xml, pretty_print=True)

résultant en:

<root>
  <record>alfa</record>
  <record>beta</record>
  <record>gama</record>
</root>

Conclusions

Je recommande fortement de lire le tutoriel lxml - il est très bien écrit et vous donnera beaucoup plus de raisons d’utiliser cette puissante bibliothèque.

Le seul inconvénient de lxml est qu'il doit être compilé. Voir la réponse à SO pour plus de conseils sur l'installation de LXML à partir du format de roue en une fraction de seconde.


Cela dépend un peu de la complexité du document.

J'ai beaucoup utilisé minidom pour écrire du code XML, mais cela consiste généralement à lire des documents, à effectuer des transformations simples et à les réécrire. Cela a fonctionné assez bien jusqu'à ce que j'aie besoin de la possibilité de commander des attributs d'élément (pour satisfaire une application ancienne qui n'analyse pas correctement XML). À ce stade, j'ai abandonné et ai écrit le XML moi-même.

Si vous ne travaillez que sur des documents simples, le faire vous-même peut être plus rapide et plus simple que d'apprendre un cadre. Si vous pouvez éventuellement écrire le XML à la main, vous pouvez probablement aussi le coder à la main (n'oubliez pas d'échapper correctement aux caractères spéciaux et utilisez str.encode(codec, errors="xmlcharrefreplace") ). En dehors de ces snafus, XML est suffisamment régulier pour que vous n’ayez pas besoin d’ une bibliothèque spéciale pour l’écrire. Si le document est trop compliqué à écrire à la main, vous devriez probablement vous pencher sur l’un des cadres déjà mentionnés. À aucun moment, vous ne devriez avoir besoin d'écrire un écrivain XML général.


J'écris un serveur SOAP qui reçoit des demandes XML et crée des réponses XML. (Malheureusement, ce n'est pas mon projet, donc c'est une source fermée, mais c'est un autre problème).

Il m'est apparu que créer des documents XML (SOAP) est assez simple si vous avez une structure de données qui "correspond" au schéma.

Je garde l'enveloppe puisque l'enveloppe de réponse est (presque) identique à l'enveloppe de demande. Ensuite, ma structure de données étant un dictionnaire (éventuellement imbriqué), je crée une chaîne qui transforme ce dictionnaire en éléments <key> value </ key>.

C’est une tâche que la récursivité simplifie et je me retrouve avec la bonne structure. Tout cela est fait en code python et est actuellement assez rapide pour une utilisation en production.

Vous pouvez également créer (relativement) facilement des listes, bien que, en fonction de votre client, vous puissiez rencontrer des problèmes à moins d'indication de longueur.

Pour moi, c'était beaucoup plus simple, car un dictionnaire est une méthode de travail beaucoup plus simple qu'une classe personnalisée. Pour les livres, générer du XML est beaucoup plus facile que d’analyser!


J'ai utilisé ElementTree pour plusieurs projets et le recommande.

C'est pythonique, livré «dans la boîte» avec Python 2.5, y compris la version c cElementTree (xml.etree.cElementTree) qui est 20 fois plus rapide que la version pure de Python et très facile à utiliser.

lxml présente certains avantages en termes de performances, mais ils sont inégaux et vous devez d'abord vérifier les repères pour votre cas d'utilisation.

Si je comprends bien, le code ElementTree peut facilement être porté en lxml.


Je suppose que la manière .Net de traiter XML repose sur une version de MSXML et, dans ce cas, je suppose que l'utilisation de minidom, par exemple, vous ferait vous sentir un peu chez vous. Toutefois, s’il s’agit d’un traitement simple, toutes les bibliothèques le feront probablement.

Je préfère aussi travailler avec ElementTree lorsque je traite avec XML en Python, c'est une bibliothèque très soignée.


Personnellement, j'ai joué avec plusieurs des options intégrées dans un projet lourd en XML et j'ai pulldom pour pulldom comme meilleur choix pour les documents moins complexes.

Surtout pour les petites choses simples, j'aime bien la théorie de l'analyse syntaxique basée sur les événements plutôt que de mettre en place toute une série de callbacks pour une structure relativement simple. Voici une bonne discussion rapide sur l'utilisation de l'API .

Ce que j’aime: vous pouvez gérer l’analyse dans une boucle for lieu d’utiliser des rappels. Vous expandNode() également l'analyse complète (la partie "pull") et n'obtenez des détails supplémentaires que lorsque vous appelez expandNode() . Cela répond à mon exigence générale d'efficacité "responsable" sans sacrifier la facilité d'utilisation et la simplicité.


Si vous construisez des messages SOAP, consultez soaplib . Il utilise ElementTree sous le capot, mais il fournit une interface beaucoup plus propre pour la sérialisation et la désérialisation des messages.


Vous pouvez également essayer de untangle pour analyser des documents XML simples.





xml