---
# System prepended metadata

title: 'TP 1 sur ![K](https://www.kaggle.com/static/images/favicon.ico)aggle'

---

# TP 1 sur ![K](https://www.kaggle.com/static/images/favicon.ico)aggle
L'équipe :
- Ayoub El Andaloussi
- Ahmed Rahmouni
- Mamadou Ciré Diallo
- Tom Kauffeld

---  

## [Pandas](https://www.kaggle.com/learn/pandas)
### [Cours 1 : Creating, Reading and Writing](https://www.kaggle.com/residentmario/creating-reading-and-writing)
Nous avons appris a charger des donnees avec Panda dans un dataframe puis de le sauvegarder, par example :
```python
import pandas as pd
fruits = pd.DataFrame({'Apples': [30], 'Bananas': [21]})
fruits.to_csv('fruits.csv')
```

Type de données: 
Il y a deux types d'objet en Pandas: 
Les *DataFrames* et les *Series*
#### DataFrame
c'est un type de donnée de type table. Chaque entrée correspond à une ligne et une colonne.   
Declaration: 
`pd.DataFrame({'Yes': [50, 21], 'No': [131,2]})`
> A noter Les types de données ne se limitent pas qu'aux nombres, les *DataFrames* supportent d'autres types de données tel que les chaines de caractères
`pd.DataFrame({'A':["First string", "Second string"]})`  
La lecture d'un fichier de données *csv* on utilise la fonction ***read_csv()*** en lui passant en paramètre le chemin d'accès au fichier.  
`pd.read_csv("../here/the/path")`
> Pour spécifier l'index par défaut du fichier on utilise le paramètre: ***index_col***
>
>`pd.read_csv("../here/the/path", index_col=the_column_index_number")`
#### Series
c'est une séquence de valeurs de données.  

**Déclaration**: 
`pd.Series([1,2,3,4,5], index=['a', 'b'], name="SeriesName")`

### [Cours 2 : Indexing, Selecting & Assigning](https://www.kaggle.com/residentmario/indexing-selecting-assigning)
#### Indexing:
Pour pouvoir selectionner les donnees , *Pandas* dispose de deux methodes pour l'indexing:
* Index-based Selection : selectionne les données en fonction de leur position numérique. Ceci est effectué avec ***iloc***  
* Label-based Selection : dans ce type de selection c'est la valeur de l'indice des données qui est importante et non sa position.   

> A noter que les opérateurs *iloc* et *loc* sont tous les deux des opérateurs dont la selection est en premier sur la ligne puis la colonne en second. Ce qui est l'opposé de la selection en [Python](https://www.kaggle.com/learn/python,"Cours de python sur kaggle.com")
#### Selecting:
Il existe un nombre de methodes pour recuperer les donnees d'un DataFrame .
  * Acces par attribut :
  >Example : recuperer la colonne description du DataFrame reviews
  ```python
  desc = reviews.description
  ``` 
  * Acces par Index : 
  >Example : recuperer la colonne description du DataFrame reviews
  ```python
  desc = desc = reviews['description']
  ``` 
#### Assigning:
- Attribuer une constante :  
    ***dataFrame[Attribut] = Constante***
- Attribuer des valeurs iterable:
    ***dataFrame[Attribut] = Methode()***

### [Cours 3 : Summary Function and Maps](https://www.kaggle.com/residentmario/summary-functions-and-maps)
Parfois les données ne sont pas dans le format désirée, nous devons donc les reformater dans le format voulu. Pour nous aider, nous avons plusieurs fonctions à notre disposition :

| Fonction     | Description                                                              |
|--------------|--------------------------------------------------------------------------|
| describe     | génère une comptrendu des attributes d'une colonne                       |
| mean         | retourne la moyenne d'une série a travers    ![mean](https://render.githubusercontent.com/render/math?math=mean={\frac{\sum_{i=0}^nk[i]}{n}})                                         |
| median       | retourne la mediane d'une serie                                          |
| min          | retourne le minimum d'une série                                          |
| max          | retourne le maximum d'une série                                          |
| unique       | retourne les valeurs uniques d'une série                                 |
| value_counts | retourne le nombre de fois une valeur apparait                           |
| map          | permet de changer le format de chaque ligne                              |
| apply        | permet d'appliquer une fonction a chaque ligne                           |
| isin         | selectionne les données dont la valeur *est dans* une liste de valeurs.  |
| isnull       | permet de mettre en évidence les valeurs qui sont vides
| notnull      | permet de mettre en évidence les valeurs qui ne sont pas vides


### [Cours 4 : Grouping and Sorting](https://www.kaggle.com/residentmario/grouping-and-sorting)  

Dans cette partie de cours nous avons appris quelques méthodes de regroupement de données et de tri qu’en nous détaillons une partie au dessous:

***groupeby()*** : attribuer  une valeur à un ensemble de données

***sort_values()*** : permet de mettre en ordre les données (un tri croissant par default)

***sort_index()*** : permet de trier selon la valeur d’indice




### [Cours 5 : Data Types and Missing Values](https://www.kaggle.com/residentmario/data-types-and-missing-values)


Dans cette partie du cours nous avons appris la façon d’étudier les types de données dans un DataFrame, et les fonctions qui permet de gérer un ensemble de données et lui en extraire ses types, également la mise à jour des données qui devient obsolètes ainsi que la manière de gérer les cas où on aura un manque de ces dernières.

Fonction :

***.dytpe()*** : pour extraire le type de données utilisé

***.astype(‘nouveau type de données’ )*** : pour faire le conversion du type 

***pd.isnull ()*** : pour sélectionner les données manquantes dans notre base de données

***fillna (‘ // nouvelle donnée ’)*** : pour remplacer les données NaN par une nouvelle donnée

***.replace(‘ancienne donnée’, ‘donnée récente’)*** : pour faire la mise à jour d’une donnée  
  
  

### [Cours 6 : Renaming and Combining](https://www.kaggle.com/residentmario/renaming-and-combining)
 
Dans cette partie, on apprend des méthodes qui permetent de renommer des colonnes et des indices d'un DataFrame et/ou séries, et la façon dont on peut combiner plusieurs (DataFrame et/ou séries).

Les fonctions :

***rename(colonnes = {'ancien nom': 'nouveau nom'})***

***set_index()***   : on l’utilise plus précisément pour renommer les colonnes

***concat()*** : Étant donné une liste d'éléments, cette fonction regroupera ces éléments le long d'un axe.

    
---
---
## [Data Visualization](https://www.kaggle.com/learn/data-visualization)
Dans la section Data Visualization nous avons appris à visualiser nos données dans differentes graphiques en utilisant [seaborn](https://seaborn.pydata.org) :
- Des graphiques aves des lignes (line charts) ou bars (bar charts)
- Des graphiques avec des points (scatter plots)
- Des graphiques de densité et distributions

Ces graphiques nous aident à mieux repérer les correlations entre différentes données et/ou de mieux voir le rapport entre deux ou plus variables.

À la fin de cette section, nous avons aussi utilisés des données réels et non pas des données d'exercice.


#### Choix des types de tracé et des styles personnalisés: personnalisez vos graphiques et donnez-leur un aspect élégant :

* Trends - Une tendance est définie comme un modèle de changement.
* sns.lineplot - Les graphiques en courbes sont les meilleurs pour afficher les tendances sur une période donnée, et plusieurs lignes peuvent être utilisées pour afficher les tendances dans plusieurs groupes.
* Relationship - Il existe de nombreux types de graphiques différents que vous pouvez utiliser pour comprendre les relations entre les variables de vos données.
* sns.barplot - Les graphiques à barres sont utiles pour comparer les quantités correspondant à différents groupes.
* sns.heatmap - Les cartes thermiques peuvent être utilisées pour rechercher des motifs à code couleur dans les tableaux de nombres.
* sns.scatterplot - Les nuages de points montrent la relation entre deux variables continues; s'il est codé par couleur, nous pouvons également montrer la relation avec une troisième variable catégorielle.
* sns.regplot - L'inclusion d'une ligne de régression dans le nuage de points permet de voir plus facilement toute relation linéaire entre deux variables.
* sns.lmplot - Cette commande est utile pour dessiner plusieurs lignes de régression, si le nuage de points contient plusieurs groupes codés par couleur.
* sns.swarmplot - Les nuages de points catégoriels montrent la relation entre une variable continue et une variable catégorielle.
* Distribution - Nous visualisons les distributions pour montrer les valeurs possibles que nous pouvons nous attendre à voir dans une variable, ainsi que leur probabilité.
* sns.distplot - Les histogrammes montrent la distribution d'une seule variable numérique.
* sns.kdeplot - KDE plots (or 2D KDE plots) montrent une distribution estimée et lisse d'une seule variable numérique (ou de deux variables numériques).
* sns.jointplot - Cette commande est utile pour afficher simultanément un tracé KDE 2D avec les tracés KDE correspondants pour chaque variable individuelle.  


Pour changer le style de la figure en un thème différent, nous utilisons:
sns.set_style(‘’style_name’’).  

Seaborn a 5 thèmes différents: "" darkgrid "", "" whitegrid "", "" dark "", "" white "", "" ticks ""



---
---
## [Data Cleaning](https://www.kaggle.com/learn/data-cleaning)
Dans cette section nos avons vu comment corriger des incohérences entres les données :
### [Cours 1 : Handling Missing Values](https://www.kaggle.com/alexisbcook/handling-missing-values)
Dans ce cours nous avons vu comment traiter les cas où il y a des données manquantes.  
En utilisant `donnees.isnull().sum()` nous pouvont voir dans quelles colonnes les données sont manquantes et combiens de lignes sont affectés.  
Pour avoir une information plus précis on peut utilisér la formule 
```python
precent_missing = donnees.isnull().sum().sum() / np.product(donnees.shape) * 100
```
Puis nous pouvont laisser tomber les lignes avec des données manquantes avec `donnees.dropna()`, ou les colonnes avec `donnees.dropna(axis=1)`.  
Sinon nous pouvont aussi les remplire avec des valeurs fixes `donnees.fillna(0)` ou avec des valeurs qui suivent `donnees.fillna(method='bfill', axis=0)` ou les deux pour remplire tous les cellules.

### [Cours 2 : Scaling and Normalization](https://www.kaggle.com/alexisbcook/scaling-and-normalization)
Dans ce cours nous avons vu comment normaliser les données avec `minmax_scaling(donnees, columns=[0])` ou `stats.boxcox(donnees)`.

##### Scaling vs Normalization : the difference is :
* Scaling : we change the range of the data
* Normalization : we change the shape of the distribution of the data , 



### [Cours 3 : Parsing Dates](https://www.kaggle.com/alexisbcook/parsing-dates)
Dans ce cours nous avons vu comment lire des dates en utilisant la formule 
```python
donnees['date_parsed'] = pd.to_datetime(donnees['date'], format='%d/%m/%y')
```  

* Pour obtenir la longueur de la saisie de la date: : 
```python
    date_lengths = data.date_column.str.len()
```
        puis nous la comptons avec value_counts() .

* Pour obtenir les indices de ces colonnes, nous utilisons:
```python
    indices = np.where([date_lengths == 24])[1] data.loc[indices]
```




### [Cours 4 : Character Encodings](https://www.kaggle.com/alexisbcook/character-encodings)
Dans ce cours nous avons vu comment controller et forcer un encodage des données.

Pour controller quelle encodage est utilisée on utilise le code suivant :
```python
with open('fruits.csv', 'rb') as rawdata:
    result = chardet.detect(rawdata.read(10000))
print(result)
```
ce qui retourne (par exemple) :
```json
{
    'encoding': 'Windows-1252', 
    'confidence': 0.73, 
    'language': ''
}
```
Pour forcer l'encodage pendant que l'on lit les donnees, on utilise alors :
```python
fruits = pd.read_csv('fruits.csv', encoding='Windows-1252')
```
Pour changer d'encodage d'une chaine de caractères on utilise
```python
nouvelle_string = ancienne_string.decode('Windows-1252').encode('utf-8')
```
Quand on sauvgarde avec `Pandas`, l'encodage par default est l'`utf-8`.

### [Cours 5 : Inconsistent Data Entry](https://www.kaggle.com/alexisbcook/inconsistent-data-entry)
Dans ce cours nous avons vu comment repérer et corriger des fautes de frappes dans les données.  

Nous pouvons corriger 80% des incohérences dans les données en convertissant l'entrée de colonne en minuscules puis en supprimant l'espace blanc 


Pour tout mettre en miniscule, puis enlever les espaces on utilise
```python
donnees['nom'] = donnees['nom'].str.lower() # pour mettre en miniscule
donnees['nom'] = donnees['nom'].str.strip() # pour enlever les espaces
```  
  
  Utilisez fuzzy matching pour corriger les entrées de données incohérentes: nous utilisons le package fuzzywuzzy pour aider à identifier les chaînes les plus proches les unes des autres.



