Il est fréquent lorsque l'on travaille avec des données, et particulièrement avec des données tabulées, de se retrouver avec plusieurs jeux de données.
Une question que l'on peut se poser naturellement est comment combiner ces jeux de données en une seule table?
En effet, une fois ces données combinées en une seule table, nous pouvons réutiliser les opérations vues dans les séquences précédentes :\n- filtrage,\n- sélection de colonnes,\n- agrégation,\n- tri.
Nous allons voir qu'il existe plusieurs manière pour fusionner des données en tables.
Selon l'opération que l'on souhaite effectuer, des précautions particulières sont à prendre pour ne pas introduire d'incohérence dans les données."},{"input":""}],[{"text":"
Une première opération naturelle est de vouloir mettre dans une même table les données de deux tables existantes.
Par exemple, sur la plateforme des données publiques françaises, on peut trouver des fichiers CSV recensant les listes des prénoms d'enfants nés dans certaines villes,
https://www.data.gouv.fr/fr/datasets/prenoms-a-rennes/
pour chaque année entre 2007 et 2015.
Chaque année est stockée dans un fichier CSV propre :
Il est naturel de vouloir réunir tous ces jeux de données en un seul, pour former une seule grande table que l'on peut ensuite filtrer ou trier.
Cette opération a du sens car tous ces fichiers, et donc toutes les tables correspondantes, possèdent la même structure :\n- elles ont les memes attributs (en nom et en nombre)\n- les attributs de même nom sont du même type.
Pour notre exemple, ces attributs donnent l'année de naissance, le sexe, le prenom et le nombre d'enfants nés avec ce prénom.
| annee | prenom | sexe | nombre |
| 2018 | Arthur | Masculin | 59 |
| 2018 | Gabriel | Masculin | 55 |
| 2018 | Adèle | Féminin | 48 |
| 2018 | Louis | Masculin | 48 |
| 2018 | Alice | Féminin | 47 |
Attention, n'oubliez pas de mettre les fichiers csv dans le même répertoire que votre programme python.
import csv\nf2017 = open(\"prenoms2017.csv\")\nf2018 = open(\"prenoms2018.csv\")\n\nt2017 = list(csv.DictReader(f2017))\nt2018 = list(csv.DictReader(f2018))\n\nprint(\"t2017=\",t2017)\nprint(\"t2018=\",t2017)\nEcrire et tester le code.
Les deux tables ayant les mêmes attributs, il est possible de les réunir en une seule table contenant toutes les valeurs.
Nous pouvons faire cela en utilisant l'opérateur + sur les tableaux, comme nous l'avons déja vu.
t1718 = t2017 + t2018\nprint(t1718)
Ajouter et tester le code ci-dessous.
Le tableau t21718 que l'on obtient est un nouveau tableau contenant les éléments de t2017 suivis des éléments de t2018.\nDu point de vue de Python, cette opération est toujours autorisée entre deux tableaux quelconques.
","title":"Réunion de tables"},{"input":""}],[{"text":"
Mais a-t-elle toujours un sens dans le cadre de tables de données?
Une manière d'approcher le problème est de considérer les opérations que nous connaissons sur les tables.
Prenons l'exemple de la sélection de lignes d'une table. Si l'on souhaite connaitre les prénoms de toutes les filles nées en 2017, on peut écrire le code suivant :
fille2017 = [ f for f in t2017 if f[\"sexe\"] == \"Féminin\" ]print(\"fille2017=\",fille2017)
Ajouter et tester le code ci-dessous.
La même opération aura aussi du sens pour la table t2018, de même que sur la table t1718.
fille2018 = [ f for f in t2018 if f[\"sexe\"] == \"Féminin\" ]
fille1718 = [ f for f in t1718 if f[\"sexe\"] == \"Féminin\" ]
"},{"input":"","place":"Ecrire le résultat ici."}],[{"text":"print(\"fille2018=\",fille2018)print(\"fille1718=\",fille1718)Ajouter et tester le code ci-dessous.
Si nous réunissons les tables t2017 et la table élèves introduite à la séquence précédente, alors nous aurons un problème pour effectuer cette opération.
f_eleves = open(\"eleves.csv\")\nt_eleves = list(csv.DictReader(f_eleves.csv))\n\nmauvaisetable = t2017 + t_eleves\n\ntest = [ f for f in mauvaisetable if f[\"sexe\"] == \"Féminin\" ]\nAjouter et tester le code ci-dessous.
Quel est le problème dans la fusion de ces 2 tables?
Comme on le voit, réunir les valeurs de deux tables est une opération légitime, à condition que les tables aient les mêmes attributs et des attributs de mêmes type.
Nous pouvons aller plus loin et considérer des tables ayant des attributs différents, mais au moins un attribut commun.
Pour cela, nous considérons de nouveaux nos élèves.
| Prénom | Année | Note 1 | Note 2 | Appréciation |
| Stéphane | 2000 | 12.5 | 9.4 | AB |
| Paul | 2003 | 14 | 17 | B |
| Régis | 2002 | 9 | 15 | TB |
| Bernard | 2001 | 5.5 | 12 | B |
| Franck | 1999 | 16 | 14.5 | AB |
| Léon | 2004 | 14 | 16 | TB |
La table correspondant à ce tableau est la suivante :
Il se trouve que parmi ces élèves, Léon, Paul et Bernard ont rendu un devoir maison Le professeur renseigne les notes dans une autre table.
| Prénom | Note 3 |
| Léon | 12 |
| Paul | 13 |
| Bernard | 9 |
La table correspondant à ce tableau est la suivante :
On souhaite maintenant éditer un relevé de note, c'est-à-dire une table donnant pour chaque élève qui a eu une note 3 son prénom, son année, la note 1, 2 et 3.
La première chose à faire est de créer une fonction qui, étant donnée une ligne de la table élèves et une ligne de la table note3, crée un nouveau dictionnaire représentant la ligne du résultat.\n
def fusion(e, n) :\n return { \"prenom\" : e[\"prenom\"] , \"annee\":e[\"annee\"] , \"note1\" : e[\"note1\"] , \"note2\" : e[\"note2\"] , \"note3\":n[\"note\"]}\n\nprint(fusion(t_eleves[1],t_note3[0]))
Ecrire et tester le code ci-dessus.Ici, on choisit d'ignorer la clé prénom du dictionnaire n car nous l'avons déja dans le dictionnaires e.","title":"Opération de jointure"},{"input":""}],[{"text":"L'algorithme de \"fusion de table\" que l'on souhaite appliquer est une double boucle for.
t = [] \nfor e in t_eleves:\n for n in t_note3:\n if e[\"prenom\"] == n[\"prenom\"] :\n t.append(fusion(e , n))\n\nprint(t)
Ajouter et tester le code.
A l'issue de cette boucle, le tableau t contient les trois lignes avec les notes de Paul, Bernard et Léon.
Nous avons obtenu le résultat escompté mais nous pouvons le faire d'une autre manière, en utilisant une double compréhension de tableaux.
Cette opération est une extension de la compréhension simple qui itère sur toutes les cases d'un tableau.
t2 = [ fusion(e, n) for e in t_eleves for n in t_note3 if e[\"prenom\"] == n[\"prenom\"]]\nprint(t2)\nAjouter et tester le code ci-dessous.
La double compréhension for e in t_eleves for n in t_note3 produit toutes les paires (e, n) de lignes de la table t_eleves et de la table t_note3 et ne conserve que celles pour lesquelles les valeurs de l'attribut prenom sont les mêmes dans les deux lignes.
Cette opération de mise en correspondance des lignes de deux tables ayant un attribut commun est appelée jointure de deux tables."},{"input":"","place":"Ecrire le résultat ici."}],[{"text":"
La double compréhension est un outil très puissant dans la gestion des données tabulées.Par exemple, si on considère de nouveau nos deux tables des prénoms de 2017 et 2018, on peut calculer la nouvelle table suivante:
f2017 = open(\"prenoms2017.csv\")\nf2018 = open(\"prenoms2018.csv\")\n\nt2017 = list(csv.DictReader(f2017))\nt2018 = list(csv.DictReader(f2018))\n\nevolution = [{ \"PRN\" : t1[\"prenom\"] , \"NBR2017\" : int(t1[\"nombre\"]) , \\\n \"NBR2018\" : int(t2[\"nombre\"]) } for t1 in t2017 for t2 in t2018 \\\n if t1[\"prenom\"] == t2[\"prenom\"] ]\n \nprint(evolution)\n
Ecrire et tester le code.
On obtient la table evolution contenant, pour chaque prenom, le nombre de naissances correspondantes en 2017 et en 2018, ce qui nous permettra de calculer la variation sur une annee pour un prénom donnée.
Lors de la production du relevé de notes ou de la variation des prénoms dans les partie précédente, nous avons fait une hypothèse implicite, à savoir que les prénoms étalent uniques.
Celle-ci est vraie pour les fichiers prenoms2017.csv et prenoms2018.csv mais pas pour la table élève suivante :
t_eleves = [{'prenom': 'Stéphane', 'annee': 2000, 'note1': 12.5, 'note2': 9.4, 'appreciation': 'AB'}, {'prenom': 'Paul', 'annee': 2003, 'note1': 14.0, 'note2': 17.0, 'appreciation': 'B'}, {'prenom': 'Régis', 'annee': 2002, 'note1': 9.0, 'note2': 15.0, 'appreciation': 'TB'}, {'prenom': 'Bernard', 'annee': 2001, 'note1': 5.5, 'note2': 12.0, 'appreciation': 'B'}, {'prenom': 'Franck', 'annee': 1999, 'note1': 16.0, 'note2': 14.5, 'appreciation': 'AB'}, {'prenom': 'Léon', 'annee': 2004, 'note1': 14.0, 'note2': 16.0, 'appreciation': 'TB'}, {'prenom': 'Paul', 'annee': 2005, 'note1': 9.0, 'note2': 11.0, 'appreciation': 'AB'}]\n
Supposons que l'élève Paul de l'année 2006 à une nouvelle note. Le professeur met sa note dans une table.\nt_note4 = t_note4 = [{'prenom': 'Paul', 'note': 13.0}]
Si nous calculons la jointure entre la table t_note4 ci-dessus et la table t_eleves, nous obtenons la table suivante:
def fusion(e, n) :\n return { \"prenom\" : e[\"prenom\"] , \"annee\":e[\"annee\"] , \"note1\" : e[\"note1\"] , \"note2\" : e[\"note2\"] , \"note3\":n[\"note\"]}\n\nt3 = [ fusion(e, n) for e in t_eleves for n in t_note4 if e[\"prenom\"] == n[\"prenom\"]]\nprint(t3)\nAjouter et tester le vode..
Il y a un problème. En effet, le prénom Paul n'étant pas unique dans la table élèves, le test interne if e[pronom\"] == n[\"prenom\"] est vrai deux fois.
","title":"Utilisation d'un identifiant unique"},{"input":"","place":"Ecrire le résulrar ici."}],[{"text":"
La situation précédente n'est pas satisfaisante. De manière générale, il est possible que des données \"réalistes\" ne suffisent pas à identifier des éléments de manière unique.
Par exemple, beaucoup de personnes portent le même nom et le même prénom. A l'échelle d'une ville, il est même courant que plusieurs personnes portent le même nom et aient la même date de naissance.
Pour prendre un autre exemple, les livres publiés sont identifiés par leur ISBN, un numéro unique attribué en France par l'AFNIL (Agence Francophone pour la Numérotation Internationale du Livre). On pourrait imaginer que l'ISBN est unique. Cependant, une bibliothèque qui possèderait plusieurs exemplaires d'un même ouvrage ne peut pas se fier uniquement à l'ISBN pour déterminer si un exemplaire particulier à été emprunté (elle peut en revanche lui associer un numéro d'inventaire unique). Comme on le voit, il est important de pouvoir associer un identifiant unique à chaque ligne d'une table car les données elles-mêmes ne permettent pas forcément de distinguer deux entrées de la table.
Une manière de faire est d'associer, au moment du chargement, un entier unique pour chaque entrée de la table.\n
Le code est le suivant pour ajouter un entier unique à chaque élève.
compteur = 0\nfor e in t_eleves:\n e[\"id\"] = compteur\n compteur = compteur + 1\n\nprint(t_eleves)\n\nAjouter et tester le code ci-dessous.Ce code relativement compact modifie en place tous les enregistrements de la table chargee, en leur ajoutant un attribut id dont la valeur est un entier incrémenté a chaque ligne. Cet incrément permet d'assurer l'unicité de l'identifiant. On obtiendra donc la table suivante :
| id | Prénom | Année | Note 1 | Note 2 | Appréciation |
| 0 | Stéphane | 2000 | 12.5 | 9.4 | AB |
| 1 | Paul | 2003 | 14 | 17 | B |
| 2 | Régis | 2002 | 9 | 15 | TB |
| 3 | Bernard | 2001 | 5.5 | 12 | B |
| 4 | Franck | 1999 | 16 | 14.5 | AB |
| 5 | Léon | 2004 | 14 | 16 | TB |
| 5 | Paul | 2005 | 9 | 11 | AB |
La jointure peut alors se faire sur l'attribut id et en modifiant lq tqble t_note4 en t_note5. De cette manière le prénom est remplacé par l'id unique.
t_note5 = [{'id': 6 , 'note': 13.0}]\n\ndef fusionid(e, n) :\n return { \"id\" : e[\"id\"] , \"prenom\" : e[\"prenom\"] , \"annee\":e[\"annee\"] , \"note1\" : e[\"note1\"] , \"note2\" : e[\"note2\"] , \"note3\":n[\"note\"]}\n\nt4 = [ fusionid(e, n) for e in t_eleves for n in t_note5 if e[\"id\"] == n[\"id\"]]\n
print(t4)\n
Ajouter et tester le code.
Donc en procédant de cette manière, nous avons uniquement modifié la note de Paul 2005.
Attention la fonction fusion a été modifiee en fusionid pour reporter l'attribut id dans le nouveau dictionnaire.\n
| Membre | Livre | ||||
| idm | Prénom | idl | Titre | N° ISBN | |
| 0 | Stéphane | 12 | Le rouge et le noir | 9780736618137 | |
| 1 | Paul | 16 | Madame de Bovary | 9782743431839 | |
| 2 | Régis | 25 | Notre-Dame de Paris | 9781720460282 | |
| 3 | Bernard | 26 | Notre-Dame de Paris | 9781720460282 | |
| 34 | Les Misérables | 9781522998518 | |||
| 57 | Un aventurier de la liberté | 9782234086104 | |||
| 67 | Un monde sans fin | 9780451980267 |
| Prêt | ||
| idp | idm | idl |
| 0 | 2 | 16 |
| 1 | 0 | 26 |
| 2 | 1 | 67 |
| 3 | 3 | 57 |
| 4 | 2 | 12 |
| 5 | 2 | 25 |
On considère les tables ci-dessus Membre, Prêt et Livre.
Déterminer à la main :\n- la jointure des tables Membre et Prêt;\n- la jointure des tables Prêt et Livre;\n- la jointure des tables Menbre et Livre;\n
","title":"Exercice 1"},{"input":""}],[{"text":"
Pour chaque table de l'exercice 1 écrire le contenu du fichier CSV. correspondant:
membre.csv\nlivre.csv\npret.csv","title":"Exercice 2"},{"input":""}],[{"text":"
Ecrire un programme Python qui charge les trois fichiers membre.csv, pret.csv et livre.csv et qui mets les données dans 3 table :\nt_membre\nt_livre\nt_pret","title":"Exercice 3"},{"input":"","place":"Ecrire le résultat ici."}],[{"text":"
Ecrire un programme Python qui réalise la jointure entre la table membre et prêt.
Faire de même pour la table prêt et livre.","title":"Exercice 4"},{"input":"","place":"Ecrire le résultat ici."}],[{"text":"Ecrire le programme Python qui réalise la jointure entre la table membre et la table livre.
Ensuite celui-ci enregistre cette jointure dans le fichier resultat.csv .
","title":"Exercice 5"},{"input":"","place":"Ecrire le résultat ici."}]]