Comment analyser XML et les flux RSS en Python

Parse xml rss feeds python cover

Les données se présentent sous de nombreux formats, des simples tableaux CSV et objets JSON aux documents XML plus descriptifs et hiérarchisés. XML peut sembler un peu old-school, mais il reste très répandu : dans les flux RSS, les API et les configurations logicielles.

Avant de pouvoir exploiter des données XML, vous devez les parser. Autrement dit, vous apprenez à votre programme à en interpréter le contenu. Avec des bibliothèques Python comme ElementTree, minidom et lxml, le parsing XML est un processus simple et intuitif.

Quel que soit le format de données rencontré, savoir le manipuler, et notamment manipuler XML, est une compétence essentielle pour tout développeur. Dans ce guide, vous apprendrez pas à pas à lire, parcourir et extraire des données XML.

Les bases de XML

XML signifie Extensible Markup Language. C’est un format universel de stockage et d’échange de données. Sa structure est à la fois lisible par les humains et exploitable par les machines. Ce langage a été conçu pour être simple, adaptable et largement utilisable en ligne.

On peut représenter XML sous la forme d’un arbre. Comme un arbre réel avec ses branches et ses feuilles, il comporte une racine et des éléments enfants imbriqués. Cette représentation montre comment XML organise les données de façon hiérarchique. Python propose plusieurs approches pour manipuler les données XML, dont le module ElementTree, l’une des plus populaires. ElementTree s’appuie sur deux classes principales : ElementTree, qui représente l’ensemble du document, et Element, qui représente un nœud individuel.  

Comment les développeurs parsèrent XML : principales techniques

En Python, la fonction parse() constitue généralement la première étape du parsing d’un fichier XML. Elle traite un document XML et le transforme en structure arborescente que votre programme peut parcourir. Cette fonction est à la base de diverses approches, que vous utilisiez ElementTree, lxml ou d’autres bibliothèques.

Pour comprendre les différentes méthodes de parsing, il faut d’abord connaître les composants d’un fichier XML :

  • Espace de noms – permet d’éviter les conflits de noms en qualifiant les éléments et les attributs.
  • Élément racine – le conteneur principal qui englobe tous les autres éléments.
  • Attributs – des paires clé-valeur qui fournissent des informations supplémentaires sur les éléments.
  • Éléments enfants – des éléments imbriqués qui organisent hiérarchiquement les données.
  • Contenu du texte – les informations réelles contenues dans les éléments.

Ces composants forment un format structuré qui permet aux programmes de stocker et de partager des données complexes. Après avoir compris cette structure, examinons les principales techniques de parsing XML en Python :  

1. Module ElementTree   

Une bibliothèque intégrée à Python, avec une API facile à utiliser pour parcourir les arbres XML. Elle convient à la plupart des tâches grâce à son bon équilibre entre simplicité et performances.   

2. lxml   

Une bibliothèque tierce qui prend en charge XPath, XSLT et la validation. Elle est plus rapide et plus complète que ElementTree, ce qui la rend adaptée au traitement de documents XML complexes.   

3. DOM (Document Object Model)  

Cette approche charge l’intégralité du document XML en mémoire sous forme d’arborescence. Elle est facile à parcourir et à modifier, mais peut consommer beaucoup de mémoire pour les fichiers volumineux. 

4. SAX (Simple API for XML)   

Un parseur événementiel qui traite XML de façon séquentielle. Peu gourmand en mémoire et rapide pour les fichiers volumineux, il peut toutefois être moins intuitif pour les opérations complexes.   

5. Untangle   

Cette bibliothèque transforme les données XML en objets Python faciles d’accès. Elle est idéale pour un parsing rapide avec un minimum de code, mais se montre moins souple face aux structures XML complexes.   

Pour ce tutoriel, vous aurez besoin de…

  • Python et Requests  

Si Python 3.x n’est pas installé sur votre ordinateur, vous pouvez le télécharger depuis https://www.python.org/. Ouvrez un terminal et installez Requests en utilisant pip :

pip install requests ou  pip3 install requests

  • Visual Studio Code (VS Code)

Pour exécuter toutes les commandes nécessaires, vous pouvez utiliser le terminal intégré à Visual Studio Code (VS Code). Téléchargez-le depuis le site officiel et suivez les instructions d’installation correspondant à votre système d’exploitation.

  • Flux RSS

Un flux RSS est un fichier XML particulier qui sert à diffuser automatiquement les actualités ou mises à jour d’un site Web. En termes simples, c’est une liste structurée des dernières publications, que les programmes peuvent lire.

Par exemple, notre site Web comporte une rubrique de tutoriels. Plutôt que de le consulter chaque jour pour savoir si un nouveau tutoriel a été publié, vous pouvez utiliser son flux RSS, un fichier XML qui contient les informations sur les publications récentes. Nous utiliserons le flux RSS DataImpulse dans ce tutoriel. Voyons maintenant les bibliothèques nécessaires et le code correspondant.

ElementTree

Voyons comment utiliser le module ElementTree intégré de Python pour analyser les données XML à partir d’un flux RSS.  

La première étape consiste à importer xml.etree.ElementTree. Le processus est simple : nous envoyons une requête GET à l’URL du flux RSS, puis le serveur renvoie les données XML. L’.content de la réponse fournit les données brutes sous forme d’octets, qu’ElementTree peut parser. Avec ET.fromstring(), nous convertissons les données XML en structure arborescente et récupérons l’élément racine. Dans un flux RSS, la majeure partie du contenu suit la structure <channel> → <item>éléments.

La méthode find() renvoie le premier élément correspondant, tandis que findall() renvoie tous les éléments enfants portant une balise donnée. Ici, items est la liste de tous les éléments, chacun représentant un tutoriel ou un article.

Exemple de code :  


import xml.etree.ElementTree as ET
import requests

# URL of the RSS feed (from DataImpulse site)
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"

# Download the XML data
response = requests.get(FEED_URL)
xml_data = response.content

# Parse the XML
root = ET.fromstring(xml_data)

# In RSS feeds, items are inside 
channel = root.find("channel")
items = channel.findall("item")

# Print titles and links of the items
for item in items:
   title = item.findtext("title")
   link = item.findtext("link")
   print(f"Title: {title}")
   print(f"Link: {link}\n")

Enfin, nous extrayons et affichons le titre et le lien de chaque élément avec findtext(), qui récupère directement le contenu textuel. Lorsque vous exécutez le script, vous obtenez une liste claire de tous les titres de tutoriels et de leurs URL.  

lxml 

lxml est une bibliothèque externe qui étend les fonctionnalités d’ElementTree et ajoute la prise en charge de XPath, un langage de requête permettant de parcourir les documents XML. Dans cet exemple, nous utiliserons lxml.etree pour analyser un flux RSS et extraire les titres des articles.

Nous commençons par récupérer le flux RSS en utilisant requests.get(), comme avant. Le contenu de la réponse est transmis à etree.fromstring(), qui parse le XML et renvoie l’élément racine. Avec lxml, nous pouvons utiliser des expressions XPath pour rechercher des éléments. Elles offrent une navigation plus rapide et plus souple que les méthodes standard d’ElementTree.


import requests
from lxml import etree

# URL of the RSS feed
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"

# Download the XML data
response = requests.get(FEED_URL)
xml_data = response.content

# Parse XML
root = etree.fromstring(xml_data)
items = root.xpath("//channel/item")

# Show list of titles with numbers
print("Available blog posts:\n")
for item in items:
   title = item.findtext("title")
   print(title)

Enfin, nous parcourons les éléments <item> et extrayons le titre de chaque article avec findtext(“title”), puis les affichons.

Minidom 

Dans cet exemple, nous utilisons Minidom, abréviation de Minimal DOM Implementation. Il fait partie de la bibliothèque standard de Python et charge l’intégralité du document XML en mémoire sous la forme d’un Document Object Model (DOM).  

Nous appelons minidom.parseString() pour analyser le XML et construire un objet DOM (doc). Parmi les méthodes DOM courantes, nous en utiliserons deux. La première est getElementsByTagName(“tag”,) qui renvoie tous les éléments portant le nom de balise indiqué. La seconde est .firstChild.nodeValue qui récupère le contenu textuel d’un nœud.

Enfin, nous utilisons toprettyxml(). Cette méthode permet d’afficher le premier élément dans une mise en forme XML lisible.   

Voici comment parser les données d’un flux RSS avec Minidom :


import requests
from xml.dom import minidom

# URL of the RSS feed
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"

# Download XML data
response = requests.get(FEED_URL)
xml_data = response.content

# Parse XML with minidom
doc = minidom.parseString(xml_data)

# Get all  elements
items = doc.getElementsByTagName("item")

print(f"Total articles found in feed: {len(items)}\n")

# Show titles with links
for i, item in enumerate(items, start=1):
   title = item.getElementsByTagName("title")[0].firstChild.nodeValue
   link = item.getElementsByTagName("link")[0].firstChild.nodeValue
   print(f"{i}. {title}")
   print(f"   Link: {link}\n")

# Show raw XML of the first  (just for demo)
print("First  as raw XML:\n")
print(items[0].toprettyxml())

SAX 

SAX lit le XML de manière séquentielle, élément par élément. Il déclenche des événements spécifiques pour chaque partie du document XML :

  • startElement(name, attrs) → lorsqu’une balise s’ouvre
  • characters(content) → lorsque du texte est lu entre les balises
  • endElement(name) → lorsqu’une balise se ferme

Enregistrez le code dans un fichier, puis exécutez-le :  


import requests
import xml.sax

# Custom handler for SAX parsing
class RSSHandler(xml.sax.ContentHandler):
   def __init__(self):
       super().__init__()
       self.current_tag = ""
       self.in_item = False
       self.title = ""
       self.link = ""
       self.counter = 0

   def startElement(self, name, attrs):
       if name == "item":
           self.in_item = True
           self.title = ""
           self.link = ""
       self.current_tag = name

   def characters(self, content):
       if self.in_item:
           if self.current_tag == "title":
               self.title += content
           elif self.current_tag == "link":
               self.link += content

   def endElement(self, name):
       if name == "item":
           self.counter += 1
           print(f"{self.counter}. {self.title.strip()}")
           print(f"   Link: {self.link.strip()}\n")
           self.in_item = False
       self.current_tag = ""

# Download the XML feed
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"
response = requests.get(FEED_URL)
xml_data = response.content

# Parse XML with SAX
print("Parsing RSS feed with SAX...\n")
handler = RSSHandler()
xml.sax.parseString(xml_data, handler)

print(f"Total items parsed: {handler.counter}")

L’avantage de cette méthode est l’efficacité de la mémoire, puisqu’elle ne stocke pas l’intégralité du document.  

Untangle

Cette méthode offre une façon plus simple de manipuler XML. La bibliothèque Untangle convertit les documents XML en objets Python. Il n’est donc pas nécessaire de parcourir manuellement les éléments ni de gérer les événements.  

Lorsque vous analysez XML avec untangle.parse(), la bibliothèque lit automatiquement le fichier XML, convertit chaque balise XML en objet Python et stocke les données de chaque balise dans les attributs .cdata (lorsqu’il s’agit de contenu textuel). Au lieu de travailler avec des nœuds ou des événements, vous parcourez simplement la structure XML comme un objet Python classique.  

Voici le code : 


import requests
import untangle
from io import BytesIO

# RSS feed from DataImpulse
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"

# Download XML
resp = requests.get(FEED_URL)
resp.raise_for_status()
xml_bytes = resp.content

# Parse XML with untangle (use BytesIO for bytes input)
doc = untangle.parse(BytesIO(xml_bytes))

# Get all  elements
items = doc.rss.channel.item

print("Articles from DataImpulse RSS:\n")

# Print articles
for i, it in enumerate(items, start=1):
   title = it.title.cdata if hasattr(it, "title") else ""
   link = it.link.cdata if hasattr(it, "link") else ""
   desc = it.description.cdata if hasattr(it, "description") else ""
  
   print(f"{i}. {title}")
   print(f"   Link: {link}")
   if desc:
       print(f"   Description: {desc}")
   print()

Quelques recommandations supplémentaires

  • Gérer les erreurs de parsing

Parfois, les flux peuvent être indisponibles ou contenir des balises inattendues. Dans ce cas, utilisez try/except lors du téléchargement ou du parsing de XML.

  • Préférer .content pour récupérer des données XML

L’attribut .content renvoie les données brutes sous forme d’octets et évite ainsi les problèmes d’encodage que l’attribut .text pourrait provoquer.

  • Vérifier que les éléments existent  

Tous les fichiers XML n’ont pas la même structure. Utilisez des conditions telles que if item.find(‘title’) is not None avant d’accéder aux balises.

  • Surveillez l’utilisation des ressources avec les fichiers volumineux

Pour les documents XML volumineux, utilisez SAX, qui lit les données de manière séquentielle sans tout charger en mémoire.

Récupérer des données XML depuis des sites externes peut être difficile. Les proxies aident à garantir un accès fluide depuis différents emplacements tout en préservant la confidentialité.

À retenir

  • Le parsing XML consiste à lire des fichiers XML et à en extraire des données structurées et exploitables.
  • ElementTree fournit une approche arborescente pour parcourir et extraire les éléments XML.
  • lxml est une bibliothèque qui prend en charge les requêtes XPath pour un parsing XML plus rapide.
  • Minidom charge l’intégralité du XML sous forme d’arborescence DOM, ce qui permet d’accéder aux nœuds et au texte comme dans un objet structuré.
  • SAX est idéal pour les fichiers XML volumineux, car il traite le XML étape par étape sans tout conserver en mémoire.
  • Untangle convertit XML en objets Python afin d’accéder facilement aux balises et à leur contenu.

Articles connexes  

Intégrer des proxies à des requêtes Python

Comment scraper eBay avec Python et des proxies

Comment configurer les proxies DataImpulse en Java

Récupérer des données produit Amazon avec Python

Créer un rotateur de proxy personnalisé avec Python

Gérer les contrôles de sécurité à l’aide de Python et Selenium

Share article: