Manipulation XML avec

Python

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 1

1. Introduction : Qu'est-ce que le XML pour Python ?
• Le XML (Extensible Markup Language) est un format de stockage de données structuré sous
forme d'arbre. En Python, on utilise principalement la bibliothèque
standard [Link].
1.1 Vocabulaire essentiel :
• Root (Racine) : Le nœud parent unique (ex: <catalogue>).
• Element (Élément) : Une balise (ex: <produit>).
• SubElement : Une balise enfant à l'intérieur d'une autre.
• Attribut : Une information dans la balise (ex: <produit id="123">).
• Texte : La donnée entre les balises (ex: <nom>Pomme</nom>).

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 2

En Python, la manipulation d’un document XML se fait principalement avec le module
[Link], qui permet de lire, parcourir, modifier et écrire des fichiers XML sous
forme d’arbre.
C’est une approche simple et efficace pour analyser la structure hiérarchique d’un XML et travailler
directement sur ses éléments et attributs
Définition
La manipulation XML avec Python consiste à :
Lire un fichier XML et le transformer en une structure arborescente (ElementTree).
Explorer les éléments et attributs avec des boucles ou des requêtes XPath.
Modifier le contenu (ajouter, supprimer, changer des nœuds ou des attributs).
Écrire le fichier XML mis à jour sur disque.

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 3

Modules :
• [Link] : API simple et légère pour lire/écrire des XML.
• [Link] : implémentation minimale du modèle DOM (utile pour formater joliment).
• [Link] : analyse événementielle, adaptée aux gros fichiers XML.
• [Link] : parseur rapide intégré à Python.

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 4

Exemple:
import [Link] as ET
# Charger le fichier XML
tree = [Link]( "[Link]" )
root = [Link]()
# Parcourir les éléments
for fichier in [Link]( "fichier" ):
nom = [Link]("nom")
contenu = [Link]
print(f"Nom: {nom}, Contenu: {contenu}")
# Modifier un attribut
[Link]("chemin", "c:/nouveauxDocuments")
# Ajouter un nouvel élément
nouveau = [Link]("fichier", nom="[Link]")
[Link] = "contenu ajouté"
[Link](nouveau)
# Sauvegarder le fichier modifié
[Link]("dossier_modifie.xml", encoding="utf-8", xml_declaration=True)
31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 5
Note Importante

• XML est hiérarchique → Python le représente comme un arbre.

• Attributs et texte sont accessibles via .get() et .text.
• XPath simplifié est disponible pour rechercher des éléments (find, findall).
• Écriture possible avec [Link]().

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 6

2. Les 4 étapes de la création
• Pour créer un XML, on suit toujours ce cycle :
• Définir la Racine : root = [Link]("nom")
• Ajouter des branches : enfant = [Link](root, "nom")
• Remplir les données : [Link] = "valeur" ou [Link]("clé", "valeur")
• Sauvegarder : tree = [Link](root) puis [Link]("[Link]")

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 7

3. Exemple de référence (Le "Hello World" du XML) python
import [Link] as ET
# Création de la structure
ecole = [Link]("ecole")
classe = [Link](ecole, "classe", nom="Informatique")

# Ajout d'un étudiant

etudiant = [Link](classe, "etudiant")
nom = [Link](etudiant, "nom")
[Link] = "Jean Dupont"
# Génération du fichier
arbre = [Link](ecole)
[Link](arbre, space=" ") # Pour que le fichier soit lisible (Python 3.9+)
[Link]("[Link]", encoding="utf-8", xml_declaration=True)

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 8

• 4. Exercice d'application
• Sujet : Gestion d'un Inventaire de Magasin
• Consigne :
Écrivez un script Python qui génère un fichier nommé [Link]. Le fichier doit respecter la
structure suivante :
• Une racine nommée <magasin>.
• Deux éléments <produit>.
• Chaque produit doit avoir :
• Un attribut categorie (ex: "Électronique").
• Une balise <nom> avec le nom de l'article.
• Une balise <prix> avec une valeur numérique.
• Une balise <stock> avec la quantité disponible.
• Bonus : Ajoutez une boucle for pour ajouter 3 produits automatiquement à partir d'une liste de
dictionnaires Python.

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 9

Correction:
import [Link] as ET

# Création de la racine
magasin = [Link]("magasin")

# Exemple de produits définis en dur

produit1 = [Link](magasin, "produit", categorie="Électronique")
[Link](produit1, "nom").text = "Ordinateur portable"
[Link](produit1, "prix").text = "7500"
[Link](produit1, "stock").text = "12"

produit2 = [Link](magasin, "produit", categorie="Alimentation")

[Link](produit2, "nom").text = "Chocolat"
[Link](produit2, "prix").text = "25"
[Link](produit2, "stock").text = "200"

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 10

Suite------
# Bonus : ajout automatique via une liste de dictionnaires
liste_produits = [
{"categorie": "Électronique", "nom": "Smartphone", "prix": "4500", "stock": "30"},
{"categorie": "Maison", "nom": "Lampe LED", "prix": "150", "stock": "50"},
{"categorie": "Papeterie", "nom": "Cahier", "prix": "20", "stock": "100"}
]
for p in liste_produits:

produit = [Link](magasin, "produit", categorie=p["categorie"])

[Link](produit, "nom").text = p["nom"]
[Link](produit, "prix").text = p["prix"]
[Link](produit, "stock").text = p["stock"]
# Sauvegarde dans un fichier XML
arbre = [Link](magasin)
[Link]("[Link]", encoding="utf-8", xml_declaration=True)

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 11

Résultat attendu (extrait du fichier [Link])
<magasin>
<produit<magasin>
<produit categorie="Électronique">
<nom>Ordinateur portable</nom>
<prix>7500</prix>
<stock>12</stock>
</produit>
<produit categorie="Alimentation">
<nom>Chocolat</nom>
<prix>25</prix>
<stock>200</stock>
</produit>
<produit categorie="Électronique">
<nom>Smartphone</nom>
<prix>4500</prix>
<stock>30</stock>
</produit>
...
31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 12
• Cours Partie 2 : Lire et Rechercher dans un XML
• Une fois le fichier créé, Python doit pouvoir "fouiller" dedans pour extraire des informations
précises. On appelle cela le Parsing.
• 1. Charger un fichier XML
• Pour lire un fichier, on utilise [Link](). Cela transforme le fichier en un objet manipul
python
import [Link] as ET

# Charger le document
tree = [Link]('[Link]')
root = [Link]() # Récupérer la racine (<magasin>)

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 13

2. Parcourir les données
Il existe trois méthodes principales pour trouver des informations :
[Link]("balise") : Cherche toutes les balises de ce nom, peu importe où elles sont cachées.
[Link]("balise") : Cherche uniquement les enfants directs de la racine.
.find("balise") : Récupère uniquement le premier élément trouvé.

Exemple : Extraire les noms de produits

python
for produit in [Link]("produit"):
nom = [Link]("nom").text
prix = [Link]("prix").text
print(f"Article : {nom} | Prix : {prix}€")

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 14

3. Accéder aux Attributs
Pour lire une information stockée dans la balise (comme categorie="Accessoires"), on utilise .get() :

python
for produit in [Link]("produit"):
cat = [Link]("categorie")
print(f"Catégorie détectée : {cat}")

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 15

Exercice Pratique n°2 : L'Analyseur de Stock
• Objectif : Utiliser le fichier [Link] créé précédemment pour faire un
rapport automatique.
• Énoncé :
Écrivez un script Python qui :
• Ouvre le fichier [Link].
• Parcourt tous les produits.
• Calcule la valeur totale du stock (Prix × Quantité).
• Affiche le nom des produits dont le stock est inférieur à 10 (Alerte
réapprovisionnement).

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 16

Corriger:
python
import [Link] as ET

tree = [Link]('[Link]')
root = [Link]()

valeur_totale_magasin = 0

print("--- RAPPORT D'INVENTAIRE ---")

for p in [Link]("produit"):
nom = [Link]("nom").text

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 17

prix = float([Link]("prix").text)
stock = int([Link]("stock").text)

# Calcul de la valeur
valeur_produit = prix * stock
valeur_totale_magasin += valeur_produit

# Vérification du stock bas

if stock < 10:
print(f" ALERTE : Le produit '{nom}' est presque épuisé ({stock} restants).")

print(f"\nValeur totale du stock en magasin : {valeur_totale_magasin}€")

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 18

Résumé des commandes fondamentales (A retenir) :

Action Commande

Charger tree = [Link]('[Link]')

Racine root = [Link]()

Chercher tout [Link]('nom')

Chercher un [Link]('nom')

Attribut [Link]('attribut')

Contenu [Link]
31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 19
Pour ces concepts avancés (Namespaces, XSD, XSLT),
la bibliothèque standard [Link] devient limitée. On utilise alors lxml, qui est la
référence professionnelle en Python.

Cours Partie 3 : XML Avancé (Espaces de noms, XSD et XSLT)

1. Les Espaces de Noms (Namespaces)
Les namespaces évitent les conflits entre balises de même nom (ex: <titre> pour un
livre vs <titre> pour une civilité).
Structure : xmlns:prefix="URL".
En Python : Il faut spécifier l'URL complète entre accolades {}.

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 20

python
import [Link] as ET

# Créer avec un Namespace

ns = {"h": "[Link]
root = [Link](f"{{{ns['h']}}}table") # Résultat: <h:table xmlns:h="...">

# Lire avec un Namespace

# On passe le dictionnaire 'ns' aux fonctions de recherche
titre = [Link]("h:titre", ns)

Validation XML Schema (XSD)

Le XSD définit les règles du fichier (types de données, présence obligatoire d'une
balise).
• Note : Nécessite l'installation de lxml (pip install lxml).
31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 21
• 2. python
from lxml import etree
# Charger le schéma et le XML
schema_root = [Link]("[Link]")
schema = [Link](schema_root)
xml_doc = [Link]("[Link]")
# Valider
if [Link](xml_doc):
print("Le XML est valide !")
else:
print("Erreur de structure :", schema.error_log.filter_from_errors()[0])

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 22

3. Transformation XSLT
Le XSLT permet de transformer un XML en un autre format (HTML, Texte, ou
autre XML).
4. Installation de l'outil
Exécution de la commande dans le terminal pour installer lxml

bash
pip install lxml

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 23

5. Les concepts clés du code Python
Pour réaliser une transformation, le script Python doit suivre scrupuleusement 4 étapes :

1. Le Parsing : Charger et parser le fichier XML et le fichier XSLT en structures d'arbres d'objets.
2. L'Instanciation : Créer un objet transformateur en lui passant l'arbre XSLT.
3. L'Exécution : Appliquer ce transformateur sur l'arbre XML.
4. La Sérialisation : Convertir le résultat obtenu en chaîne de caractères ou en fichier physique.

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 24

6. Code Python (fichiers locaux)
Ce script charge un fichier XML et un fichier XSLT locaux, puis génère le résultat

python
from lxml import etree
# 1. Charger les fichiers XML et XSLT
donnees_xml = [Link]("[Link]")
regles_xslt = [Link]("[Link]")
# 2. Créer le processeur de transformation
transformateur = [Link](regles_xslt)
# 3. Appliquer la transformation
document_final = transformateur(donnees_xml)

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 25

# 4. Sauvegarder le résultat obtenu
with open("[Link]", "wb") as fichier:
[Link]([Link](document_final, pretty_print=True, encoding="utf-8"))
print("Transformation réussie !")

7. Code Python (chaînes de caractères textuelles)

Si vos données XML et XSLT sont stockées directement sous forme de chaînes de
texte dans votre script :
python

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 26

from lxml import etree
# Définition des structures textuelles
xml_txt = "<racine><message>Bonjour le monde</message></racine>"
xslt_txt = """<xsl:stylesheet version="1.0"
xmlns:xsl="[Link]
<xsl:template match="/">
<html_output>
<contenu><xsl:value-of select="/racine/message"/></contenu>
</html_output>
</xsl:template>
</xsl:stylesheet>"""

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 27

# Conversion du texte en arbres exploitables
xml_arbre = [Link](xml_txt)
xslt_arbre = [Link](xslt_txt)
# Application de la transformation
convertir = [Link](xslt_arbre)
resultat = convertir(xml_arbre)
# Affichage de la sortie finale
print([Link](resultat, pretty_print=True, encoding="unicode"))

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 28

Note importante sur les versions XSLT
La bibliothèque lxml s'appuie sur libxslt, ce qui signifie qu'elle supporte uniquement
XSLT 1.0. Si vous devez utiliser des fonctionnalités de XSLT 2.0 ou XSLT 3.0,
vous devrez vous tourner vers la bibliothèque alternative officielle SaxonC de
Saxonica.
8. Travaux Pratiques : Étude de cas complète
Étape A : Le fichier de données ([Link])
Ce fichier contient les données brutes à traiter.

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 29

xml
<?xml version="1.0" encoding="UTF-8"?>
<classe>
<etudiant id="01">
<nom>Dupont</nom>
<prenom>Jean</prenom>
<note>15</note>
</etudiant>
<etudiant id="02">
<nom>Martin</nom>
<prenom>Sophie</prenom>
<note>18</note>
</etudiant>
</classe>

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 30

Étape B : La feuille de style ([Link])
Ce fichier définit comment transformer les données XML en un tableau HTML propre.
xml
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="[Link]

<!-- Sortie attendue : HTML -->

<xsl:output method="html" encoding="UTF-8" indent="yes"/>

<!-- Règle principale sur la racine -->

<xsl:template match="/">
<html>
<head><title>Liste des étudiants</title></head>
<body>
<h1>Résultats de la classe</h1>

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 31

<table border="1">
<tr bgcolor="#9acd32">
<th>ID</th>
<th>Nom Prénom</th>
<th>Note</th> </tr>
<!-- Boucle sur chaque étudiant -->
<xsl:for-each select="classe/etudiant">
<tr> <td><xsl:value-of select="@id"/></td> <td><xsl:value-of select="nom"/>
<xsl:value-of
select="prenom"/></td> <td><xsl:value-of select="note"/>/20</td> </tr>
</xsl:for-each> </table>
</body> </html>
</xsl:template> </xsl:stylesheet>

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 32

Étape C : Le script d'automatisation Python ([Link])
Le code qui orchestre la transformation des deux fichiers précédents.
python
from lxml import etree

try:

# 1. Chargement des fichiers sources

arbre_xml = [Link]("[Link]")

arbre_xslt = [Link]("[Link]")

# 2. Préparation du moteur XSLT

transformateur = [Link](arbre_xslt)

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 33

 # 3. Application de la transformation
resultat_transformation = transformateur(arbre_xml)

# 4. Écriture du résultat final en HTML

with open("[Link]", "wb") as fichier_sortie:
fichier_sortie.write([Link](resultat_transformation, pretty_print=True,
method="html"))
print("Fichier '[Link]' généré avec succès !")
except [Link] as e:
print(f"Erreur de syntaxe XML : {e}")
except Exception as e: print(f"Une erreur est survenue : {e}")

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 34

9. Fonctionnalité Avancée : Passage de paramètres
Il est fréquent de vouloir filtrer les données XML dynamiquement depuis Python
(par exemple, afficher uniquement les étudiants ayant une note supérieure à un
seuil).

Modification XSLT
Déclarer un paramètre global juste sous la balise <xsl:stylesheet> :

<xsl:param name="note_minimale" select="0"/>

Utiliser le paramètre dans la boucle avec une condition de filtrage :
<xsl:for-each select="classe/etudiant[note >= $note_minimale]">

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 35

Modification Python
Il suffit de passer le paramètre sous forme de chaîne de caractères lors de l'appel du transformateur
(attention aux guillemets imbriqués indispensables pour lxml) :
# Filtrer pour n'avoir que les notes >= 16
resultat = transformateur(arbre_xml, note_minimale="'16'")

31/05/2026 Universite Mohamed V, ENSIAS Prof :Najat Chadli 36