---
# System prepended metadata

title: Pandas

---

# Pandas
Dans ce cours on s'est familiarisé avec Pandas qui est une librairie de Python destinée à l'analyse des données.
On commence par importer la librairie pandas:
```python=
import pandas as pd
```
## Creation, reading and writing
### Data Creation
On distingue deux objets dans Pandas: les dataframes et les Series.

**Dataframe**

Le Dataframe est une table qui prend en paramètre une liste de variables ayant une certaine valeur.Chaque variable correspond à une ligne et à une colonne.
Exemple:
```python=
fruits = pd.DataFrame({'Apples': [30], 'Bananas': [21]})
```
Cela nous génère le tableau suivant:

|  | Apples | Bananas |
| -------- | -------- | -------- |
|      0   | 30     | 21    |
Donc c'est avec l'instruction `pd.Dataframe()` qu'on génère les objets Dataframe.

P.S: Les variables du Dataframe peuvent être des entiers (int) ou des chaines de caractères (string)
****
**Séries**
Series est une liste qui prend en paramètre des objets et leurs indices `index`  et et le nom de la serie `name`.
Exemple:
```python=
ingredients = pd.Series(["4 cups","1 cup","2 large","1 can",],index=["Flour","Milk","Eggs","Spam",] ,name='Dinner')
```
---
### Reading data files
* `pd.read_csv`:Pour lire un fichier de données dans notre base de donnée, on utilise la méthode .
Exemple:
```python=
reviews = pd.read_csv("../input/wine-reviews/winemag-data_first150k.csv", index_col=0)
```
* `shape`:Pour vérifier la taille du Dataframe résultant.
* `head`:Pour retourner les 5 premières lignes de notre Dataframe, on utilise la commande .
* `tail`:Pour retourner les 5 dernières lignes de notre Dataframe, on utilise la commande .


---

## Indexing, selection and allocation
Pour afficher le Dataframe:
```python=
reviews
```
Pour afficher une colonne du Dataframe:
```python=
reviews.description
# ou
reviews['description']
```

Pour gérer les indices, on utilise `iloc` et `loc`.

* `Iloc`  est utilisé pour gérer les lignes en se basant sur la position et en ignorant les indices:
```python=
reviews.iloc([1, 2, 3])
```

* `loc` a le meme principe que `iloc` mais se base sur la valeur de l'indice et pas la position. 
```python=
reviews.loc(0, ['description'])
```

* `isin` permet de sélectionner des données dont la valeur "est dans" une liste de valeurs. 
Par exemple, voici comment l’utiliser pour sélectionner des vins uniquement d’Italie ou de France:
```python=
reviews.loc[reviews.country.isin(['Italy', 'France'])]
```
---

## Summary Functions and Maps
### Les fontions Summary
* `describe()` sert à générer une description des attributs d'une colonne, et sa sortie change en fonction du type des données entrées.
* `mean()` sert à donner la moyenne des points attribués et se base sur la formule: $(min + max)/2$.
* `unique()` sert à donner une liste des valeurs uniques.
* `value_counts()` sert à donner une liste des valeurs uniques et leur fréquence d'apparition dans les données.
### Maps
Le mappage de données est le fait mettre en correspondance les champs de plusieurs bases de données.
Pour cela en utilise deux méthodes:
* `map()` sert à transformer chaque valeur d'une série par une autre valeur,pouvant etre dérivée d'une fonction ou d'une série.
* `apply()` est équivalente à `map()`,on l'utilise pour transformer tout un Dataframe en faisant appel à une méthode précise pour chaque ligne de celui-ci.

---



## Grouping and sorting
* `groupby`: affiche les données en ordre du tableau initial, mais on peut mettre l'ordre par valeur qu'on veut avec `sort_values`.
* `sort_index()`:Pour mettre les indices en ordre.


---
## Data Types and Missing Values
Cette partie nous a servi pour apprendre à étudier les types de données dans un DataFrame ou une série et les rechercher ou remplacer à l'aide des méthodes suivantes:
* `dtype`: sert à retourner le type d'une colonne précise.
* `dtypes`:meme role que `dtype` , mais pour le type de chaque colonne du Dataframe.
* `astype()`: sert à changer le type d'une colonne à un autre type précisé entre les parenthèses.

Meme les indices d'un Dataframe ou Serie ont leurs propres types et pour les trouver on fait appel à `dtype`:
```python=
reviews.index.dtype
```
### Missing Values
Les valeurs manquantes (nulle) des données ont la valeur `NaN` et sont par défaut de type`float64`. 
Il existe des méthodes spécifiques pour gérer les valeurs manquantes:
* `pd.isnull()` ou `pd.notnull()` : Sert à selectionner les valeurs manquantes `NaN`.
* `fillna()`:Sert à remplacer les valeurs `NaN` par une valeur de nore choix.
* `replace()`: Sert pour remplacer une valeur non nulle avec une autre valeur non nulle.


---

## Renaming and Combining
### Renaming
* `rename`:Pour renommer les colonnes.
* `rename_axis()`:Pour renommer les axes des lignes ou colonnes.


### Combining
Cette partie sert à combiner différents Dataframes/Series et pour cela on utilise ces 4 méthodes:
* `concat` :Pour concatener 2 éléments de notre bases de données.
* `join()` :Pour combiner de différents objets du Dataframe qui ont un indice commun, et pour cela on aura besoin des paramètres `lsuffix` et `rsuffix` si les données on le meme nom de colonne.

---

# Data Visualization
Dans cette partie du cours on apprend à faire passer nos visulisations de données à un niveau supérieur avec seaborn, qui est un outil de visualisation de données puissant mais encore facile à utiliser.

## Line charts
* `donnee = pd.read_csv("../input/spotify.csv", index_col="Date", parse_dates=True)`
* `plt.figure(figsize=(14,6))` Pour preciser la taille de la figure
* `plt.title("Daily Global Streams of Popular Songs in 2017-2018")` Pour ajouter un titre
* `sns.lineplot(data=donnee)` Pour afficher le tableau de données
![](https://i.imgur.com/3FFaAPu.png)



On peut facillement changer le tableau de données en changent la valeur du parametre *data*

*PS.* Certaines fonctionalités sont accessibles directement depuis la librairie matplotlib (fonctionalités générales) mais d'autres ne le sont qu'à travers seaborn.

## Bar charts

* `donnee = pd.read_csv("../input/flight_delays.csv", index_col="Month")`
* `plt.figure(figsize=(10,6))` : Pour préciser la taille de la figure
* `plt.title()`: Pour ajouter le titre.
* `sns.barplot(x=donnee.index, y=donnee['NK'])`:Pour afficher le tableau de données

*NK* est la collonne choisie

## Heatmaps
* `donnee = pd.read_csv("../input/flight_delays.csv", index_col="Month")`  La donnee a afficher
* `plt.figure(figsize=(14,7)) `  Pour preciser la taille de la figure
* `plt.title("Average Arrival Delay for Each Airline, by Month")` Pour ajouter un titre
* `sns.heatmap(data=donnee, annot=True)`  Pour afficher le tableau de données

*annot = True* pour remplir la map par les valeurs à l'affichage

## Scratter Plots
* `donnee = pd.read_csv("../input/insurance.csv")` :La donnee a afficher
* `sns.scatterplot(x=donnee['bmi'], y=donnee['charges'])`:On choisit les collonnes x et y a afficher dans l'axe des abscisses et des ordonnés respectivement
* `sns.regplot(x=donnee['bmi'], y=donnee['charges'])`:Pour dessiner la ligne de regression on peut utiliser 
* `sns.regplot(x=donnee['bmi'], y=donnee['charges'], hue=donnee['smoker'])`:Pour afficher une 3eme colonne, on la fait rajouter dans l'attribut *hue*


---


# Data Cleaning 
Le but de ce cours est d'optimiser nos données, et résoudre des problèmes de nettoyage de données a fin d'annalyser nos données rapidement, par ce que il existe des données de mauvaises qualités.

### Handling Missing Values 

Dans cette partie on apprend a compter le nombre de valeurs manquantes avec le code suivant : 
```python=
missing_values_count = nfl_data.isnull().sum()
```
- On prend l'exemple suivant : 

|     | Bob        | Jhon       |
| --- | ---------- | ---------- |
| 0   | 27         | NAN        |
| 1   | Tresorier  | Protecteur |

 On voit que la donnée de type age de Bob est manquante. On compte le nombre de valeur manquante avec le code suivant : 
 ```python=
 missing_values_count = Bob.isnull().sum()
 total_missing = missing_values_count.sum()
```
Pour compter le pourcentage de valeurs manquantes, il faut récuperer le nombre total de celulle et faire le calcule . 
 ```python=
total_cells = np.product(Bob.shape)
percent_missing = (total_missing/total_cells) * 100
```
Dans autres cas on peut trouver un problèmes face a les valeurs qui n'exsite pas ou les valeurs non enregistrer, dans ce cas on supprime la ligne qui possède les valeurs manquantes avec le code suivant : 
 ```python=
nfl_data.dropna()
```
Si on souhaite supprimer les colones qui ont une ou plusieurs valeurs manquante on utilise : 
 ```python=
 nfl_data.dropna(axis=1)
```

On peut utiliser la fonction fillna() pour remplacer les valeurs NAN : 
 ```python=
subset_nfl_data.fillna(0) #ici on remplace les NaN avec des 0
subset_nfl_data.fillna(method='bfill', axis=0).fillna(0)#On remplace par la valeur de la ligne suivante de la même colone 
```
### Scaling and Normalization

Dans cette partie on normalise et on met à l'echelles les données grâces à des fonctions, on la différence entre les deux .

- Lors de la mise à l'echelle on modifie le range de nos données 
- En normalisation on modifie la forme de la distribution des données 
-----
Soit le Dataframe suivant livre_data : 

|     | livres    | pages    | note | auteur   | prix    |
| --- | --------- | ------   | ---- | -------- | --------|
| 0   | Water        | 335   | 5    | GeorgeX     | 9.99 |
| 1   | In the Jungle| 500   | 9    | LefaX    | 6.99    |
#### Scaling
On transforme nos données afin qu'elles soient dans une échelle spécifique. On souhaite mettre à l'echelles nos données lorsqu'on utilise des méthodes basées sur des mesures de la distance entre les points de données.
En mettant à l'echelle nos variables, cela aide à comparer différentes variables sur un points d'égalité.
 ```python=
 minmax_scaling(livre_data, columns=['prix'])
```
Cette fonction permet de faire un distribution des valeurs entre 0 et 1 des prix de livres.

#### Normalization
La normalisation sert a changer les observations afin qu'elles puissent êtres décrites comme une distribution normale. En général, on normalise nos données quand on utilise une technique d'apprentissage automatique ou de statistique qui suppose que les données sont normalement distribuées.
Pour normaliser les valeurs on récupère les index de toutes les valeurs postives : 
 ```python=
index_of_positive_pledges = livre_data.prix > 0
```
Pour récuprer les valeurs de l'index : 
 ```python=
valeurs_positives = livre_data.prix.loc[index_positif]
```
Après on normalise les valeurs récuperer : 
 ```python=
normalisee = pd.Series(stats.boxcox(valeurs_positives)[0]) 
```
### Parsing Dates

Le but de cette partie est la gestion des dates. 
|     | date         | pays     | ct   | code     |
| --- | ----------   | ------   | ---- | ---------|
| 0   | 02/02/1888   | FRANCE   | 8.5  | FR       |
| 1   | 03/12/1998   | CANADA   | 7    | CA

On peut vérifier la taille des dates dans la colonne et regarde s'ils vérifient la forme(JJ/MM/AAAA) : 
```python=
date_lengths = date_data.date.str.len()
#on compte les dates
date_lengths.value_counts()
#On va trouver une date de taille 10 c'est  04/048/19997
```
On peut recupérer l'indice après : 
```python=
indices = np.where([date_taille == 10])[1]
print('Les indices avec les mauvaises dates:', indices)
date_data.loc[indices]
```
Après la récupération de l'indice(indice est : 2), on peut modifier la date et l'écrire dans le format demander : 
```python=
date_data.loc[2, "date"] = "04/04/1997"
```
### Character Encodings
On va traiter l'encodage des caractères dans cette partie, tout nos données seront en UTF-8 .

Pour préciser l'encodage du message : 
```python=
avant = message.decode("big5-tw")
#encode en utf-8
new_entry = avant.encode()
```
- La lecture d'un fichier avec les problèmes d'encodage : 
 On utilise le fichier "../input/best-punshline-in-the-world/ArtHealingUs.csv".
 On determine le bon encodage et on va lire le fichier dans un Dataframe art_life .
 ```python=
 #il suffit d'utiliser pd.read.csv(chemin, encoding='type d'encodage')
 art_life = pd.read_csv("../input/best-punshline-in-the-world/ArtHealingUs.csv", encoding='UTF-32')
```

- On peut l'enregistrer avec UTF-8 encoding en utilisant la commande suivante : 

 ```python=
 art_life.to_csv("../input/best-punshline-in-the-world/ArtHealingUs.csv")
 ```