---
title: " 1 : Premiers pas avec R et les données climatiques"
format: html
execute:
  echo: true
  warning: false
  message: false
---

![notebook 1](https://raw.githubusercontent.com/smugeit/ghana_wkshp_img/main/images/img.png)

# Notebook 1 : Premiers pas avec R et les données climatiques

Ce notebook couvre **trois sessions pratiques** :

- **Session 1 :** bases de R, notebook, variables, objets, tableaux et packages  
- **Session 2 :** introduction aux données climatiques, chargement des données, vérification de la structure, contrôles de qualité et statistiques descriptives  
- **Session 3 :** transformation des données, visualisation, interprétation et sauvegarde des résultats  

Tout au long du notebook, nous suivrons le même flux d’analyse :

**Charger les données > Inspecter > Analyser > Visualiser > Interpréter > Sauvegarder**

Ce notebook utilise des jeux de données sur les précipitations et la température comme principaux jeux de données de formation, et introduit les idées clés qui seront réutilisées dans les sessions suivantes de l’atelier.


---

## Objectifs d’apprentissage

À la fin de ce notebook, vous devriez être capable de :

- expliquer ce qu’est R et comment fonctionnent les notebooks
- charger et inspecter un vrai jeu de données
- comprendre ce qu’est un package et pourquoi nous les utilisons
- utiliser les objets, vecteurs et data frames de base dans R
- utiliser les fonctions principales de `dplyr` pour filtrer, sélectionner, modifier, trier et résumer des données
- réaliser des statistiques descriptives sur des données climatiques
- créer des graphiques simples avec `ggplot2`
- sauvegarder des résultats dans un dossier `resultats/`

## Avant de commencer

1. Créez un nouveau dossier sur votre ordinateur pour cet atelier, par exemple : atelier_ggw_senegal.
2. Dans ce dossier, créez une structure simple pour organiser vos fichiers :
atelier_ggw_senegal/
├── donnees/
├── scripts/
├── resultats/
└── figures/
3. Enregistrez ce notebook dans le dossier scripts/ et renommez-le, par exemple : `Practical1_VotreNom.qmd`
4. Placez les fichiers de données fournis dans le dossier donnees/.
5. Ouvrez le fichier .qmd dans RStudio et travaillez uniquement dans votre propre copie.
6. Enregistrez régulièrement votre travail avec File > Save ou Ctrl + S.
---

# Session 1 - Bases de R et travail dans les notebooks

## **1. Qu’est-ce que R ?**

**R** est un langage de programmation conçu pour travailler avec des données.

![R](https://raw.github.com/smugeit/ghana_wkshp_img/main/images/r.png)

Il est largement utilisé pour :

- le nettoyage et la transformation des données
- les statistiques et l’analyse descriptive
- la visualisation
- la cartographie et l’analyse spatiale
- la modélisation
- les rapports et les flux de travail reproductibles

Dans cet atelier, l’élément le plus important à comprendre est qu’en R, nous allons généralement :

- stocker des éléments dans des **objets**
- appliquer des **fonctions** à ces objets
- construire des flux de travail étape par étape

Vous n’avez **pas** besoin de tout mémoriser. L’objectif est de devenir plus à l’aise pour lire du code, exécuter du code et comprendre progressivement ce que fait chaque ligne.

### Liens utiles
Si vous souhaitez en apprendre davantage sur R, depuis les bases jusqu’à ses nombreuses capacités en modélisation statistique, visualisation et création de produits interactifs comme des tableaux de bord, consultez les liens ci-dessous.

- R : <https://education.rstudio.com/learn/beginner/>
- R for Data Science : <https://r4ds.hadley.nz/>

## **2. Pourquoi utiliser des notebooks ?**

Un notebook combine trois éléments au même endroit :

- **texte** - instructions, explications et interprétation
- **code** - les commandes utilisées pour l’analyse
- **sorties** - tableaux, graphiques, résumés et cartes

Les notebooks sont utiles car ils nous aident à :

- documenter ce que nous faisons
- exécuter une analyse étape par étape
- garder le code et l’interprétation ensemble
- rendre les flux de travail plus faciles à partager et à reproduire

Dans cet atelier, le notebook est un espace pour exécuter du code, lire et suivre les étapes d’instruction, et tester progressivement votre compréhension à chaque étape.


## **3. Cellules Markdown et cellules de code**

Un notebook est composé de **cellules**.

### Cellules Markdown
Les cellules Markdown contiennent :
- du texte
- des images
- des notes
- des explications
- de l’interprétation

### Cellules de code
Les cellules de code contiennent du code qui peut être exécuté.

Dans cet atelier :
- le Markdown aide à expliquer le *pourquoi*
- les cellules de code montrent le *comment*


Essayez d’exécuter la cellule ci-dessous.

```{r}
"Bonjour de R!"
# Ceci est un commentaire.
# Les commentaires aident à expliquer ce que fait le code.
# Pour écrire un commentaire, mettez simplement un `#` avant votre texte.
```

## **4. Packages et bibliothèques**

L’une des forces de R est qu’il dispose de nombreux **packages**.

Un package est un ensemble de fonctions conçues pour un objectif particulier.

Dans ce notebook, nous utiliserons :

- `dplyr` - manipulation des données
- `ggplot2` - création de graphiques et visualisation

Vous verrez généralement deux étapes :

1. **installer** un package  
2. **charger** un package avec `library()`

Dans de nombreux environnements de notebooks, les packages doivent être réinstallés lorsqu’un nouveau runtime démarre.

### Liens utiles
- dplyr : <https://dplyr.tidyverse.org/>
- ggplot2 : <https://ggplot2.tidyverse.org/>

```{r}
# Installer les packages
install.packages(c("dplyr", "ggplot2"))

# Charger les packages
library(dplyr)
library(ggplot2)
```

## 5. Objets et assignation

Dans R, nous stockons généralement des éléments dans des **objets**. Vous entendrez peut-être aussi certaines personnes les appeler des **variables**.

Nous créons des objets avec l’opérateur d’assignation :

```r
name <- value
```

Cela signifie :

- prendre la valeur à droite
- la stocker dans le nom d’objet à gauche

Les objets nous permettent de sauvegarder des informations et de les réutiliser plus tard.

```{r}
precipitation_mm <- 520
temperature_c <- 27

precipitation_mm
temperature_c
```

### Pourquoi utiliser des objets (variables) ?

Lorsque vous travaillez dans R, vous saisissez rarement les mêmes valeurs encore et encore. À la place, vous les stockez dans des objets, puis vous utilisez ces objets dans des calculs, des résumés et des graphiques.

```{r}
precipitation_mm + 50
temperature_c - 3
precipitation_mm / 12
```

### Exercice 1

Créez ci-dessous deux objets de votre choix :

- une valeur de précipitation
- une valeur de température

Puis réalisez au moins deux calculs avec ces objets.

```{r}
# À vous de jouer
```

## 6. Types de données

R doit savoir avec quel type d’information il travaille.

Quelques types de données courants sont :

- **numeric** - nombres
- **character** - texte
- **logical** - TRUE ou FALSE

Vous pouvez vérifier le type d’un objet avec des fonctions comme `class()` ou `typeof()`.

```{r}
pays <- "Ghana"
annee <- 2024
annee_seche <- TRUE

class(pays)
class(annee)
class(annee_seche)
```

### Pourquoi c’est important

Différentes fonctions attendent différents types de données.

Par exemple :

- vous pouvez calculer une moyenne pour des valeurs numériques
- vous ne pouvez pas calculer une moyenne pour des valeurs textuelles
- les valeurs logiques sont utiles pour vérifier des conditions

### Exercice 2

Créez un objet pour chacun des éléments suivants :

- un nombre
- une valeur textuelle
- une valeur TRUE ou FALSE

Puis utilisez `class()` pour inspecter chacun d’eux.

```{r}
# À vous de jouer
```

## 7. Vecteurs

Un **vecteur** est une collection de valeurs du même type.

Les vecteurs sont très courants dans R. Ils peuvent représenter :

- des valeurs annuelles de précipitations
- des années
- des noms de districts
- des mesures de sol

Nous créons généralement un vecteur avec `c()`, qui signifie **concaténer**.

```{r}
valeurs_precipitations <- c(420, 380, 510, 610, 455)

valeurs_precipitations
length(valeurs_precipitations)
mean(valeurs_precipitations)
min(valeurs_precipitations)
max(valeurs_precipitations)
```

### Important !

Les vecteurs sont l’un des concepts les plus importants dans R.

Très souvent, une colonne dans un jeu de données est simplement un vecteur. Cela signifie que lorsque vous apprenez à travailler avec des vecteurs, vous apprenez déjà à travailler avec de vraies données.

### Exercice 3

Créez votre propre vecteur de cinq mesures, puis utilisez :

- `length()`
- `mean()`
- `min()`
- `max()`

Vous pouvez utiliser des précipitations, des températures, des valeurs de sol ou toute autre mesure environnementale.

```{r}
# À vous de jouer
```

## 8. Fonctions

Une **fonction** est un élément qui effectue une opération sur des données.

Vous avez déjà utilisé plusieurs fonctions :

- `mean()`
- `length()`
- `min()`
- `max()`
- `class()`

Un modèle simple à retenir est :

```r
function_name(data)
```

L’analyse dans R est souvent simplement une suite d’applications de fonctions à des objets.

```{r}
# Nous pouvons essayer la même chose avec un autre vecteur d’exemple

valeurs_temperature <- c(26.1, 27.3, 28.0, 26.8, 27.5)

mean(valeurs_temperature)
sum(valeurs_temperature)
round(mean(valeurs_temperature), 1)
sort(valeurs_temperature)
```

### Exercice 4

Utilisez le vecteur ci-dessous et essayez les fonctions suivantes :

- `mean()`
- `sum()`
- `sort()`
- `round()`

Que fait chacune d’elles ?

```{r}
valeurs_exemple <- c(14.2, 11.8, 15.6, 13.1, 12.9)

# À vous de jouer
```

## 9. Data frames

Un **data frame** est un tableau avec des lignes et des colonnes.

Vous pouvez l’imaginer comme une feuille de calcul :

- chaque ligne est une **observation**
- chaque colonne est une **variable**

C’est l’une des structures les plus courantes avec lesquelles vous travaillerez dans R.

```{r}
exemple_df <- data.frame(
  pays = c("Ghana", "Senegal", "Mali", "Nigeria", "Ethiopia"),
  precipitation_mm = c(520, 410, 365, 290, 640),
  temperature_c = c(24.8, 28.1, 29.0, 30.4, 22.6)
)

exemple_df
```

Deux fonctions très utiles lorsque vous ouvrez un nouveau jeu de données sont :

- `str()` - affiche la structure et les types de variables
- `summary()` - donne un résumé statistique rapide
- `names()` - affiche les noms des colonnes

Ce sont souvent les **premières fonctions** à exécuter sur un nouveau jeu de données.

```{r}
str(exemple_df)
summary(exemple_df)
names(exemple_df)
```

### Exercice 5

Créez un petit data frame de votre choix avec :

- un nom de localité
- une valeur climatique
- une variable de terre ou de sol

Puis exécutez `str()` et `summary()` dessus.

```{r}
# À vous de jouer
```

## 10. Accéder aux colonnes dans un data frame

Vous pouvez accéder à une colonne spécifique avec le symbole `$`.

C’est utile car cela vous permet de travailler avec une variable à la fois.

```{r}
# Ici, nous utilisons $ pour extraire precipitation_mm et temperature_c
exemple_df$precipitation_mm
mean(exemple_df$precipitation_mm)
summary(exemple_df$temperature_c)
```

Vous pouvez aussi utiliser des crochets pour extraire des lignes ou des colonnes.

Par exemple :

- `exemple_df[1, ]` signifie la première ligne
- `exemple_df[, 2]` signifie la deuxième colonne

```{r}
exemple_df[1, ]
exemple_df[, 2]
exemple_df[1:3, ]
```

### Exercice 6

En utilisant `exemple_df` ci-dessus, essayez les actions suivantes :

1. Extraire la colonne `temperature_c` avec `$`
2. Calculer la moyenne de `temperature_c`
3. Afficher uniquement les deux premières lignes

```{r}
# À vous de jouer
```

## 11. Inspecter les données avant l’analyse

Avant de faire une analyse, il est recommandé d’inspecter vos données.

Quelques fonctions très utiles sont :

- `head()` - premières lignes
- `tail()` - dernières lignes
- `dim()` - nombre de lignes et de colonnes
- `nrow()` - nombre de lignes
- `ncol()` - nombre de colonnes
- `summary()` - aperçu rapide des valeurs

```{r}
head(exemple_df)
tail(exemple_df)
dim(exemple_df)
nrow(exemple_df)
ncol(exemple_df)
```

### Réflexion

Pourquoi est-il utile d’inspecter un jeu de données avant de faire une analyse ? Écrivez une ou deux phrases avec vos propres mots.

```{r}
# Écrivez votre réponse ici sous forme de commentaire
```

## 12. Répertoire de travail et dossiers

Avant de travailler avec de vraies données, il est utile de savoir d’où les fichiers sont lus et où ils sont sauvegardés.

Le **répertoire de travail** est l’emplacement actuel utilisé par R.

```{r}
getwd()

list.files()
```

Cela deviendra important plus tard lorsque vous commencerez à charger des jeux de données et à sauvegarder des résultats comme des graphiques ou des tableaux de synthèse.

## **13. Importer de vraies données**


Nous allons maintenant passer des données d’exemple à un vrai jeu de données de l’atelier.

**Étape 1 : Télécharger le jeu de données**

Nous commencerons par télécharger le jeu de données que vous utiliserez dans ce pratique.

Cliquez sur le lien ci-dessous pour accéder aux données :

🔗 https://drive.google.com/drive/folders/1TC6qBGdCt2xvz1P1DuDoFty6AZmXYJAn

**Instructions**

1. Ouvrez le lien ci-dessus  
2. Sélectionnez les fichiers pertinents (`ggw_precipitations.csv` et `ggw_temperatures.csv`)  
3. Cliquez sur **Download**  
4. Enregistrez le fichier sur votre ordinateur (par exemple, dans votre dossier Téléchargements)

**Étape 2 : Configurer votre dossier de projet**

Avant de poursuivre avec des exercices plus pratiques utilisant de vraies données, il est recommandé de configurer un dossier de projet pour garder votre travail bien organisé.

Une fois les fichiers csv téléchargés, créez un nouveau dossier quelque part sur votre ordinateur (avec un nom intuitif comme `ghana_workshop_2026`). Dans ce dossier, créez trois nouveaux dossiers :

- `donnees/` → fichiers de données d’entrée
- `resultats/` → graphiques et tableaux sauvegardés
- `scripts/` → notebooks ou scripts

![structure_dossier](https://github.com/gsl-icraf/Ghana_K4GGWA_workshop_2026/raw/practicals/images/proj_str.png)

Pour cet atelier, nous sauvegarderons les données téléchargées dans le dossier `donnees/`, et les résultats dans le dossier `resultats/`, afin que vous puissiez voir comment un flux de travail reproductible est organisé.

**Étape 3 : Téléverser le jeu de données dans le notebook**

Nous allons maintenant téléverser le fichier depuis votre ordinateur vers cet environnement de notebook.

Sur le côté gauche de la console Colab, vous verrez une longue barre d’icônes. Cliquez sur l’icône de dossier, puis sélectionnez l’option de téléversement. Ensuite, trouvez l’emplacement du dossier de projet où vous avez sauvegardé vos données. Cliquez sur vos jeux de données pour les téléverser. Vous devriez maintenant les voir dans l’onglet Files de Colab.

![notebook1](https://github.com/gsl-icraf/Ghana_K4GGWA_workshop_2026/raw/practicals/images/upload_data.png)

**Étape 4 : Charger les jeux de données dans R**

Une fois téléversés, les fichiers sont disponibles dans l’environnement du notebook.

Nous pouvons maintenant les charger dans R avec la fonction `read.csv`.

Commençons par explorer les données de précipitations, puis ajoutons la température comme deuxième jeu de données climatique.

```{r}
precipitations_df <- read.csv("donnees/ggw_precipitations.csv")

head(precipitations_df)
```

Nous pouvons aussi charger le jeu de données de température exactement de la même manière.

Cela nous donne deux jeux de données climatiques à comparer :

- **précipitations** - précipitations annuelles moyennes (`PMA`) et colonnes de précipitations annuelles (`precip_...`)
- **température** - température annuelle moyenne (`TMA`) et colonnes de température annuelle (`t2m_...`)

```{r}
# Charger le jeu de données de température
temperature_df <- read.csv("donnees/ggw_temperatures.csv")

head(temperature_df)
```

Le jeu de données sur les précipitations contient :
> - le nom du pays
> - l’identifiant du point d’échantillonnage
> - la longitude (`lon`) et la latitude (`lat`)
> - `PMA` (précipitations annuelles moyennes)
> - des valeurs annuelles de précipitations pour plusieurs années

Le jeu de données sur la température contient :

> - un nom de pays
> - un identifiant de point d’échantillonnage
> - la longitude (`lon`) et la latitude (`lat`)
> - TMA (température annuelle moyenne)
> - des valeurs annuelles de température pour plusieurs années

**Vérification des connaissances**

- Que fait `read.csv()` ?
- Qu’est-ce qu’une observation dans ces jeux de données ?
- Quelles sont les variables ?

```{r}
# Écrivez vos réponses aux questions ci-dessus ici
```

# Session 2 - Données climatiques : comprendre, vérifier et décrire les données

## **14. Comprendre les données climatiques pour le travail de restauration**

Le climat est un facteur clé de la santé des terres et des résultats de restauration. Il influence :
> - la croissance de la végétation
> - la disponibilité de l’eau
> - le stress lié à la sécheresse
> - l’humidité du sol
> - les processus d’érosion

Comprendre le climat aide les praticiens à poser des questions comme :
> - Quelles zones sont plus humides ou plus sèches ? Y a-t-il des tendances à l’humidification ou à l’assèchement dans ma zone ?
> - Quelle est la variabilité des précipitations au fil du temps ?
> - Comment les conditions climatiques pourraient-elles influencer mes choix de restauration ?

Dans cette session, nous nous concentrons sur le jeu de données de précipitations.

### À propos de ce jeu de données

Ce jeu de données comprend :
- `PMA` - précipitations annuelles moyennes
- `precip_2001` à `precip_2025` - valeurs annuelles de précipitations par année

Le jeu de données contient donc à la fois :
- une **variable climatique de synthèse** (`PMA`)
- une **série temporelle** de valeurs annuelles de précipitations

## **15. Premier aperçu du jeu de données**

Lorsque vous ouvrez un nouveau jeu de données réel, une bonne première étape consiste à demander :

- Combien y a-t-il de lignes et de colonnes ? Autrement dit, quelle est la taille du jeu de données avec lequel je travaille ?
- Quels sont les noms des colonnes ?
- Quels types de variables avons-nous ? Quelle est l’unité de mesure ?
- Les valeurs semblent-elles raisonnables ?
- Y a-t-il des valeurs manquantes ?

```{r}
# Commençons par inspecter le jeu de données avec quelques fonctions apprises plus tôt
dim(precipitations_df)
names(precipitations_df)
str(precipitations_df)
summary(precipitations_df)
```

Nous pouvons répéter les mêmes vérifications initiales pour le jeu de données de température.

C’est une bonne habitude : lorsque vous commencez à travailler avec différents jeux de données, il est toujours utile de vérifier la structure pour savoir avec quoi vous travaillez.

```{r}
# Essayez d’effectuer les mêmes opérations sur votre jeu de données de température, en utilisant le nom que vous lui avez donné lors du chargement
dim()
names()
str()
summary()
```

### Interpréter ce que vous voyez

Regardez la sortie ci-dessus et discutez :

> - Combien d’observations y a-t-il dans chaque jeu de données ?
> - Combien de variables y a-t-il ?
> - Quelles variables sont des identifiants ?
> - Quelles variables sont des coordonnées ?
> - Quelles variables sont des mesures de précipitations/température ?

```{r}
# Écrivez vos réponses aux questions ci-dessus dans cette cellule
```

### Exercice 7

En utilisant les sorties ci-dessus, répondez aux questions suivantes pour chaque jeu de données sous forme de commentaires :

> 1. Combien y a-t-il de lignes ?
> 2. Combien y a-t-il de colonnes ?
> 3. Quelle colonne contient les précipitations/la température annuelles moyennes ?
> 4. Quelles colonnes semblent représenter des valeurs annuelles par année ?

```{r}
# Écrivez vos réponses ici sous forme de commentaires

# PRÉCIPITATIONS
# 1.
# 2.
# 3.
# 4.

# TEMPÉRATURE
# 1.
# 2.
# 3.
# 4.
```

## 16. Examiner les données plus attentivement

Il est souvent utile d’inspecter le début et la fin du tableau, et d’examiner quelques colonnes sélectionnées.

```{r}
# Nous pouvons préciser le nombre de lignes à inspecter en modifiant le nombre placé après `precipitations_df`.
# Ici, il est fixé à 10, mais essayez de changer ce nombre pour voir plus ou moins de points.
head(precipitations_df, 10)
tail(precipitations_df, 10)
```

```{r}
# Nous pouvons aussi vérifier uniquement les colonnes qui nous intéressent
precipitations_df[, c("pays", "id_echantillon", "lon", "lat", "PMA")]
```

Nous devrions inspecter le tableau de température de la même manière avant de continuer.

Notez que le jeu de données de température couvre une période différente avec des intervalles d’échantillonnage différents de ceux du jeu de données de précipitations, mais les points d’échantillonnage et les identifiants sont les mêmes.

```{r}
# Essayez de vérifier les premières et dernières lignes de votre jeu de données de température.
head()
tail()

# Essayez maintenant de sélectionner seulement quelques colonnes d’intérêt dans votre data frame de température.
```

```{r}
# Combien de pays et de points d’échantillonnage y a-t-il dans le jeu de données de température ?
length(unique(temperature_df$pays))

length(unique(temperature_df$id_echantillon))
table(temperature_df$pays)
```

### Comparaison rapide

- Les jeux de données de précipitations et de température semblent-ils contenir les mêmes localisations d’échantillonnage ?
- Quel jeu de données couvre le plus d’années ?

```{r}
# Vérifions maintenant combien de pays il y a dans notre jeu de données et combien de points chacun contient

length(unique(precipitations_df$pays))

length(unique(precipitations_df$id_echantillon))
table(precipitations_df$pays)
```

```{r}
# Répétez la même vérification pour votre jeu de données de température
```

## **17. Contrôles de base de la qualité des données**

Avant toute analyse, il est toujours recommandé de vérifier vos données pour détecter des problèmes simples tels que :

- valeurs manquantes
- doublons
- plages de valeurs inattendues
- noms de variables étranges

```{r}
# Compter les valeurs manquantes dans chaque colonne
colSums(is.na(precipitations_df))

# Vérifier combien de valeurs manquantes il y a dans tout le jeu de données
sum(is.na(precipitations_df))

# Vérifier les plages de valeurs des précipitations
range(precipitations_df$PMA, na.rm = TRUE)
```

Nous devrions aussi effectuer quelques vérifications rapides sur les données de température.

```{r}
# Compter les valeurs manquantes dans chaque colonne

# Vérifier les plages de valeurs de la température
```

### Vérification des connaissances

Pourquoi devons-nous vérifier nos données de cette manière ?

Réfléchissez à ce qui pourrait arriver si :
- une variable clé contient beaucoup de valeurs manquantes
- des identifiants d’échantillons sont dupliqués de manière inattendue
- des valeurs climatiques sont en dehors d’une plage raisonnable

Cela aurait-il un impact sur les résultats de notre analyse ? Cela pourrait-il conduire à des résultats trompeurs ?

Nos valeurs semblent-elles raisonnables ?

```{r}
# Écrivez vos réponses aux questions ci-dessus dans cette cellule
```

## 18. Identifier les colonnes de précipitations annuelles

Une compétence utile consiste à pouvoir identifier automatiquement un groupe de colonnes.

Ici, nous identifions toutes les colonnes dont les noms commencent par `precip_`.

```{r}
colonnes_annees <- grep("^precip_", names(precipitations_df), value = TRUE)

colonnes_annees
length(colonnes_annees)
```

Nous pouvons identifier les colonnes annuelles de température de la même manière.

```{r}
# Essayez d’effectuer la même vérification sur le jeu de données de température
```

Cela nous donne un vecteur de toutes les colonnes annuelles de précipitations/température. C’est utile car nous pouvons ensuite les traiter comme un groupe.

### Exercice 8

Exécutez la cellule ci-dessous pour inspecter un sous-ensemble des colonnes de précipitations annuelles.

```{r}
precipitations_df[, c("pays", "id_echantillon", colonnes_annees[1:5])]
```

Nous pouvons inspecter quelques colonnes annuelles de température exactement de la même manière.

```{r}
# Faites la même chose pour la température
```

## 19. Statistiques descriptives pour les variables clés

Les statistiques descriptives nous aident à comprendre :
- la tendance centrale
- la dispersion
- les valeurs minimales et maximales
- les valeurs aberrantes possibles

Commençons avec `PMA`.

```{r}
mean(precipitations_df$PMA, na.rm = TRUE)
median(precipitations_df$PMA, na.rm = TRUE)
sd(precipitations_df$PMA, na.rm = TRUE)
min(precipitations_df$PMA, na.rm = TRUE)
max(precipitations_df$PMA, na.rm = TRUE)
quantile(precipitations_df$PMA, na.rm = TRUE)
```

Nous pouvons aussi résumer la variable clé de température, `TMA`.

```{r}
# Essayez de calculer ces statistiques descriptives pour votre jeu de données de température
```

### Exercice 9

En utilisant les colonnes de précipitations annuelles, calculez la moyenne pour une année spécifique, par exemple `precip_2020`.

```{r}
# À vous de jouer
```

```{r}
# Quelle année avait les précipitations annuelles moyennes les plus élevées : 2005 ou 2015 ?
```

Nous pouvons faire une vérification rapide similaire pour la température.

Par exemple, quelle était la température moyenne sur tous les points d’échantillonnage au cours d’une année ?

```{r}
# À vous de jouer
```

```{r}
# Quelle année avait les températures annuelles moyennes les plus élevées : 1995 ou 2025 ?
```

Comme les précipitations commencent en 2001 et que la température s’étend de 1940 à 2025, la **période de chevauchement** pour une comparaison directe est 2001-2025.

Cela sera important plus tard lorsque nous comparerons ensemble les tendances des précipitations et de la température.

## 20. Introduction à `dplyr`

`dplyr` est l’un des packages R les plus importants pour travailler avec des données tabulaires.

Quelques verbes courants sont :

- `select()` → choisir des colonnes
- `filter()` → garder les lignes qui correspondent à une condition
- `mutate()` → créer ou modifier des variables
- `arrange()` → trier les lignes
- `summarise()` → calculer des statistiques de synthèse
- `group_by()` → faire des résumés par groupes

Ces fonctions sont particulièrement utiles lorsque l’on travaille avec de grands jeux de données réels.

```{r}
# Chargeons d’abord la bibliothèque, si vous ne l’avez pas déjà fait plus tôt
library(dplyr)
```

## 21. Sélectionner et filtrer

Commençons par sélectionner quelques colonnes pertinentes et filtrer les données.

```{r}
precipitations_df %>%
  select(pays, id_echantillon, PMA)

precipitations_df %>%
  filter(PMA > 800) %>%
  select(pays, id_echantillon, PMA) %>%
  head()
```

### Exercice 10

Créez un nouvel objet appelé `fortes_precipitations_df` qui contient uniquement les points où `PMA` est supérieur à 700.
Puis affichez les premières lignes.

```{r}
# À vous de jouer
```

## 22. Résumés groupés par pays

Une tâche courante consiste à comparer des valeurs moyennes entre des groupes tels que des pays. Ci-dessous, nous créons un nouvel objet appelé `resume_pays` sur lequel nous travaillerons ensuite.

```{r}
resume_pays <- precipitations_df %>%
  group_by(pays) %>%
  summarise(
    nb_points = n(),
    moyenne_PMA = mean(PMA, na.rm = TRUE),
    mediane_PMA = median(PMA, na.rm = TRUE),
    ecart_type_PMA = sd(PMA, na.rm = TRUE),
    min_PMA = min(PMA, na.rm = TRUE),
    max_PMA = max(PMA, na.rm = TRUE)
  ) %>%
  arrange(desc(moyenne_PMA))

resume_pays
```

Nous pouvons produire le même résumé groupé pour la température.

```{r}
# Résumer les températures par pays
resume_temperature_pays <- temperature_df %>%
  group_by(pays) %>%
  summarise(
    nb_points = n(),
    moyenne_TMA = mean(TMA, na.rm = TRUE),
    mediane_TMA = median(TMA, na.rm = TRUE),
    ecart_type_TMA = sd(TMA, na.rm = TRUE),
    min_TMA = min(TMA, na.rm = TRUE),
    max_TMA = max(TMA, na.rm = TRUE)
  ) %>%
  arrange(desc(moyenne_TMA))

resume_temperature_pays
```

Comme les tableaux de précipitations et de température décrivent les mêmes points d’échantillonnage, nous pouvons les joindre.

Cela nous permet de poser des questions de comparaison simples, par exemple :

- Les endroits plus chauds ont-ils tendance à être plus secs ?
- Quels pays sont à la fois chauds et humides ?
- La relation entre précipitations et température est-elle la même partout ?

```{r}
climat_df <- precipitations_df %>%
  select(pays, id_echantillon, lon, lat, PMA) %>%
  inner_join(
    temperature_df %>% select(pays, id_echantillon, TMA),
    by = c("pays", "id_echantillon")
  )

head(climat_df)
dim(climat_df)
```

### Vérification des connaissances

Regardez le tableau `climat_df`.

- Pourquoi utilisons-nous `inner_join()` ici ?
- Que représente chaque ligne après la jointure ?
- Quelles variables sont maintenant disponibles pour la comparaison ?

```{r}
cor(climat_df$PMA, climat_df$TMA, use = "complete.obs")
```

Avant de commencer les graphiques, il est utile de créer un tableau simple qui combine les résumés de précipitations et de température au niveau des pays.

Cela nous donne un objet de comparaison propre pour l’interprétation.

```{r}
resume_climat_pays <- resume_pays %>%
  select(pays, nb_points, moyenne_PMA, ecart_type_PMA) %>%
  inner_join(
    resume_temperature_pays %>% select(pays, moyenne_TMA, ecart_type_TMA),
    by = "pays"
  )

resume_climat_pays
```

### Vérification des connaissances

Regardez `resume_climat_pays`.

- Quels pays semblent les plus humides en moyenne ?
- Quels pays semblent les plus chauds en moyenne ?
- Les pays les plus chauds semblent-ils aussi être les plus secs ?
- Pourquoi cela pourrait-il être important pour la planification de la restauration dans la région de la Grande Muraille Verte ?

## 23. Créer de nouvelles variables avec `mutate()`

Souvent, nous voulons dériver une nouvelle variable à partir d’une variable existante.
Par exemple, nous pouvons classer les localisations dans des catégories simples de précipitations.

```{r}
precipitations_df <- precipitations_df %>%
  mutate(
    classe_precipitations = case_when(
      PMA < 400 ~ "faible",
      PMA >= 400 & PMA < 800 ~ "moyenne",
      PMA >= 800 ~ "elevee"
    )
  )

table(precipitations_df$classe_precipitations)
```

Nous pouvons aussi classer les valeurs de température en groupes simples.

```{r}
# Essayez la même chose pour la température
```

### Exercice 11

Modifiez les seuils de classification si vous le souhaitez et inspectez comment les effectifs changent.

```{r}
# À vous de jouer
```

## 24. Inspecter une localisation au fil du temps

Le jeu de données contient des valeurs annuelles de précipitations pour chaque point.
Inspectons la série temporelle pour un point unique.

```{r}
point_echantillon <- precipitations_df[precipitations_df$id_echantillon == precipitations_df$id_echantillon[1], c("pays", "id_echantillon", colonnes_annees)]
point_echantillon
```

Nous pouvons aussi inspecter un point d’échantillonnage du jeu de données de température.

```{r}
# Essayez de faire la même chose pour la température : souvenez-vous du nom donné à votre objet de température
```

Cela montre un point et ses valeurs annuelles de précipitations au fil du temps. Pour l’instant, les données sont en **format large** : chaque année est une colonne séparée.

### Vérification des connaissances

- Pourquoi les données en format large peuvent-elles être pratiques pour le stockage, mais moins pratiques pour tracer des séries temporelles ?

---

# Session 3 - Analyse climatique, visualisation et résultats

## 25. Visualiser nos données

À ce stade, nous avons déjà :

> - inspecté les jeux de données de précipitations et de température
> - vérifié leur structure et leur qualité
> - identifié les colonnes annuelles
> - calculé des statistiques descriptives
> - produit des résumés groupés par pays
> - joint les deux jeux de données pour les comparer

Nous pouvons maintenant passer aux graphiques. La visualisation nous aide à :
> - voir rapidement des tendances
> - comparer des groupes
> - identifier des valeurs inhabituelles
> - communiquer les résultats à d’autres personnes

Dans cette session, nous utiliserons `ggplot2` pour créer des graphiques à partir des jeux de données de précipitations et de température, puis nous les comparerons.

## 26. Un graphique simple de PMA par pays

Commençons par un boxplot montrant la distribution des précipitations annuelles moyennes par pays.

Pour nous aider à tracer et visualiser nos données, nous avons besoin de `ggplot2`. Si vous l’avez déjà installé et chargé plus tôt dans le notebook, vous pouvez simplement exécuter les cellules de graphique suivantes.

```{r}
# Installer et charger `ggplot2`
```

```{r}
ggplot(precipitations_df, aes(x = pays, y = PMA)) +
  geom_boxplot() +
  theme_minimal() +
  labs(
    title = "Distribution des précipitations annuelles moyennes par pays",
    x = "Pays",
    y = "PMA (mm)"
  ) +
  theme(axis.text.x = element_text(angle = 45, hjust = 1))
```

## 26b. Un graphique simple de TMA par pays

Nous pouvons créer le même type de boxplot pour la température.

```{r}
# Essayez de créer un graphique similaire avec votre data frame de température
```

## 26c. Comparer les précipitations et la température ensemble

Maintenant que les deux jeux de données sont joints, nous pouvons créer un nuage de points simple pour explorer si les points plus humides ont aussi tendance à être plus frais ou plus chauds.

```{r}
ggplot(climat_df, aes(x = PMA, y = TMA, colour = pays)) +
  geom_point(alpha = 0.6) +
  theme_minimal() +
  labs(
    title = "Précipitations et température aux points d’échantillonnage",
    x = "PMA (mm)",
    y = "TMA (°C)"
  )
```

### Exercice 12b

Discutez du nuage de points :

- La relation semble-t-elle positive, négative ou faible ?
- Certains pays sont-ils regroupés dans différentes parties du graphique ?
- Pourquoi les précipitations et la température pourraient-elles être liées dans cette région ?

### Exercice 12

Modifiez le graphique ci-dessus de l’une des manières suivantes :

- changer le titre
- changer les étiquettes des axes

```{r}
# À vous de jouer
```

## 27. Nuage de points des coordonnées coloré par classe de précipitations

Même sans packages complets de cartographie, nous pouvons créer un graphique de localisation simple en utilisant la longitude (`lon`) et la latitude (`lat`).

```{r}
ggplot(precipitations_df, aes(x = lon, y = lat, colour = classe_precipitations)) +
  geom_point(alpha = 0.6, size = 1.5) +
  theme_minimal() +
  labs(
    title = "Localisations des points colorées par classe de précipitations",
    x = "Longitude",
    y = "Latitude",
    colour = "Classe de précipitations"
  )
```

### Discussion de contrôle

- Quels motifs spatiaux remarquez-vous ?
- Les points plus humides et plus secs sont-ils regroupés dans certaines régions ?

## 28. Optionnel : reformater les données pour un graphique de série temporelle

Pour tracer des séries temporelles, il est souvent utile de convertir le jeu de données du **format large** au **format long**.
C’est une étape plus avancée, donc considérez-la comme optionnelle et uniquement si vous êtes en avance.

```{r}
precipitations_longues <- reshape(precipitations_df,
                        idvar = c("pays", "id_echantillon"),
                        varying = colonnes_annees,
                        v.names = "precipitation_annuelle",
                        timevar = "etiquette_annee", # Nouvelle colonne pour les noms de colonnes d’origine
                        direction = "long") %>%
  mutate(annee = as.integer(sub("precip_", "", etiquette_annee))) %>%
  select(-etiquette_annee) # Supprimer la colonne temporaire contenant l’année

head(precipitations_longues)
str(precipitations_longues)
```

Nous pouvons reformater le jeu de données de température de la même manière.

```{r}
# Essayez de reformater le jeu de données de température de la même manière
```

## 29. Optionnel : précipitations moyennes au fil du temps

Nous pouvons maintenant résumer les précipitations par année sur l’ensemble des points.

```{r}
resume_annee <- precipitations_longues %>%
  group_by(annee) %>%
  summarise(moyenne_precipitations = mean(precipitation_annuelle, na.rm = TRUE))

head(resume_annee)
```

```{r}
# Essayez avec le jeu de données de température
```

```{r}
ggplot(resume_annee, aes(x = annee, y = moyenne_precipitations)) +
  geom_line() +
  geom_point() +
  theme_minimal() +
  labs(
    title = "Précipitations annuelles moyennes sur l’ensemble des points",
    x = "Année",
    y = "Précipitations moyennes (mm)"
  )
```

## 29b. Un graphique montrant tous les pays ensemble

Le graphique suivant montre les précipitations annuelles moyennes pour chaque pays dans une seule figure.

Cela facilite la comparaison pour voir si les pays évoluent dans des directions similaires ou différentes au fil du temps.

```{r}
precipitations_pays_annee <- precipitations_longues %>%
  group_by(pays, annee) %>%
  summarise(moyenne_precipitations = mean(precipitation_annuelle, na.rm = TRUE), .groups = "drop")

ggplot(precipitations_pays_annee, aes(x = annee, y = moyenne_precipitations, colour = pays)) +
  geom_line() +
  theme_minimal() +
  labs(
    title = "Précipitations annuelles moyennes par pays au fil du temps",
    x = "Année",
    y = "Précipitations moyennes (mm)"
  )
```

Nous pouvons faire la même chose pour la température.

```{r}
# Essayez maintenant la même chose avec la température
```

Comme les jeux de données de précipitations et de température se chevauchent de **2001 à 2025**, nous pouvons aussi préparer un seul tableau combiné pour cette période commune.

C’est utile lorsque nous voulons comparer l’évolution des précipitations et de la température au niveau des pays sur les mêmes années.

```{r}
annees_communes <- intersect(precipitations_pays_annee$annee, temperature_pays_annee$annee)

climat_pays_annee <- bind_rows(
  precipitations_pays_annee %>%
    filter(annee %in% annees_communes) %>%
    rename(value = moyenne_precipitations) %>%
    mutate(variable = "Précipitations"),
  temperature_pays_annee %>%
    filter(annee %in% annees_communes) %>%
    rename(value = moyenne_temperature) %>%
    mutate(variable = "Température")
)

head(climat_pays_annee)
```

Si vous voulez une seule figure montrant les deux variables, nous pouvons combiner les résumés par pays dans un seul tableau long et utiliser des facettes.

Comme les précipitations et la température utilisent des unités différentes, elles sont affichées dans des panneaux séparés. Ici, nous utilisons la période commune de **2001 à 2025** pour que la comparaison soit équivalente.

```{r}
ggplot(climat_pays_annee, aes(x = annee, y = value, colour = pays)) +
  geom_line() +
  theme_minimal() +
  facet_wrap(~ variable, scales = "free_y") +
  labs(
    title = "Tendances climatiques par pays pendant la période commune 2001-2025",
    x = "Année",
    y = "Valeur"
  )
```

## 29c. Optionnel : une tendance linéaire très simple

Une régression linéaire peut donner une première indication de l’augmentation ou de la diminution des précipitations au fil du temps pour un pays.

Ci-dessous, remplacez `"Ghana"` par n’importe quel nom de pays présent dans le jeu de données.

```{r}
precipitations_ghana <- precipitations_pays_annee %>%
  filter(pays == "Ghana")

modele_precipitations <- lm(moyenne_precipitations ~ annee, data = precipitations_ghana)

summary(modele_precipitations)
```

### Interpréter la sortie

Concentrez-vous surtout sur le coefficient de `annee`.

- si le coefficient est **positif**, les précipitations augmentent au fil du temps dans ce pays
- si le coefficient est **négatif**, les précipitations diminuent au fil du temps dans ce pays
- si la valeur est proche de zéro, la tendance est faible

Ce n’est qu’un premier modèle simple, mais c’est une introduction utile à l’analyse des tendances.

```{r}
ggplot(precipitations_ghana, aes(x = annee, y = moyenne_precipitations)) +
  geom_point() +
  geom_smooth(method = "lm", se = TRUE) +
  theme_minimal() +
  labs(
    title = "Tendance simple des précipitations pour le Ghana", # Vous pouvez remplacer le Ghana par un autre pays qui vous intéresse
    x = "Année",
    y = "Précipitations moyennes (mm)"
  )
```

### Exercice 13

Si vous êtes en avance, essayez l’une des options suivantes :

- résumer les précipitations à la fois par `pays` et par `annee`
- résumer la température à la fois par `pays` et par `annee`
- tracer une ligne séparée pour chaque pays
- comparer un pays à la moyenne globale
- tester une tendance simple des précipitations pour un pays avec `lm()`

```{r}
# À vous de jouer
```

## 30. Sauvegarder les résultats

Un bon flux de travail sauvegarde clairement les résultats afin qu’ils puissent être réutilisés plus tard.

```{r}
# Sauvegarder le tableau de résumé par pays
write.csv(resume_pays, "resultats/resume_precipitations_pays.csv", row.names = FALSE)

# Sauvegarder un graphique
p1 <- ggplot(precipitations_df, aes(x = pays, y = PMA)) +
  geom_boxplot() +
  theme_minimal() +
  labs(
    title = "Distribution des précipitations annuelles moyennes par pays",
    x = "Pays",
    y = "PMA (mm)"
  ) +
  theme(axis.text.x = element_text(angle = 45, hjust = 1))

ggsave("resultats/boxplot_precipitations_par_pays.png", plot = p1, width = 9, height = 5)
```

```{r}
# Sauvegarder le tableau de résumé de la température
write.csv(resume_temperature_pays, "resultats/pays_temperature_summary.csv", row.names = FALSE)

# Sauvegarder le graphique combiné précipitations-température
p2 <- ggplot(climat_df, aes(x = PMA, y = TMA, colour = pays)) +
  geom_point(alpha = 0.6) +
  theme_minimal() +
  labs(
    title = "Précipitations et température aux points d’échantillonnage",
    x = "PMA (mm)",
    y = "TMA (°C)"
  )

ggsave("resultats/nuage_precipitations_temperature.png", plot = p2, width = 8, height = 5)
```

### Vérifiez vos résultats

Utilisez la cellule ci-dessous pour confirmer que vos résultats ont été sauvegardés.

```{r}
list.files("resultats")
```

## 31. Mini-projet final

Utilisez le jeu de données de précipitations, le jeu de données de température, ou les deux ensemble, pour réaliser la courte tâche suivante.

### Tâche
1. Charger ou réutiliser un ou les deux jeux de données climatiques  
2. Inspecter leur structure  
3. Calculer un résumé groupé par pays  
4. Créer un graphique  
5. Si vous le souhaitez, tester une tendance simple des précipitations pour un pays avec `lm()`  
6. Écrire 2 à 3 phrases interprétant ce que vous avez trouvé

Vous pouvez choisir l’une de ces questions :

- Quel pays a les précipitations moyennes les plus élevées ?
- Quel pays a la température moyenne la plus élevée ?
- Les précipitations et la température sont-elles faiblement ou fortement liées au niveau des points d’échantillonnage ?
- Les précipitations semblent-elles augmenter ou diminuer au fil du temps dans un pays ?

```{r}
# Mini-projet final - à vous de jouer
```

## 32. Récapitulatif de la session

Dans ce notebook, vous avez :

- appris les concepts et objets de base dans R
- travaillé dans un environnement de notebook
- importé et inspecté de vrais jeux de données de précipitations et de température
- réalisé des contrôles de données et des statistiques descriptives
- utilisé `dplyr` pour filtrer, sélectionner, modifier, grouper, résumer et joindre des données
- créé des résumés au niveau des pays pour les deux variables climatiques
- exploré la relation entre précipitations et température
- utilisé `ggplot2` pour créer des boxplots, des nuages de points et des graphiques de séries temporelles
- sauvegardé des résultats dans un dossier
- éventuellement testé une tendance linéaire simple des précipitations pour un pays
