Traitement XML en Python : Guide pour la gestion de données interopérables

XML est un langage portable, open source, permettant de développer des applications lisibles par d'autres applications, indépendamment du système d'exploitation et/ou du langage de développement.

Qu'est-ce que XML ?

L'Extensible Markup Language (XML) est un langage de balisage semblable à HTML ou SGML. Recommandé par le W3C et disponible comme standard ouvert.

XML est extrêmement utile pour suivre de petites à moyennes quantités de données sans nécessiter de base SQL.

Architectures et APIs d'analyseurs XML

La bibliothèque standard Python fournit un ensemble minimal mais utile d'interfaces pour travailler avec XML.

Les deux APIs de base les plus utilisées pour les données XML sont les interfaces SAX et DOM.

Simple API for XML (SAX) : Vous enregistrez des rappels (callbacks) pour les événements d'intérêt, puis laissez l'analyseur parcourir le document. Utile pour gros documents ou limitations mémoire : le fichier est analysé au fur et à mesure de sa lecture depuis le disque, jamais stocké entièrement en mémoire.
Document Object Model (DOM) API : Recommandation W3C où le fichier entier est lu en mémoire et stocké sous forme hiérarchique (arborescente) pour représenter toutes les fonctionnalités d'un document XML.

SAX ne peut pas traiter l'information aussi vite que DOM sur de gros fichiers. En revanche, DOM exclusivement peut épuiser les ressources, surtout sur beaucoup de petits fichiers.

SAX est en lecture seule, DOM permet de modifier le fichier XML. Ces deux APIs se complètent littéralement, il n'y a aucune raison de ne pas les utiliser toutes deux pour de gros projets.

Pour tous nos exemples XML, utilisons un fichier simple movies.xml :

<collection shelf="New Arrivals">
<movie title="Enemy Behind">
<type>War, Thriller</type>
<format>DVD</format>
<year>2003</year>
<rating>PG</rating>
<stars>10</stars>
<description>Talk about a US-Japan war</description>
</movie>
<movie title="Transformers">
<type>Anime, Science Fiction</type>
<format>DVD</format>
<year>1989</year>
<rating>R</rating>
<stars>8</stars>
<description>A schientific fiction</description>
</movie>
<movie title="Trigun">
<type>Anime, Action</type>
<format>DVD</format>
<episodes>4</episodes>
<rating>PG</rating>
<stars>10</stars>
<description>Vash the Stampede!</description>
</movie>
<movie title="Ishtar">
<type>Comedy</type>
<format>VHS</format>
<rating>PG</rating>
<stars>2</stars>
<description>Viewable boredom</description>
</movie>
</collection>

Analyse XML avec l'API SAX

SAX est une interface standard pour l'analyse XML événementielle. L'analyse avec SAX nécessite généralement de créer votre propre ContentHandler en sous-classant xml.sax.ContentHandler.

Votre ContentHandler gère les balises et attributs particuliers de votre type(s) d'XML. Un objet ContentHandler fournit des méthodes pour gérer divers événements d'analyse. Son analyseur appelant appelle les méthodes du ContentHandler pendant l'analyse.

Les méthodes startDocument et endDocument sont appelées au début et à la fin du fichier XML. La méthode characters(text) reçoit les données de caractères via le paramètre text.

Le ContentHandler est appelé au début et à la fin de chaque élément. Si l'analyseur n'est pas en mode espace de noms, les méthodes startElement(tag, attributes) et endElement(tag) sont appelées ; sinon, startElementNS et endElementNS. Ici, tag est l'étiquette de l'élément, et attributes un objet Attributes.

La méthode make_parser

Crée un nouvel objet analyseur et le retourne. L'analyseur créé sera du premier type trouvé par le système.

xml.sax.make_parser([parser_list])

Paramètre :

parser_list : Argument optionnel : liste d'analyseurs à utiliser, tous doivent implémenter make_parser.

La méthode parse

Crée un analyseur SAX et l'utilise pour analyser un document.

xml.sax.parse(xmlfile, contenthandler[, errorhandler])

Paramètres :

xmlfile : Nom du fichier XML à lire.
contenthandler : Doit être un objet ContentHandler.
errorhandler : Si spécifié, doit être un objet SAX ErrorHandler.

La méthode parseString

Méthode pour créer un analyseur SAX et analyser une chaîne XML spécifiée.

xml.sax.parseString(xmlstring, contenthandler[, errorhandler])

Paramètres :

xmlstring : Chaîne XML à lire.
contenthandler : Objet ContentHandler.
errorhandler : Objet SAX ErrorHandler si spécifié.

Exemple

#!/usr/bin/python
import xml.sax

class MovieHandler(xml.sax.ContentHandler):
    def __init__(self):
        self.CurrentData = ""
        self.type = ""
        self.format = ""
        self.year = ""
        self.rating = ""
        self.stars = ""
        self.description = ""

    def startElement(self, tag, attributes):
        self.CurrentData = tag
        if tag == "movie":
            print("*****Movie*****")
            title = attributes["title"]
            print("Title:", title)

    def endElement(self, tag):
        if self.CurrentData == "type":
            print("Type:", self.type)
        elif self.CurrentData == "format":
            print("Format:", self.format)
        elif self.CurrentData == "year":
            print("Year:", self.year)
        elif self.CurrentData == "rating":
            print("Rating:", self.rating)
        elif self.CurrentData == "stars":
            print("Stars:", self.stars)
        elif self.CurrentData == "description":
            print("Description:", self.description)
        self.CurrentData = ""

    def characters(self, content):
        if self.CurrentData == "type":
            self.type = content
        elif self.CurrentData == "format":
            self.format = content
        elif self.CurrentData == "year":
            self.year = content
        elif self.CurrentData == "rating":
            self.rating = content
        elif self.CurrentData == "stars":
            self.stars = content
        elif self.CurrentData == "description":
            self.description = content

if __name__ == "__main__":
    parser = xml.sax.make_parser()
    parser.setFeature(xml.sax.handler.feature_namespaces, 0)
    Handler = MovieHandler()
    parser.setContentHandler(Handler)
    parser.parse("movies.xml")

Résultat :

*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Year: 2003
Rating: PG
Stars: 10
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Year: 1989
Rating: R
Stars: 8
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Stars: 10
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Stars: 2
Description: Viewable boredom

Pour la documentation complète de l'API SAX, consultez la documentation standard Python SAX APIs.

Analyse XML avec l'API DOM

Le Document Object Model (DOM) est une API multi-langage du W3C pour accéder et modifier des documents XML.

Le DOM est extrêmement utile pour les applications à accès aléatoire. SAX ne permet de voir qu'un bout du document à la fois.

Voici le moyen le plus simple de charger rapidement un document XML et créer un objet minidom avec le module xml.dom. L'objet minidom fournit une méthode d'analyse simple qui crée rapidement un arbre DOM depuis le fichier XML.

L'exemple appelle parse(file[, parser]) de l'objet minidom pour analyser le fichier XML en un objet arbre DOM.

#!/usr/bin/python
from xml.dom.minidom import parse
import xml.dom.minidom

DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement

if collection.hasAttribute("shelf"):
    print("Root element : %s" % collection.getAttribute("shelf"))

movies = collection.getElementsByTagName("movie")

for movie in movies:
    print("*****Movie*****")
    if movie.hasAttribute("title"):
        print("Title: %s" % movie.getAttribute("title"))
    type = movie.getElementsByTagName('type')[0]
    print("Type: %s" % type.childNodes[0].data)
    format = movie.getElementsByTagName('format')[0]
    print("Format: %s" % format.childNodes[0].data)
    rating = movie.getElementsByTagName('rating')[0]
    print("Rating: %s" % rating.childNodes[0].data)
    description = movie.getElementsByTagName('description')[0]
    print("Description: %s" % description.childNodes[0].data)

Résultat :

Root element : New Arrivals
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom

Pour la documentation complète de l'API DOM, consultez la documentation standard Python DOM APIs.

Maîtriser la programmation multithread en Python : Techniques de concurrence efficaces Développement GUI en Python avec Tkinter : Guide complet

Python