# Atelier narration de données
Ce TP est articulé autour de la **réutilisation des données**. A l'image du désormais célèbre [CovidTracker](https://covidtracker.fr/), le but est d'utiliser des données en accès libre pour créer des visualisations permettant une meilleure lisibilité ou compréhension de l'information.
## Objectif
Vous devrez réaliser un [Colab](https://colab.research.google.com/), ou équivalent, décrivant un jeu de données et présentant ces données (ou données retravaillées et/ou enrichies) sous forme de visualisations. Vous avez la possibilité d'exporter ces données et de réaliser ces visualisations en JavaScript, sur Tableau, sur Excel, etc. si vous le souhaitez.
## Jeu de données
Pour réaliser les travaux pratiques, il est nécessaire de trouver un (ou plusieurs) jeu(x) de données permettant de réaliser des moyennes, d'aggréger selon des catégories, etc. Vous êtes libres de trouver un sujet qui vous plaît.
- [data.gouv.fr](https://www.data.gouv.fr/fr/)
- [data.europa.eu](https://data.europa.eu/en)
- [Google Dataset Search](https://datasetsearch.research.google.com/)
Une fois le(s) jeu(x) de données sélectionné(s), vous pouvez essayer de trouver d'autres jeux de données analogues permettant d'enrichir, comparer, etc. l'information par la suite. L'important est de s'approprier les données (format, description, etc.).
Quelques pistes : énergie (évolution des prix, consommation, bornes de recharge pour les VE), etc.
## Traitement
### Traitement à la main
Pour traiter un jeu de données sans utiliser de librairie spécifique. Il suffit de lire les données en respectant le format dans lesquelles elles sont livrées.
#### CSV
```python=
import csv
with open("fichier.csv", 'r') as f:
csvreader = csv.reader(f, delimiter=';')
for row in csvreader:
print(row)
# traitement...
```
```python=
import csv
with open("fichier.csv", 'r') as f:
csvreader = csv.DictReader(f, delimiter=';')
for row in csvreader:
print(row)
# traitement...
```
Avec une petite nuance ligne n°4 où on précise à l'interpréteur de lire le fichier CSV comme un dictionnaire, c'est-à-dire qu'on ne va pas accéder à la colonne par son numéro de colonne mais par son appelation précisée dans l'entête du fichier CSV.
#### JSON
```python
import json
with open('fichier.json', 'r') as f:
data = json.load(f)
# traitement...
```
Mais il existe d'autres moyens plus appropriés !
### Traitement avec des outils adaptés
La librairie Python ```Pandas``` permet d'effectuer rapidement des traitements d'un ensemble de données. Pour l'utiliser, il faut installer la librairie comme présenté ci-dessous.
```
!pip install pandas
```
#### CSV
```python
import pandas as pd
df = pd.read_csv('fichier.csv')
# traitement...
```
#### JSON
```python
import pandas as pd
df = pd.read_json('fichier.json')
# traitement...
```
#### Quelques exemples de traitements
##### Afficher des informations sur le *dataframe*
```python
# affiche la taille du df
print(df.shape)
# affiche les x premières lignes
print(df.head(x))
# affiche le nombre de lignes correspondantes à des valeurs identiques
print(df['column'].value_counts())
# affiche les types des colonnes
print(df.dtypes)
```
##### Supprimer des lignes en fonction de valeurs données
```python
df = df[df.column != "value"]
# ou encore
df.drop(df.index[data['column'] < 123], inplace=True)
```
##### Créer des sous *dataframes*
```python
sub_df = df[df.column == "value"]
# ou encore
sub_df = df[df["column"].str.contains("value").fillna(False)]
```
```python
sub_dfs = df.groupby("column")
sub_df1 = sub_dfs.get_group(1)
```
##### Effectuer des opérations sur un ensemble de cellules ayant des valeurs identiques
Les opérations disponibles sont listées sur la [documentation officielle](https://pandas.pydata.org/docs/user_guide/basics.html#:~:text=Here%20is%20a%20quick%20reference%20summary%20table%20of%20common%20functions.%20Each%20also%20takes%20an%20optional%20level%20parameter%20which%20applies%20only%20if%20the%20object%20has%20a%20hierarchical%20index.).
```python
# grouper des données en fonction de la valeur d'une cellule
sub_df = df.groupby('column', as_index=False).count()
sub_df = df.groupby('column', as_index=False).mean()
sub_df = df.groupby('column', as_index=False).sum()
# ...
```
##### Trier un *dataframe*
```python
df.sort_values('column')
```
##### Fusionner des *dataframes*
```python
dfxdf = pd.merge(df1[["col1", "col2"]], df2[["col1", "col1"]], on="col1", how="left")
```
##### Renommer une colonne
```python
df.rename(columns={'column': 'col1'}, inplace=True)
```
## Création de visualisations
Pour créer des visualisations, divers outils sont disponibles. Les visualisations Python, basées sur les librairies matplotlib, plotly ou encore seaborn, sont plus proches du code mais parfois moins interactives que celles développées en JS (D3.js) ou Vega.
Le mieux est de choisir un exemple qui se rapproche le plus de la visualisation voulue, d'y intégrer ses données et de la modifier par la suite. Vous avez plusieurs sites proposant une multitude de visualisations ci-dessous.
À noter que les visualisations Vega peuvent s'intégrer à Kibana.
### Python (matplotlib, plotly, seaborn, bokeh ?)
- [Python-graph-gallery](https://www.python-graph-gallery.com/)
- [Bokeh](https://docs.bokeh.org/en/latest/docs/gallery.html)
- [Altair](https://altair-viz.github.io/gallery/index.html) (qui fait le lien avec Vega)
#### Example de visualisation rapide d'un *dataframe*
```python
import matplotlib.pyplot as plt
import seaborn as sns
# pd.set_option('display.max_rows', None)
sns.set()
# un histogramme
plt.figure()
p = sns.histplot(data['col1'], kde=True, stat="density", linewidth=0)
plt.show()
# un graphique linéaire
sns.lineplot(x='col1', y='col2', data=df)
```
### JS
- [Vizhub](https://vizhub.com/)
- [D3-grap-gallery](https://d3-graph-gallery.com/)
- [Chart.js](https://www.chartjs.org/docs/latest/samples/information.html)
- [Google Charts](https://developers.google.com/chart/interactive/docs)
- [Observable](https://observablehq.com/) (mais en mode notebook...)
### Vega
- [Vega](https://vega.github.io/vega/examples/)
Sign in with Wallet
Connect another wallet