ajout cours données en table

données_en_table/FUSION.md

@@ -0,0 +1,53 @@
+## Fusion et jointures de tables
+
+
+
+>  Lorsque l'on a de grandes quantités de données à traiter, il arrive que celles-ci soient réparties entre plusieurs tables. Il est donc parfois utile voir necessaire de regrouper toutes ces données dans une seule table. On appelle cela "fusion de tables" ou "jointure de tables"
+
+### Le programme
+
+![bo_3](assets/bo_3.png)
+
+-----
+
+- On veut fusionner deux tables selon un attribut commun. 
+- On va donc selectionner dans chaque table la ligne ayant la même valeur pour l'attribut choisi.
+
+Reprenons une table *Notes* vu précédemment :
+
+| Prénom       | DS1  | DS2  | Projet |
+| ------------ | ---- | ---- | ------ |
+| Michelangelo | 12   | 14   | B      |
+| Leonardo     | 15   | 16   | A      |
+| Raphael      | 10   | 12   | C      |
+| Donatello    | 13   | 15   | B      |
+
+Admettons une seconde table et appellons la *Infos* :
+
+| Prénom       | Âge  | Mail                |
+| ------------ | ---- | ------------------- |
+| Michelangelo | 16   | pizza@turtle.com    |
+| Leonardo     | 15   | devinci@turtle.com  |
+| Raphael      | 14   | chocolat@turtle.com |
+| Donatello    | 17   | donut@turtle.com    |
+
+- On souhaite regrouper les données des deux tables : on peut utiliser l'attribut "Prénom" pour cela.
+- Il nous faut donc une fonction qui permettent de fusionner les tables:
+
+```python
+from copy import deepcopy
+def fuuuuusion(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      
+```
+

données_en_table/MANIPULATION.md

@@ -0,0 +1,130 @@
+## Operation sur les tables
+
+
+
+> Une fois que l'on dispose de données en table, nous pouvons alors manipuler ces données et effectuer des recherches ou des tris.
+
+### Le programme 
+
+![bo_2](assets/bo_2.png)
+
+
+
+### Interrogation de table
+
+Il arrive fréquemment que l'on souhaite accéder à différentes informations contenues dans une table de données, selon différents critères.
+
+On suppose que la table en question est une *liste de dictionnaires* - comme vu précédemment - et que cette table sera appelée ***table*** dans la suite de ce cours.
+
+Chaque ligne est donc un dictionnaire et chaque clé correspondra au nom d'une colonne.
+
+✏ *Avant de commencer* ✏
+
+> Pour comparer et vérifier différents critères, nous utiliserons les **opérateurs booléns habituels**
+>
+> Nous aurons donc <, >, <=, >=, ==, !=, in, not, and, or, is... 
+
+*Quand on interroge une table, on en construit une nouvelle contenant uniquement les lignes satisfaisant une condition donnée sous la forme d'une **fonction booléenne***.
+
+#### Selection de lignes
+
+Pour selectionner des lignes, on peut simplifier l'instruction à :
+
+```python
+[ligne for ligne in table if (condition)]
+```
+
+Cette instruction va donc générer une liste de dictionnaires verifiant la condition.
+
+
+
+#### Selection de colonnes
+
+Selectionner certaines colonnes revient à selectionner certaines clés dans les dictionnaires.
+
+L'instruction ressemblera donc à :
+
+```python
+[{clé:ligne[clé] for clé in ligne if (condition sur clé)} for ligne in table]
+```
+
+
+
+--------------
+
+### Exemples 
+
+Suivant le tableau vu précédemment
+
+| Prénom       | DS1  | DS2  | Projet |
+| ------------ | ---- | ---- | ------ |
+| Michelangelo | 12   | 14   | B      |
+| Leonardo     | 15   | 16   | A      |
+| Raphael      | 10   | 12   | C      |
+| Donatello    | 13   | 15   | B      |
+
+On peut écrire une fonction qui va selectionner les personnes selon un critère précis :
+
+```python
+def select(table, critere):
+  def test(ligne):
+    return eval(critere)
+  return [ligne for ligne in table if test(ligne)] 
+```
+
+On peut donc tester cela en selctionnant les élèves ayant obtenu plus de 15 au DS n°2 :
+
+- la fonction *eval* permet d'évaluer l'expression contenue dans la cellule *ligne* sous forme d'une chaine de caractères dans un entier.
+- il est necessaire de bien le préciser dans l'appel de la fonction *select*
+
+```python
+>> select(table, "eval(ligne['DS2']) > 15")
+```
+
+Quel est le résultat obtenu ?
+
+----
+
+Quand on selectionne une ou plusieurs colonnes - attributs - d'une table, on appelle cela une ***projection***.
+On va donc recréer une table qui ne contiendra que les attributs selectionnés :
+
+```python
+def projection (table, liste_attributs):
+  return [{clé:ligne[clé] for clé in ligne if clé in liste_attributs} for ligne in table]
+```
+
+Admettons que l'on souhaite ne retenir uniquement que les groupes de projet ainsi que les prénoms des élèves.
+
+Afin de faire la recherche, on peut écrire l'instruction suivante:
+
+```python
+projection (Notes, ['Prénom', 'Projet'])
+```
+
+-------
+
+### Manipulation de tables
+
+#### Tri de table
+
+On peut trier une liste avec la fonction ***sorted*** qui possède un argument ***key*** précisant le critère de tri et un argument ***reverse***, un booléen qui permet de choisir un tri croissant (par défaut ) ou décroissant (en précisant reverse = True).
+
+On peut donc créer une fonction *tri* qui va trier n'importer quelle table en donnant l'attribut choisir pour le tri et en précisant si l'on veut obtenir le tri dans l'ordre décroissant.
+
+```python
+def tri (table, attribut, decroit = False):
+  def critere (ligne):
+    return ligne[attribut]
+  return sorted(table, key = critere, reverse =decroit)
+```
+
+Exemple : Pour trier dans l'ordre décroissant la table Notes selon les notes du DS n°1, on peut écrire :
+
+```python
+>> tri (Notes, 'DS1', True)
+```
+
+Quel est le résultat affiché ?
+
+
+

données_en_table/PANDAS.md

@@ -0,0 +1,39 @@
+## La bibliothèque Pandas
+
+
+
+La bibliothèque pandas est l'une des plus utilisées pour la gestion de données - appelée également *Data Science*.
+
+Comme pour toutes les bibliothèques python, on doit l'importer en début de fichier :
+
+```python
+import pandas
+```
+
+Elle nous permet de lire un fichier CSV de manière beaucoup plus rapide :
+
+```python
+pandas.read_csv('nom_du_fichier.csv' delimiter = ';')
+```
+
+Mais également un fichier Excel :
+
+```python
+pandas.read_excek('nom_de_fichier.xlsx' delimiter = ';')
+```
+
+On obtient alors un objet caractéristique de cette bibliothèque qu'on appellera *dataframe* et qu'on peut représenter par un tableau de p-uplets nommés (on utilise alors des noms au lieu d'indices).
+
+De plus, Pandas permet d'effectuer les manipulations de base que l'on a vu précédemment et même plus :
+
+Exemple, une table nommée 'table' pourra être utilisée :
+
+- pour afficher les 10 premières lignes : table.head(10)
+- pour afficher les en-têtes des colonnes (aussi appelés champs) : table.columns( )
+
+Enfin, on peut également fusionner deux tables ensemble via cette instruction:
+
+```python
+pandas.merge(table_1,table_2)
+```
+

données_en_table/README.md

@@ -26,8 +26,8 @@ Les données en table sont une composante essentielle de l'informatique : de tr
 
 <p>
  En maîtrisant cet aspect, nous pourrons commencer à utiliser de petites bases de données pour nos activités, mais également travailler sur des projets plus intéressants.
------------
 
+---------------
 
 ### <span style="color: green" > Enregistrements </span>
 
@@ -84,8 +84,7 @@ On peut choisir de représenter en Python les fichiers **CSV** par des listes de
 Par exemple, avec le tableau du dessus, cela donne :
 
 ```python
-Notes =
-[{'Prénom' : 'Michelangelo', 'DS1' : '12', 'DS2' : '14', 'Projet' : 'B'},
+Notes = [{'Prénom' : 'Michelangelo', 'DS1' : '12', 'DS2' : '14', 'Projet' : 'B'},
 {'Prénom' : 'Leonardo', 'DS1' : '15', 'DS2' : '16', 'Projet' : 'A'},
 {'Prénom' : 'Raphael', 'DS1' : '10', 'DS2' : '12', 'Projet' : 'C'},
 {'Prénom' : 'Donatello', 'DS1' : '13', 'DS2' : '15', 'Projet' : 'B'}]
@@ -148,7 +147,7 @@ resultat = [['Prenom', 'DS1', 'DS2', 'Projet'], ['Michelangelo', '12', '14', 'B'
 
 ### <span style = "color : green">Export d'un fichier CSV </span>
 
-Pour exporter une table vers un fichier CSV - *comprendre, créer un fichier csv depuis une table python* - on va entrer le nom de la table sous forme de chaine de caracteres. On donnera l'ordre des colonnes sous forme de liste d'attributs.
+Pour exporter une table vers un **fichier CSV** - *comprendre, créer un fichier csv depuis une table python* - on va entrer le nom de la table sous forme de chaine de caracteres. On donnera l'ordre des colonnes sous forme de liste d'attributs.
 
 ```python
 def vers_csv(nom, ordre):
@@ -161,3 +160,4 @@ def vers_csv(nom, ordre):
   return None
 ```
 
+