Guide sur l’analyse XML en Python

Le langage XML (Extensible Markup Language) est un format largement utilisé pour stocker et échanger des données structurées. Les fichiers XML sont couramment utilisés pour représenter des données hiérarchiques, telles que des fichiers de configuration, des formats d’échange de données, des réponses de services web et des plans de sites web.

L’analyse des fichiers XML en Python est une tâche courante, en particulier pour automatiser des processus manuels tels que le traitement des données récupérées à partir d’API web ou le Scraping web.

Dans cet article, vous découvrirez certaines des bibliothèques que vous pouvez utiliser pour analyser du XML en Python, notamment le moduleElementTree, la bibliothèque lxml, minidom, Simple API for XML (SAX) et untangle.

Concepts clés d’un fichier XML

Avant d’apprendre à analyser du XML en Python, vous devez comprendre ce qu’est une définition de schéma XML (XSD) et quels éléments composent un fichier XML. Cette compréhension peut vous aider à sélectionner la bibliothèque Python appropriée pour votre tâche d’analyse.

XSD est une spécification de schéma qui définit la structure, le contenu et les types de données autorisés dans un document XML. Elle sert de syntaxe pour valider la structure et le contenu des fichiers XML par rapport à un ensemble de règles prédéfinies.

Un fichier XML comprend généralement les éléments suivants : espace de noms, racine, attributs, éléments et contenu textuel, qui représentent collectivement des données structurées.

• Espace de noms
• roo
• attributs
• éléments
• contenu textuel

Par exemple, le plan du site Bright Data a la structure XML suivante :

• urlset est l’élément racine.
• <urlset xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd> est la déclaration d’espace de noms spécifique à l’élément urlset, ce qui implique que les règles de cette déclaration s’étendent à l’élément urlset. Tous les éléments qui se trouvent sous cet élément doivent être conformes au schéma défini par cet espace de noms.
• url est le premier enfant de l’élément racine.
• loc est l’élément enfant de l’élément url.

Maintenant que vous en savez un peu plus sur les éléments des fichiers XSD et XML, utilisons ces informations pour analyser un fichier XML à l’aide de quelques bibliothèques.

Différentes façons d’analyser du XML en Python

À des fins de démonstration, vous utiliserez le plan du site Bright Data pour ce tutoriel, qui est disponible au format XML. Dans les exemples suivants, le contenu du plan du site Bright Data est récupéré à l’aide de labibliothèque Python requests.

La bibliothèque Python requests n’est pas intégrée, vous devez donc l’installer avant de continuer. Vous pouvez le faire à l’aide de la commande suivante :

pip install requests

ElementTree

L’API XML ElementTreefournit une API simple et intuitive pour analyser et créer des données XML en Python. Il s’agit d’un module intégré à la bibliothèque standard de Python, ce qui signifie que vous n’avez rien à installer explicitement.

Par exemple, vous pouvez utiliser la méthodefindall()pour trouver tous les élémentsurlà partir de la racine et imprimer la valeur textuelle de l’élémentloc, comme ceci :

import xml.etree.ElementTree as ET
import requests

url = 'https://brightdata.com/post-sitemap.xml'

response = requests.get(url)
if response.status_code == 200:
   
    root = ET.fromstring(response.content)

    for url_element in root.findall('.//{http://www.sitemaps.org/schemas/sitemap/0.9}url'):
        loc_element = url_element.find('{http://www.sitemaps.org/schemas/sitemap/0.9}loc')
        if loc_element is not None:
            print(loc_element.text)
else:
    print("Échec de récupération du fichier XML à partir de l'URL.")

Toutes les URL du plan du site sont imprimées dans la sortie :

https://brightdata.com/case-studies/powerdrop-case-study
https://brightdata.com/case-studies/Addressing la protection de la marque de toutes les angles
https://brightdata.com/case-studies/Taking le contrôle du rayon numérique avec des données publiques en ligne
https://brightdata.com/case-studies/the-seo-transformation
https://brightdata.com/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.com/case-studies/highly-targeted-influencer-marketing
https://brightdata.com/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.com/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.com/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.com/case-studies/data-intensive-analytical-solutions
https://brightdata.com/case-studies/canopy-advantage-solutions
https://brightdata.com/case-studies/seamless-digital-automations

ElementTree est un moyen convivial d’analyser les données XML en Python, doté d’une API simple qui facilite la navigation et la manipulation des structures XML. Cependant, ElementTree a ses limites : il ne prend pas suffisamment en charge la validation des schémas et n’est pas idéal si vous devez vous assurer du strict respect d’une spécification de schéma avant l’analyse.

Si vous disposez d’un petit script qui lit un flux RSS, l’API conviviale d’ElementTree serait un outil utile pour extraire les titres, les descriptions et les liens de chaque élément du flux. Cependant, si vous avez un cas d’utilisation avec une validation complexe ou des fichiers volumineux, il serait préférable d’envisager une autre bibliothèque comme lxml.

lxml

lxmlest une API rapide, facile à utiliser et riche en fonctionnalités pour analyser des fichiers XML en Python ; cependant, il ne s’agit pas d’une bibliothèque précompilée en Python. Si certaines plateformes Linux et Mac ont déjà le paquet lxml installé, d’autres plateformes nécessitent une installation manuelle.

lxml est distribué viaPyPIet vous pouvezl'installerà l’aide de la commandepipsuivante :

pip install lxml

Une fois installé, vous pouvez utiliserlxmlpour analyser des fichiers XML à l’aide dediversesméthodesAPI, telles quefind(),findall(),findtext(),get() etget_element_by_id().

Par exemple, vous pouvez utiliser la méthodefindall()pour parcourir les élémentsurl, trouver leurs élémentsloc(qui sont des éléments enfants de l’élémenturl), puis imprimer le texte de localisation à l’aide du code suivant :

from lxml import etree
import requests

url = "https://brightdata.com/post-sitemap.xml"

response = requests.get(url)
if response.status_code == 200:

    root = etree.fromstring(response.content)
    

    for url in root.findall(".//{http://www.sitemaps.org/schemas/sitemap/0.9}url"):
        loc = url.find("{http://www.sitemaps.org/schemas/sitemap/0.9}loc").text.strip()
        print(loc)
else:
    print("Échec de récupération du fichier XML à partir de l'URL.")

La sortie affiche toutes les URL trouvées dans le plan du site :

https://brightdata.com/case-studies/powerdrop-case-study
https://brightdata.com/case-studies/Addressing la protection de la marque de toutes les angles
https://brightdata.com/case-studies/Taking le contrôle du rayon numérique avec des données publiques en ligne
https://brightdata.com/case-studies/the-seo-transformation
https://brightdata.com/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.com/case-studies/highly-targeted-influencer-marketing
https://brightdata.com/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.com/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.com/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.com/case-studies/data-intensive-analytical-solutions
https://brightdata.com/case-studies/canopy-advantage-solutions
https://brightdata.com/case-studies/seamless-digital-automations

Jusqu’à présent, vous avez appris à rechercher des éléments et à afficher leur valeur. Passons maintenant à la validation du schéma avant l’analyse du XML. Ce processus garantit que le fichier est conforme à la structure spécifiée définie par le schéma.

Le XSD pour le plan du site ressemble à ceci :

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.sitemaps.org/schemas/sitemap/0.9"
           xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
           elementFormDefault="qualified"
           xmlns:xhtml="http://www.w3.org/1999/xhtml">

  
  <xs:element name="urlset">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="url" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element name="url">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="loc" type="xs:anyURI"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

</xs:schema>

Pour utiliser le plan du site pour la validation du schéma, veillez à le copier manuellement et à créer un fichier nommé schema.xsd.

Pour valider le fichier XML à l’aide de ce XSD, utilisez le code suivant :

from lxml import etree

import requests

url = "https://brightdata.com/post-sitemap.xml"

response = requests.get(url)

if response.status_code == 200:

    root = etree.fromstring(response.content)

    try:
        print("Schema Validation:")
        schema_doc = etree.parse("schema.xsd")  
        schema = etree.XMLSchema(schema_doc)  
        schema.assertValid(root)  
        print("XML is valid according to the schema.")
    except etree.DocumentInvalid as e:
        print("XML validation error:", e)

Ici, vous analysez le fichier XSD à l’aide de la méthodeetree.parse(). Vous créez ensuite un schéma XML à partir du contenu du document XSD analysé. Enfin, vous validez le document XML racine par rapport au schéma XML à l’aide de la méthodeassertValid(). Si la validation du schéma réussit, votre sortie inclut un message indiquant quele XML est valide selon le schéma. Sinon, l’exceptionDocumentInvalidest levée.

Votre sortie devrait ressembler à ceci :

 Validation du schéma :
    Le XML est valide selon le schéma.

Maintenant, lisons un fichier XML qui utilise la méthode xpath pour trouver les éléments à l’aide de leur chemin d’accès.

Pour lire les éléments à l’aide de la méthode xpath(), utilisez le code suivant :

from lxml import etree

import requests

url = "https://brightdata.com/post-sitemap.xml"
response = requests.get(url)

if response.status_code == 200:
   
    root = etree.fromstring(response.content)
    
    print("Prise en charge XPath :")
    root = etree.fromstring(response.content)

    namespaces = {"ns": "http://www.sitemaps.org/schemas/sitemap/0.9"}
    for url in root.xpath(".//ns:url/ns:loc", namespaces=namespaces):
        print(url.text.strip())

Dans ce code, vous enregistrez le préfixe d’espace de noms ns et le mappez à l’URI d’espace de noms http://www.sitemaps.org/schemas/sitemap/0.9. Dans l’expression XPath, vous utilisez le préfixe ns pour spécifier les éléments dans l’espace de noms. Enfin, l’expression .//ns:url/ns:loc sélectionne tous les éléments loc qui sont des enfants des éléments url dans l’espace de noms.

Votre résultat ressemblera à ceci :

Prise en charge XPath :

https://brightdata.com/case-studies/powerdrop-case-study
https://brightdata.com/case-studies/Addressing la protection de la marque de toutes les angles
https://brightdata.com/case-studies/Taking le contrôle du rayon numérique avec des données publiques en ligne
https://brightdata.com/case-studies/the-seo-transformation
https://brightdata.com/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.com/case-studies/highly-targeted-influencer-marketing
https://brightdata.com/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.com/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.com/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.com/case-studies/data-intensive-analytical-solutions
https://brightdata.com/case-studies/canopy-advantage-solutions
https://brightdata.com/case-studies/seamless-digital-automations

Comme vous pouvez le constater, les méthodes find() et findall() sont plus rapides que la méthode xpath, car xpath collecte tous les résultats dans la mémoire avant de les renvoyer. Il est recommandé d’utiliser la méthode find(), sauf si vous avez une raison particulière d’utiliser les requêtes XPath.

lxml offre des fonctionnalités puissantes pour l’analyse et la manipulation de XML et HTML. Il prend en charge les requêtes complexes utilisantdes expressions XPath, valide les documents par rapport aux schémas et permet mêmeles transformations XSLT (eXtensible Stylesheet Language Transformations). Cela le rend idéal pour les scénarios où les performances et les fonctionnalités avancées sont cruciales. Cependant, gardez à l’esprit que lxml nécessite une installation séparée, car il ne fait pas partie du package Python de base.

Si vous traitez des données XML volumineuses ou complexes qui nécessitent à la fois des performances élevées et une manipulation avancée, vous devriez envisager d’utiliser lxml. Par exemple, si vous traitez des flux de données financières au format XML, vous devrez peut-être utiliser des expressions XPath pour extraire des éléments spécifiques tels que les cours boursiers, valider les données par rapport à un schéma financier afin d’en garantir l’exactitude, et éventuellement transformer les données à l’aide de XSLT pour une analyse plus approfondie.

minidom

minidomest une bibliothèque d’analyse XML légère et simple qui est incluse dans la bibliothèque standard de Python. Bien qu’elle ne soit pas aussi riche en fonctionnalités ni aussi efficace que l’analyse avec lxml, elle offre un moyen simple d’analyser et de manipuler des données XML dans Python.

Vous pouvez utiliser les différentes méthodes disponibles dans l’objet DOM pour accéder aux éléments. Par exemple, vous pouvez utiliser laméthodegetElementsByTagName()pour récupérer la valeur d’un élément à l’aide de son nom de balise.

L’exemple suivant montre comment utiliser la bibliothèque minidom pour analyser un fichier XML et récupérer les éléments à l’aide de leurs noms de balise :

import requests
import xml.dom.minidom

url = "https://brightdata.com/post-sitemap.xml"

response = requests.get(url)
if response.status_code == 200:
    dom = xml.dom.minidom.parseString(response.content)
    
    urlset = dom.getElementsByTagName("urlset")[0]
    for url in urlset.getElementsByTagName("url"):
        loc = url.getElementsByTagName("loc")[0].firstChild.nodeValue.strip()
        print(loc)
else:
    print("Échec de la récupération du fichier XML à partir de l'URL.")

Votre résultat ressemblera à ceci :

https://brightdata.com/case-studies/powerdrop-case-study
https://brightdata.com/case-studies/Addressing la protection de la marque de toutes les angles
https://brightdata.com/case-studies/Taking le contrôle du rayon numérique avec des données publiques en ligne
https://brightdata.com/case-studies/the-seo-transformation
https://brightdata.com/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.com/case-studies/highly-targeted-influencer-marketing
https://brightdata.com/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.com/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.com/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.com/case-studies/data-intensive-analytical-solutions
https://brightdata.com/case-studies/canopy-advantage-solutions
https://brightdata.com/case-studies/seamless-digital-automations

minidom fonctionne avec les données XML en les représentant sous forme d’arborescence DOM. Cette structure arborescente facilite la navigation et la manipulation des données, et convient particulièrement aux tâches de base telles que la lecture, la modification ou la création de structures XML simples.

Si votre programme implique la lecture des paramètres par défaut d’un fichier XML, l’approche DOM de minidom vous permet d’accéder facilement à des paramètres spécifiques dans le fichier XML à l’aide de méthodes telles que la recherche de nœuds enfants ou d’attributs. Avec minidom, vous pouvez facilement récupérer des paramètres spécifiques du fichier XML, tels que le nœud font-size, et utiliser sa valeur dans votre application.

Analyseur SAX

L’analyseur SAXest une approche d’analyse XML événementielle en Python qui traite les documents XML de manière séquentielle et génère des événements à mesure qu’il rencontre différentes parties du document. Contrairement aux analyseurs basés sur DOM qui construisent une structure arborescente représentant l’ensemble du document XML en mémoire, les analyseurs SAX ne construisent pas une représentation complète du document. Au lieu de cela, ils émettent des événements tels que des balises de début, des balises de fin et du contenu textuel à mesure qu’ils analysent le document.

Les analyseurs SAX sont utiles pour traiter des fichiers XML volumineux ou des flux où l’efficacité de la mémoire est importante, car ils opèrent sur les données XML de manière incrémentielle sans charger l’intégralité du document en mémoire.

Lorsque vous utilisez l’analyseur SAX, vous devez définir les gestionnaires d’événements qui répondent à des événements XML spécifiques, tels que startElement et endElement émis par l’analyseur. Ces gestionnaires d’événements peuvent être personnalisés pour effectuer des actions en fonction de la structure et du contenu du document XML.

L’exemple suivant montre comment analyser un fichier XML à l’aide de l’analyseur SAX en définissant les événements startElement et endElement et en récupérant les informations d’URL à partir du fichier sitemap :

import requests
import xml.sax.handler
from io import BytesIO

class MyContentHandler(xml.sax.handler.ContentHandler):
    def __init__(self):
        self.in_url = False
        self.in_loc = False
        self.url = ""

    def startElement(self, name, attrs):
        if name == "url":
            self.in_url = True
        elif name == "loc" and self.in_url:
            self.in_loc = True

    def characters(self, content):
        if self.in_loc:
            self.url += content

    def endElement(self, name):
        if name == "url":
            print(self.url.strip())
            self.url = ""
            self.in_url = False
        elif name == "loc":
            self.in_loc = False

url = "https://brightdata.com/post-sitemap.xml"

response = requests.get(url)
if response.status_code == 200:

    xml_content = BytesIO(response.content)
    
    content_handler = MyContentHandler()
    parser = xml.sax.make_parser()
    parser.setContentHandler(content_handler)
    parser.parse(xml_content)
else:
    print("Échec de récupération du fichier XML à partir de l'URL.")

Votre résultat ressemblera à ceci :

https://brightdata.com/case-studies/powerdrop-case-study
https://brightdata.com/case-studies/Addressing la protection de la marque de toutes les angles
https://brightdata.com/case-studies/Taking le contrôle du rayon numérique avec des données publiques en ligne
https://brightdata.com/case-studies/the-seo-transformation
https://brightdata.com/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.com/case-studies/highly-targeted-influencer-marketing
https://brightdata.com/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.com/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.com/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.com/case-studies/data-intensive-analytical-solutions
https://brightdata.com/case-studies/canopy-advantage-solutions
https://brightdata.com/case-studies/seamless-digital-automations

Contrairement aux autres analyseurs qui chargent l’intégralité du fichier en mémoire, SAX traite les fichiers de manière incrémentielle, ce qui permet d’économiser de la mémoire et d’améliorer les performances. Cependant, SAX nécessite d’écrire davantage de code pour gérer chaque segment de données de manière dynamique. De plus, il ne peut pas revenir sur certaines parties spécifiques des données pour les analyser ultérieurement.

Si vous devez analyser un fichier XML volumineux (par exemple, un fichier journal contenant divers événements) pour extraire des informations spécifiques (par exemple, des messages d’erreur), SAX peut vous aider à naviguer efficacement dans le fichier. Cependant, si votre analyse nécessite de comprendre les relations entre différents segments de données, SAX n’est peut-être pas le meilleur choix.

untangle

untangleest une bibliothèque d’analyse XML légère pour Python qui simplifie le processus d’extraction de données à partir de documents XML. Contrairement aux analyseurs XML traditionnels qui nécessitent de naviguer dans des structures hiérarchiques, untangle vous permet d’accéder directement aux éléments et attributs XML en tant qu’objets Python.

Avec untangle, vous pouvez convertir des documents XML en dictionnaires Python imbriqués, où les éléments XML sont représentés comme des clés de dictionnaire et leurs attributs et leur contenu textuel sont stockés comme des valeurs correspondantes. Cette approche facilite l’accès et la manipulation des données XML à l’aide des structures de données Python.

untangle n’est pas disponible par défaut dans Python et doit être installé à l’aide de la commande PyPI suivante :

pip install untangle

L’exemple suivant montre comment analyser le fichier XML à l’aide de la bibliothèque untangle et accéder aux éléments XML :

import untangle
import requests

url = "https://brightdata.com/post-sitemap.xml"

response = requests.get(url)

if response.status_code == 200:
  
    obj = untangle.parse(response.text)
    
    for url in obj.urlset.url:
        print(url.loc.cdata.strip())
else:
    print("Échec de la récupération du fichier XML à partir de l'URL.")

Votre résultat ressemblera à ceci :

https://brightdata.com/case-studies/powerdrop-case-study
https://brightdata.com/case-studies/Addressing la protection de la marque de toutes les angles
https://brightdata.com/case-studies/Taking le contrôle du rayon numérique avec des données publiques en ligne
https://brightdata.com/case-studies/the-seo-transformation
https://brightdata.com/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.com/case-studies/highly-targeted-influencer-marketing
https://brightdata.com/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.com/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.com/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.com/case-studies/data-intensive-analytical-solutions
https://brightdata.com/case-studies/canopy-advantage-solutions
https://brightdata.com/case-studies/seamless-digital-automations

untangle offre une approche conviviale pour travailler avec des données XML dans Python. Il simplifie le processus d’analyse syntaxique grâce à une syntaxe claire et convertit automatiquement la structure XML en objets Python faciles à utiliser, éliminant ainsi le besoin de techniques de navigation complexes. Cependant, gardez à l’esprit que untangle nécessite une installation séparée car il ne fait pas partie du package Python de base.

Vous devriez envisager d’utiliser untangle si vous disposez d’un fichier XML bien formé et que vous devez le convertir rapidement en objets Python pour un traitement ultérieur. Par exemple, si vous disposez d’un programme qui télécharge des données météorologiques au format XML, untangle pourrait être un bon choix pour analyser le XML et créer des objets Python représentant la température, l’humidité et les prévisions actuelles. Ces objets pourraient ensuite être facilement manipulés et affichés dans votre application.

Conclusion

Dans cet article, vous avez tout appris sur les fichiers XML et les différentes méthodes d’analyse des fichiers XML en Python.

Que vous travailliez avec de petits fichiers de configuration, que vous analysiez des réponses de services web volumineuses ou que vous extrayez des données à partir de plans de site étendus, Python offre des bibliothèques polyvalentes pour automatiser et rationaliser vos tâches d’analyse XML. Cependant, lorsque vous accédez à des fichiers sur le web à l’aide de la bibliothèque requests sans gestion de Proxy, vous pouvez rencontrer des exceptions de quota et des problèmes de limitation.Bright Dataest un réseau de proxys primé qui fournitdes solutions de Proxyfiables et efficaces pour garantir une récupération et une analyse des données sans faille. Avec Bright Data, vous pouvez effectuer des tâches d’analyse XML sans vous soucier des limitations ou des interruptions. Contactez-nous pour en savoir plus.

Vous souhaitez éviter tout le processus de scraping et d’analyse ? Essayez gratuitement notre marché de données!