Format XML

RappelFormat reconnu pour l'échange de données entre applications

Un fichier XML (Extensible Markup Language) est un fichier texte (!) permettant de décrire des documents.

Le principe de construction est simple et immuable (organisation hiérarchique, balises, attributs), mais la structure est évolutive (extensible) en fonction du document à décrire.

1
<?xml version="1.0" encoding="UTF-8"?>
2
<liste>
3
	<personne>
4
		<Prenom>Robert</Prenom>
5
		<Nom>Lepingre</Nom>
6
		<Email>bobby@exemple.com</Email>
7
		<Age>41</Age>
8
		<Ville>Paris</Ville>
9
	</personne>
10
	<personne>
11
		<Prenom>Jeanne</Prenom>
12
		<Nom>Ducoux</Nom>
13
		<Email>jeanne@exemple.com</Email>
14
		<Age>32</Age>
15
		<Ville>Marseille</Ville>
16
	</personne>
17
	<personne>
18
		<Prenom>Pierre</Prenom>
19
		<Nom>Lenfant</Nom>
20
		<Email>pierre@exemple.com</Email>
21
		<Age>23</Age>
22
		<Ville>Rennes</Ville>
23
	</personne>
24
</liste>

Méthode1. Sauvegarder un objet de type Personne dans un fichier

Le module « xml » permet de gérer les fichiers au format XML sous Python

ModulePersonne.py [py]
1
#import module Perso
2
import ModulePersonne as MP
3
4
#import module xml
5
import xml.etree.ElementTree as ET
6
7
#saisie personne
8
p = MP.Personne()
9
p.saisie()
10
11
#ecriture racine
12
root = ET.Element("personne")
13
14
#ecriture des elements
15
item_prenom = ET.SubElement(root,"Prenom")
16
item_prenom.text = p.prenom
17
18
item_nom = ET.SubElement(root,"Nom")
19
item_nom.text = p.nom
20
21
item_email = ET.SubElement(root,"Email")
22
item_email.text = p.email
23
24
item_age = ET.SubElement(root,"Age")
25
item_age.text = str(p.age)
26
27
item_ville = ET.SubElement(root,"Ville")
28
item_ville.text = p.ville
29
30
#sauvegarde fichier
31
tree = ET.ElementTree(root)
32
tree.write("personne.xml")
- root est le nœud racine de la structure ;
- Noter la nature hiérarchique de la structure ;
- Il peut y avoir des nœuds intermédiaires. (cf. la sauvegarde des listes d'objets) ;
- Nous typons toutes les informations en chaîne de caractères cf. str() ;
- personne, Prenom, Nom, EMail, Age, Ville sont des balises XML.
SimulationÀ faire vous-même
1) Si ce n'est déjà fait, téléchargez le fichier Python ci-dessous et stockez le dans le même répertoire que votre futur programme Python nécessaire à la question 2).
ModulePersonne.py [py]
2) Utilisez la méthode précédente pour obtenir le premier enregistrement du tableau de données au format XML.
<personne><Prenom>Robert</Prenom><Nom>Lepingre</Nom><Email>bobby@exemple.com</Email><Age>41</Age><Ville>Paris</Ville></personne>
ComplémentLecture du fichier - Charger un fichier XML
Dans le listing suivant :
- parse() ouvre le fichier et charge la structure (l'arbre) ;
- getroot() donne accès à la racine de l'arbre ;
- findtext() permet de lire le contenu des balises ici sous le nœud racine, root.findtext().
1
#import module Perso
2
import ModulePersonne as MP
3
4
#import module xml
5
import xml.etree.ElementTree as ET
6
7
#ouverture
8
tree = ET.parse("personne.xml")
9
10
#recuperer la racine
11
root = tree.getroot()
12
13
#trans. en Personne
14
p = MP.Personne()
15
p.prenom = root.findtext("Prenom")
16
p.nom = root.findtext("Nom")
17
p.email = root.findtext("Email")
18
p.age = int(root.findtext("Age"))
19
p.ville= root.findtext("Ville")
20
21
#affichage
22
p.affichage()
RemarqueVariante avec les attributs
On peut associer des attributs aux balises, une structure possible pour le fichier XML serait d'associer à la balise « personne » l'attribut « Prenom ».
<personne Prenom="Robert"><Nom>Lepingre</Nom><Email>bobby@exemple.com</Email><Age>41</Age><Ville>Paris</Ville></personne>
1
#import module Perso
2
import ModulePersonne as MP
3
4
#import module xml
5
import xml.etree.ElementTree as ET
6
7
#saisie personne
8
p = MP.Personne()
9
p.saisie()
10
11
#ecriture racine
12
root = ET.Element("personne")
13
14
#associer un attribut a la balise personne
15
root.set("Prenom",p.prenom)
16
17
item_nom = ET.SubElement(root,"Nom")
18
item_nom.text = p.nom
19
item_email = ET.SubElement(root,"Email")
20
item_email.text = p.email
21
item_age = ET.SubElement(root,"Age")
22
item_age.text = str(p.age)
23
item_ville = ET.SubElement(root,"Ville")
24
item_ville.text = p.ville
25
26
#sauvegarde fichier
27
tree = ET.ElementTree(root)
28
tree.write("personne_attribut.xml")
1
#import module Perso
2
import ModulePersonne as MP
3
4
#import module xml
5
import xml.etree.ElementTree as ET
6
7
#ouverture
8
tree = ET.parse("personne_attribut.xml")
9
10
#ouverture
11
tree = ET.parse("personne.xml")
12
13
#recuperer la racine
14
root = tree.getroot()
15
16
#trans. en Personne
17
p = MP.Personne()
18
p.prenom = root.get("Prenom") #attribut a la racine
19
p.nom = root.findtext("Nom")
20
p.email = root.findtext("Email")
21
p.age = int(root.findtext("Age"))
22
p.ville= root.findtext("Ville")
23
24
#affichage
25
p.affichage()
Méthode2. Sauvegarder une collection (liste) de personnes
Objectif : Sauvegarder un ensemble de personnes dans un fichier XML.
ModulePersonne.py [py]
1
#import module Perso
2
import ModulePersonne as MP
3
4
#import module xml
5
import xml.etree.ElementTree as ET
6
7
#liste vide
8
liste = []
9
10
#nb. de pers ?
11
n = int(input("Nb de pers : "))
12
13
#saisie liste
14
for i in range(0,n):
15
    a = MP.Personne()
16
    a.saisie()
17
    liste.append(a)
18
    
19
#racine
20
root = ET.Element("liste")
21
22
#pour chaque personne
23
for p in liste:
24
    #personne xml
25
    px = ET.SubElement(root,"personne")
26
    #champs
27
    item_prenom = ET.SubElement(px,"Prenom")
28
    item_prenom.text = p.prenom
29
    item_nom = ET.SubElement(px,"Nom")
30
    item_nom.text = p.nom
31
    item_email = ET.SubElement(px,"Email")
32
    item_email.text = p.email
33
    item_age = ET.SubElement(px,"Age")
34
    item_age.text = str(p.age)
35
    item_ville = ET.SubElement(px,"Ville")
36
    item_ville.text = p.ville
37
38
#sauvegarde
39
tree = ET.ElementTree(root)
40
tree.write("personnes.xml")
- Il y a deux niveaux dans la structure ;
- \(px\) ("personne") est un sous-élément de root ("liste") ;
- C'est bien sur \(px\) que l'on insère les informations sur chaque personne.
SimulationÀ faire vous-même
Utilisez la méthode précédente pour obtenir l'enregistrement complet du tableau de données au format XML.
<liste><personne><Prenom>Robert</Prenom><Nom>Lepingre</Nom><Email>bobby@exemple.com</Email><Age>41</Age><Ville>Paris</Ville></personne><personne><Prenom>Jeanne</Prenom><Nom>Ducoux</Nom><Email>jeanne@exemple.com</Email><Age>32</Age><Ville>Marseille</Ville></personne><personne><Prenom>Pierre</Prenom><Nom>Lenfant</Nom><Email>pierre@exemple.com</Email><Age>23</Age><Ville>Rennes</Ville></personne></liste>
ComplémentLecture du fichier - Charger une liste d'objets à partir d'un fichier XML
Dans le listing suivant, on explore les deux niveaux lors du chargement :
-  \(root\) <liste> se comporte comme une liste (cf. la boucle for) ;
- Chaque élément \(child\) correspond au nœud <personne>.
ModulePersonne.py [py]
1
#import module Perso
2
import ModulePersonne as MP
3
4
#import module xml
5
import xml.etree.ElementTree as ET
6
7
#ouverture
8
tree = ET.parse("personnes.xml")
9
10
#recuperer la racine
11
root = tree.getroot()
12
13
#conv. en liste de personnes
14
liste = []
15
for child in root:
16
    #creer une personne
17
    p = MP.Personne()
18
    p.prenom = child.findtext("Prenom")
19
    p.nom = child.findtext("Nom")
20
    p.email = child.findtext("Email")
21
    p.age = int(child.findtext("Age"))
22
    p.ville= child.findtext("Ville")
23
    #affichage
24
    p.affichage()
25
    #l'ajouter dans la liste
26
    liste.append(p)
27
    
28
print("Nb personnes : ",len(liste))