Renommer données_en_table -> donnees_en_table

Suppression des accents pour éviter les problèmes d'encodage Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-28 00:03:13 +01:00
parent eb0adc6cc5
commit 66323aac75
16 changed files with 2 additions and 2 deletions
--- a/donnees_en_table/Exercices/CORRECTION.md
+++ b/donnees_en_table/Exercices/CORRECTION.md
@@ -0,0 +1,327 @@
+## Correction - Données en table
+
+---
+
+### 1. Manipulation de fichiers CSV
+
+- On peut représenter un enregistrement par un dictionnaire.
+- Une virgule (CSV : Comma Separated Values - Valeurs séparées par une virgule). Néanmoins, le format CSV autorise d'autres séparateurs.
+- La table étant une liste de dictionnaires, on obtient donc le premier élément de la liste, c'est à dire un dictionnaire, donc une ligne de la table.
+
+---
+
+### 2. Opérations sur les tables
+
+- Pour sélectionner des colonnes selon un critère donné, on va utiliser la fonction projection.
+
+```python
+def projection(table, liste_attributs):
+  return [{clé:ligne[clé] for clé in ligne if clé in liste_attributs} for ligne in table]
+```
+
+- La fonction *select* ici va sélectionner les lignes dont une des valeurs vaut 19. On obtient donc :
+
+```python
+[{'Prénom': 'Chandler', 'Math': '19', 'Anglais': '15', 'NSI': '17'},
+ {'Prénom': 'Ross', 'Math': '14', 'Anglais': '19', 'NSI': '13'}]
+```
+
+- Il y a deux (2) noms qui sont communs aux tables : on aura donc deux (2) lignes. De plus, la table U rajoute ses deux (2) colonnes (Âge, Mail) aux quatre de la table T : on aura donc 6 (six) colonnes.
+
+---
+
+### 3. Déterminer des fonctions basiques
+
+- Puisqu'il s'agit de compter le nombre de lignes, donc d'enregistrements, on peut donc utiliser la fonction *len* pour obtenir la longueur de la liste de dictionnaires.
+
+```python
+def cardinalite(table):
+    return len(table)
+```
+
+- La liste des attributs d'une table correspond aux clés du premier dictionnaire (en supposant que la table est cohérente) :
+
+```python
+def attributs(table):
+    if len(table) == 0:
+        return []
+    return list(table[0].keys())
+```
+
+---
+
+### 4. Reconnaître une fonction
+
+```python
+def mystère(t, cs):
+  t_p = []
+  for l in t :
+    nvlle_l = {}
+    for c in l:
+      if c in cs:
+        nvelle_l[c] = l[c]
+    t_p.append(nvlle_l)
+  return t_p
+```
+
+Cette fonction réalise une **projection** : elle crée une nouvelle table ne contenant que les colonnes (attributs) spécifiés dans la liste `cs`.
+
+- `t` est la table d'origine (liste de dictionnaires)
+- `cs` est la liste des colonnes à conserver
+- Pour chaque ligne `l` de la table, on crée un nouveau dictionnaire `nvlle_l` ne contenant que les clés présentes dans `cs`
+- On retourne la nouvelle table `t_p`
+
+**Remarque** : Il y a une erreur dans le code original (`nvelle_l` au lieu de `nvlle_l`). La version corrigée serait :
+
+```python
+def projection(table, colonnes):
+    table_projetee = []
+    for ligne in table:
+        nouvelle_ligne = {}
+        for colonne in ligne:
+            if colonne in colonnes:
+                nouvelle_ligne[colonne] = ligne[colonne]
+        table_projetee.append(nouvelle_ligne)
+    return table_projetee
+```
+
+---
+
+### 5. Tester la cohérence d'une table
+
+- Fonction `coherence` qui teste si chaque ligne a le même ensemble d'attributs :
+
+```python
+def coherence(table):
+    """
+    Teste si chaque ligne de la table a le même ensemble d'attributs
+    :param table: (list) une liste de dictionnaires
+    :return: (bool) True si la table est cohérente, False sinon
+    """
+    if len(table) == 0:
+        return True
+
+    attributs_reference = set(table[0].keys())
+
+    for ligne in table:
+        if set(ligne.keys()) != attributs_reference:
+            return False
+
+    return True
+```
+
+- Fonction `doublons` qui vérifie si un attribut apparaît deux fois avec la même valeur :
+
+```python
+def doublons(table, attribut):
+    """
+    Vérifie si un attribut apparaît deux fois avec la même valeur
+    :param table: (list) une liste de dictionnaires
+    :param attribut: (str) le nom de l'attribut à vérifier
+    :return: (bool) True s'il y a des doublons, False sinon
+    """
+    valeurs_vues = []
+
+    for ligne in table:
+        valeur = ligne[attribut]
+        if valeur in valeurs_vues:
+            return True
+        valeurs_vues.append(valeur)
+
+    return False
+```
+
+---
+
+### 6. Lier tableur, fichier CSV et liste de dictionnaires
+
+```python
+PlanningTwitch = [
+    {'NomStream': 'AntoineDaniel', 'Genre': 'M', 'Jeu': 'Fall_Guys', 'Numéro': '1'},
+    {'NomStream': 'MV', 'Genre': 'M', 'Jeu': 'Isaac', 'Numéro': '2'},
+    {'NomStream': 'AngleDroit', 'Genre': 'F', 'Jeu': 'Fall_Guys', 'Numéro': '3'},
+    {'NomStream': 'BagheraJones', 'Genre': 'F', 'Jeu': 'Fall_Guys', 'Numéro': '4'}
+]
+```
+
+- La première ligne de la feuille de calcul contient les en-têtes (attributs) :
+  `NomStream | Genre | Jeu | Numéro`
+
+- Pour obtenir le fichier CSV correspondant :
+```python
+vers_csv('PlanningTwitch', ['NomStream', 'Genre', 'Jeu', 'Numéro'])
+```
+
+- La deuxième ligne du fichier CSV :
+  `AntoineDaniel;M;Fall_Guys;1`
+
+- La cellule C8 de la feuille correspondante : la table n'a que 5 lignes (1 en-tête + 4 données), donc C8 est **vide**.
+
+- Pour obtenir la valeur d'une cellule (par exemple C2, le jeu d'AntoineDaniel) :
+```python
+PlanningTwitch[0]['Jeu']  # 'Fall_Guys'
+```
+
+- Pour modifier le jeu de MV :
+```python
+PlanningTwitch[1]['Jeu'] = 'Worms'
+```
+
+---
+
+### 7. Ajouter une ligne ou une colonne
+
+- Pour obtenir la liste de dictionnaires depuis le fichier CSV :
+```python
+Groupe1 = import_csv('Groupe1')
+```
+
+- Pour ajouter Rachel :
+```python
+Groupe1.append({'Prénom': 'Rachel', 'Math': '17', 'Anglais': '19', 'NSI': '18'})
+```
+
+- Fonction pour ajouter une colonne moyenne :
+
+```python
+from copy import deepcopy
+
+def ajouter_moyenne(table):
+    """
+    Ajoute une colonne 'Moyenne' à chaque ligne de la table
+    :param table: (list) une liste de dictionnaires avec des notes
+    :return: (list) une nouvelle table avec la colonne Moyenne
+    """
+    nouvelle_table = deepcopy(table)
+
+    for ligne in nouvelle_table:
+        math = int(ligne['Math'])
+        anglais = int(ligne['Anglais'])
+        nsi = int(ligne['NSI'])
+        moyenne = (math + anglais + nsi) / 3
+        ligne['Moyenne'] = '{:.1f}'.format(moyenne)
+
+    return nouvelle_table
+```
+
+- Pour ajouter une ligne contenant les moyennes par matière :
+
+```python
+from copy import deepcopy
+
+def ajouter_ligne_moyennes(table):
+    """
+    Ajoute une ligne contenant les moyennes par matière
+    :param table: (list) une liste de dictionnaires avec des notes
+    :return: (list) une nouvelle table avec la ligne des moyennes
+    """
+    nouvelle_table = deepcopy(table)
+
+    nb_eleves = len(nouvelle_table)
+    total_math = 0
+    total_anglais = 0
+    total_nsi = 0
+
+    for ligne in nouvelle_table:
+        total_math = total_math + int(ligne['Math'])
+        total_anglais = total_anglais + int(ligne['Anglais'])
+        total_nsi = total_nsi + int(ligne['NSI'])
+
+    ligne_moyennes = {
+        'Prénom': 'Moyenne',
+        'Math': '{:.1f}'.format(total_math / nb_eleves),
+        'Anglais': '{:.1f}'.format(total_anglais / nb_eleves),
+        'NSI': '{:.1f}'.format(total_nsi / nb_eleves)
+    }
+
+    nouvelle_table.append(ligne_moyennes)
+    return nouvelle_table
+```
+
+---
+
+### 8. Sélectionner, trier, joindre
+
+On définit les tables :
+
+```python
+Hero = [
+    {'NumHero': '0', 'NomHero': 'Sangoku', 'VilleHero': 'Kyoto'},
+    {'NumHero': '1', 'NomHero': 'Naruto', 'VilleHero': 'Konoha'},
+    {'NumHero': '2', 'NomHero': 'Luffy', 'VilleHero': 'Fuchsia'},
+    {'NumHero': '3', 'NomHero': 'Ryo Saeba', 'VilleHero': 'Tokyo'},
+    {'NumHero': '4', 'NomHero': 'Saitama', 'VilleHero': 'Ville Z'},
+    {'NumHero': '5', 'NomHero': 'Onizuka', 'VilleHero': 'Tokyo'}
+]
+
+Armes = [
+    {'NumHero': '0', 'NomHero': 'Sangoku', 'Arme': 'Ki'},
+    {'NumHero': '1', 'NomHero': 'Naruto', 'Arme': 'Chakra'},
+    {'NumHero': '2', 'NomHero': 'Luffy', 'Arme': 'Corps'},
+    {'NumHero': '3', 'NomHero': 'Ryo Saeba', 'Arme': 'Magnum'},
+    {'NumHero': '4', 'NomHero': 'Saitama', 'Arme': 'Poing'},
+    {'NumHero': '5', 'NomHero': 'Onizuka', 'Arme': 'Tout est une arme'}
+]
+```
+
+- **HeroTokyo** : héros dont la ville est Tokyo
+
+```python
+HeroTokyo = select(Hero, "ligne['VilleHero'] == 'Tokyo'")
+# Résultat :
+# [{'NumHero': '3', 'NomHero': 'Ryo Saeba', 'VilleHero': 'Tokyo'},
+#  {'NumHero': '5', 'NomHero': 'Onizuka', 'VilleHero': 'Tokyo'}]
+```
+
+- **HeroAlpha** : héros triés par ordre alphabétique du nom
+
+```python
+HeroAlpha = tri(Hero, 'NomHero')
+# Résultat :
+# [{'NumHero': '2', 'NomHero': 'Luffy', 'VilleHero': 'Fuchsia'},
+#  {'NumHero': '1', 'NomHero': 'Naruto', 'VilleHero': 'Konoha'},
+#  {'NumHero': '5', 'NomHero': 'Onizuka', 'VilleHero': 'Tokyo'},
+#  {'NumHero': '3', 'NomHero': 'Ryo Saeba', 'VilleHero': 'Tokyo'},
+#  {'NumHero': '4', 'NomHero': 'Saitama', 'VilleHero': 'Ville Z'},
+#  {'NumHero': '0', 'NomHero': 'Sangoku', 'VilleHero': 'Kyoto'}]
+```
+
+- **HeroComplet** : nom, ville et arme des héros (fusion puis projection)
+
+```python
+HeroFusion = fusion(Hero, Armes, 'NumHero')
+HeroComplet = projection(HeroFusion, ['NomHero', 'VilleHero', 'Arme'])
+# Résultat :
+# [{'NomHero': 'Sangoku', 'VilleHero': 'Kyoto', 'Arme': 'Ki'},
+#  {'NomHero': 'Naruto', 'VilleHero': 'Konoha', 'Arme': 'Chakra'},
+#  {'NomHero': 'Luffy', 'VilleHero': 'Fuchsia', 'Arme': 'Corps'},
+#  {'NomHero': 'Ryo Saeba', 'VilleHero': 'Tokyo', 'Arme': 'Magnum'},
+#  {'NomHero': 'Saitama', 'VilleHero': 'Ville Z', 'Arme': 'Poing'},
+#  {'NomHero': 'Onizuka', 'VilleHero': 'Tokyo', 'Arme': 'Tout est une arme'}]
+```
+
+- **HeroVille** : numéro et ville des héros
+
+```python
+HeroVille = projection(Hero, ['NumHero', 'VilleHero'])
+# Résultat :
+# [{'NumHero': '0', 'VilleHero': 'Kyoto'},
+#  {'NumHero': '1', 'VilleHero': 'Konoha'},
+#  {'NumHero': '2', 'VilleHero': 'Fuchsia'},
+#  {'NumHero': '3', 'VilleHero': 'Tokyo'},
+#  {'NumHero': '4', 'VilleHero': 'Ville Z'},
+#  {'NumHero': '5', 'VilleHero': 'Tokyo'}]
+```
+
+- **HeroImpair** : nom et ville des héros ne venant pas de Tokyo et dont le numéro est impair
+
+```python
+HeroImpair = select(Hero, "ligne['VilleHero'] != 'Tokyo' and int(ligne['NumHero']) % 2 == 1")
+HeroImpair = projection(HeroImpair, ['NomHero', 'VilleHero'])
+# Résultat :
+# [{'NomHero': 'Naruto', 'VilleHero': 'Konoha'}]
+```
+
+---
+
+Source : Florian Mathieu - Licence CC BY NC SA
--- a/donnees_en_table/Exercices/README.md
+++ b/donnees_en_table/Exercices/README.md
@@ -0,0 +1,236 @@
+## Exercices
+
+
+
+### 1. Manipulation de fichiers CSV
+
+- Par quoi peut-on représenter un enregistrement en Python ?
+
+- Dans un fichier CSV, quel élément sépare les différents attributs ?
+
+- On dispose d'une table de données *Table* représentée par une liste de dictionnaires. Qu'obtient-on en entrant :
+
+  ```python
+  Table[0]
+  ```
+
+  
+
+### 2. Opérations sur les tables
+
+On dispose de la table T représentant les notes d'élèves dans trois matières :
+
+| Prénom   | Math | Anglais | NSI  |
+| -------- | ---- | ------- | ---- |
+| Joey     | 16   | 17      | 18   |
+| Chandler | 19   | 15      | 17   |
+| Ross     | 14   | 19      | 13   |
+
+
+
+- Pour selectionner des colonnes selon un critère donné, laquelle de ces deux fonctions peut-on utiliser ?
+
+```python
+def select(table, critère):
+  def test(ligne):
+    return eval(critère)
+ return [ligne for ligne in table if test(ligne)] 
+```
+
+```python
+def projection(table, liste_attributs):
+  return [{clé:ligne[clé] for clé in ligne if clé in liste_attributs} for ligne in table]
+```
+
+- La fonction *select* vu au dessus peut-être utilisée comme ceci :
+
+  ```python
+  select(T,"'19' in ligne.values()")
+  ```
+
+  Que renvoie cet appel de fonction ?
+
+
+
+- Soit U la table suivante :
+
+| Prénom   | Âge  | Mail                   |
+| -------- | ---- | ---------------------- |
+| Joey     | 29   | howyoudoin@friends.com |
+| Chandler | 31   | joke@friends.com       |
+
+En réutilisant la fonction fusion suivante:  
+
+```python
+from copy import deepcopy
+def fusion(table_1, table_2, cle_1, cle_2=None):
+  if cle_2 is None:
+    cle_2 = cle_1
+  table_finale = []
+  for ligne_1 in table_1:
+    for ligne_2 in table_2:
+      if ligne_1[cle_1] == ligne_2[cle_2]:
+        ligne_finale = deepcopy(ligne_1)
+        for cle in ligne_2:
+          if cle != cle_2:
+            ligne_finale[cle] = ligne_2[cle]
+        table_finale.append(ligne_finale)
+  return table_finale      
+```
+
+donnez le nombre de  lignes et de colonnes renvoyées par :
+
+```python
+fusion(T,U, 'Prénom')
+```
+
+
+
+### 3. Determiner des fonctions basiques
+
+- Determiner une fonction qui calcule la **cardinalité** d'une table, c'est à dire son nombre de lignes.
+- Determiner une fonction qui renvoie la liste des attributs d'une table.
+
+
+
+### 4. Reconnaître une fonction
+
+Quel est le principe de la fonction suivante :
+
+```python
+def mystère(t, cs):
+  t_p = []
+  for l in t :
+    nvlle_l = {}
+    for c in l:
+      if c in cs:
+        nvelle_l[c] = l[c]
+    t_p.append(nvelle_l)
+  return t_p  
+```
+
+
+
+### 5. Tester la cohérence d'une table
+
+- Determiner une fonction *coherence*(table) qui teste si chaque ligne a le même ensemble d'attributs.
+- Determiner une fonction *doublons*(table, attribut) qui vérifie si un attribut de référerence apparaît deux fois avec la même valeur dans une table.
+
+### 6. Lier tableur, fichier CSV et liste de dictionnaires
+
+On dispose d'une liste de dictionnaires suivante :
+
+```python
+PlanningTwitch =[{'NomStream' : 'AntoineDaniel', 'Genre' : 'M', 'Jeu' : 'Fall_Guys','Numéro' : '1'},{'NomStream' : 'MV', 'Genre' : 'M', 'Jeu' : 'Isaac','Numéro' : '2'}, {'NomStream' : 'AngleDroit', 'Genre' : 'F', 'Jeu' : 'Fall_Guys','Numéro' : '3'}, {'NomStream' : 'BagheraJones', 'Genre' : 'F', 'Jeu' : 'Fall_Guys','Numéro' : '4'}]
+```
+
+- On travaille avec le tableur LibreOffice Calc de la suite LibreOffice qui produit des fichiers au format ont (alors qu'Excel de la suite Microsoft Office produit des fichiers au format xlsx). Quelle est la première ligne de la feuille de calcul obtenue dans un tableau à partir de cette liste ?
+- Quelle commande lancer pour obtenir le fichier CSV correspondant ?
+- Quelle est la deuxième ligne du fichier CSV correspondant ?
+- Quelle valeur trouve t-on à la cellule C8 de la feuille correspondante ?
+- Par quelle commande obtient-on cette valeur ?
+- Une erreur de saisie a lieu : MV joue à worms en fait. Quelle commande permet de modifier le fichier correpondant du tableur ?
+
+### 7. Ajouter une ligne ou une colonne
+
+On dispose de la table suivante au format CSV, dans le repertoire courant sous le nom ***'./Groupe1.csv'***
+
+| Prénom   | Math | Anglais | NSI  |
+| -------- | ---- | ------- | ---- |
+| Joey     | 16   | 17      | 18   |
+| Chandler | 19   | 15      | 17   |
+| Ross     | 14   | 19      | 13   |
+
+- Comment obtenir la liste de dictionnaires correspondante en utilisant une fonction déjà vue ?
+- Ajouter les notes de l'élève Rachel qui a eu 17 en Maths, 18 en NSI et 19 en anglais.
+- On voudrait ajouter une colonne contenant les moyennes de chaque élève afin d'obtenir le tableau suivant :
+
+| Prénom   | Math | Anglais | NSI  | Moyenne |
+| -------- | ---- | ------- | ---- | ------- |
+| Joey     | 16   | 17      | 18   | 17      |
+| Chandler | 19   | 15      | 17   | 17      |
+| Ross     | 14   | 19      | 13   | 15,3    |
+| Rachel   | 17   | 19      | 18   | 18      |
+
+On doit envoyer une nouvelle table qui ne modifie pas la table d'origine. Pour effectuer une copie d'une liste d'objets complexes (ici une liste de dictionnaires), on peut utiliser la fonction *deepcopy* de la bibliothèque copy. La fonction à créer pourra donc avoir la structure suivante qu'il faudra compléter :
+
+```python
+from copy import deepcopy
+def ajouter_moyenne(table):
+  nvelle_table = deepcopy(table)
+  pass
+
+	return nvelle_table
+```
+
+Pour obtenir l'affichage d'un nombre flottant arrondi à 2 chiffres derrière la virgule, on peut utiliser la méthode *format* 
+
+Par exemple :
+
+```python
+>> '{:.2f}'.format(314/100) #indique un flottant avec 2 chiffres après la virgule
+'3,14'
+```
+
+Ajouter une ligne qui contient les moyennes par matières.
+
+Cela devrait donner un tableau du genre :
+
+| Prénom   | Math | Anglais | NSI  |
+| -------- | ---- | ------- | ---- |
+| Joey     | 16   | 17      | 18   |
+| Chandler | 19   | 15      | 17   |
+| Ross     | 14   | 19      | 13   |
+| Rachel   | 17   | 19      | 18   |
+| Moyenne  | 16,5 | 17,5    | 16,5 |
+
+
+
+### 8. Selectionner, trier, joindre
+
+On dispose de la table Hero suivante
+
+| NumHero | NomHero   | VilleHero |
+| ------- | --------- | --------- |
+| 0       | Sangoku   | Kyoto     |
+| 1       | Naruto    | Konoha    |
+| 2       | Luffy     | Fuchsia   |
+| 3       | Ryo Saeba | Tokyo     |
+| 4       | Saitama   | Ville Z   |
+| 5       | Onizuka   | Tokyo     |
+
+Ainsi que celle- ci :
+
+| NumHero | NomHero   | Arme              |
+| ------- | --------- | ----------------- |
+| 0       | Sangoku   | Ki                |
+| 1       | Naruto    | Chakra            |
+| 2       | Luffy     | Corps             |
+| 3       | Ryo Saeba | Magnum            |
+| 4       | Saitama   | Point             |
+| 5       | Onizuka   | Tout est une arme |
+
+
+
+- Renvoyer HeroTokyo, une table extraite de Hero ne contenant que les lignes dont l'attribut VilleHero vaut "Tokyo"
+
+- Renvoyer HeroAlpha, une table extraite de Hero triée selon l'ordre alphabétique du nom des héros.
+
+- Renvoyer HeroComplet, une table contenant le nom, la ville ainsi que l'arme favorite des héros.
+
+- Renvoyer HeroVille, la table contenant le numéro ainsi que la ville des héros.
+
+- Renvoyer HeroImpair, la table contenant le nom et la ville des hero ne venant pas de Tokyo, et dont le numéro est impair.
+
+  
+
+  
+
+------------
+
+Auteur : Florian Mathieu
+
+Licence CC BY NC
+
+<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.
+