02_bases_R.qmd

---
output: html_document
editor_options: 
  chunk_output_type: console
format:
  html:
    code-fold: false
---

# Fondamentaux pour l'utilisation de R {#sec-fondamentaux}

## L'environnement

### Différences R et Rstudio

R est un **langage de programmation** open source spécialisé dans la statistique et l'analyse des données. Il a été créé pour fournir un environnement convivial pour la manipulation, l'analyse et la visualisation des données.Il existe d'autres langages de programmation comme Python, JavaScript, Java, C++, etc.

R est utilisé pour effectuer des opérations statistiques, faire de la modélisation, créer des graphiques et effectuer des analyses de données complexes.

R est extrêmement flexible et extensible grâce à des packages R, qui ajoutent des fonctionnalités supplémentaires.

RStudio est un **environnement de développement intégré (IDE)** conçu spécifiquement pour travailler avec le langage R. C'est un logiciel qui fournit une interface utilisateur plus conviviale pour écrire, exécuter et gérer des scripts R. Il existe d'autres IDE, comme Visual Studio Code ou Jupyter Notebook.

RStudio inclut un éditeur de texte avec coloration syntaxique, un gestionnaire de packages, des fenêtres pour l'affichage des graphiques et des données, et bien d'autres fonctionnalités pour améliorer la productivité des utilisateurs R.

En somme, R est le langage de programmation sous-jacent pour l'analyse des données, tandis que RStudio est un environnement de développement qui facilite l'utilisation de R.

### Sources d'apprentissage

Il existe de plusieurs ressources en français pour apprendre à coder sur
R. Nous vous recommandons en particulier :

-   [Introduction à R et au Tidyverse](https://juba.github.io/tidyverse/index.html) [@barnier2022]
    [Guide-R: Guide pour l’analyse de données d’enquêtes avec R](https://larmarange.github.io/guide-R/) [@larmarange2024]
-   [utilitR: documentation collaborative sur R de l'INSEE](https://www.book.utilitr.org/index.html) [@utilitr:2022]

Les bonnes ressources anglophones gratuites sont très nombreuses et
faciles à trouver sur Internet. Le grand classique est **R for data science**,
de Grolemund et Wickham [-@grolemund2022]. On se focalise ici avec deux
autres qui sont le plus en lien avec nos sujets :

-   [Geocomputation with R, a book on geographic data analysis,visualization and modeling](https://r.geocompx.org/) [@lovelace2022].
-   [Mapme.biodiversity: Efficient Monitoring of Global Biodiversity Portfolios](https://mapme-initiative.github.io/mapme.biodiversity/index.html)
    [@görgen2022]

N'hésitez pas à chercher directement sur le Web en cas de problème. Vous serez souvent conduits vers les forums stackoverflow ou RStudio, qui sont aussi des ressources très précieuses pour résoudre des problèmes très spécifiques.

Pour un apprentissage interactif, vous pouvez également utiliser **ChatGPT**. Cet outil basé sur l'intelligence artificielle s'avère particulièrement utile pour les débutants qui ont besoin de support personnalisé ou pour les utilisateurs avancés comme assistant de programmation pour structurer des chaînes de traitement ou aider avec les problèmes les plus courants. Attention toutefois car il arrive régulièrement à ChatGPT "d'halluciner" des réponses lorsqu'il s'agit de questions très spécifiques.

Pour vous retrouver parmi la multitude de packages existants, il existe une ressource précieuse en ligne : **CRAN Task View** (https://cran.r-project.org/web/views/). Ce registre fournit des recommandations sur les packages présents sur CRAN adaptés à un sujet spécifique.

Il existe également de superbes cheat-sheet ("antisèches") qui récapitulent les principales ressource  :

- https://iqss.github.io/dss-workshops/R/Rintro/base-r-cheat-sheet.pdf
- https://rstudio.github.io/cheatsheets/

### Interface Rstudio

![](figs/R_interface_colored.png)

A : fenêtre script/source B : console C : environnement D : explorateur

La **fenêtre de script** permet d'éditer les fichiers scripts en vue d'éxécuter le code.

La **console** est la fênetre où s'éxécute le code et où on peut directement taper des commandes. Il n'est pas obligatoire de passer par la fenêtre de script.

Le signe "\>" dans votre console est appelé "invite de commande" ou "prompt". C'est le symbole que la console utilise pour indiquer qu'elle est prête à recevoir des commandes ou des instructions de l'utilisateur.
Une fois que vous voyez cet invite, vous pouvez commencer à entrer des commandes en utilisant le langage R. Après avoir entré une commande, vous appuyez sur Entrée pour l'exécuter.

L'**environnement** rassemble des fonctionnalités pour suivre le fonctionnement de R, en faisant notamment apparaître les différents objets générés par notre script.

L'**explorateur** permet de connaître les fichiers de notre ordinateur, de visualiser les rendus graphiques et cartographiqus, les différentes librairies et l'aide pour l'utilisation de ces dernières.

## Introduction au langage R

R est un langage de programmation puissant et flexible, particulièrement adapté pour l'analyse de données et la statistique. Cette section couvre les bases du langage R, en fournissant une introduction aux concepts fondamentaux tels que les objets, les types de données, les fonctions, et les bonnes pratiques de codage. Ce guide est conçu pour vous aider à acquérir les bases nécessaires pour écrire du code efficace et lisible.

### La lisibilité du code

La lisibilité du code est cruciale pour comprendre ce qu'un script fait, surtout après une certaine période ou lorsqu'on travaille en équipe.

- **Espaces autour des opérateurs** : Utilisez des espaces autour des opérateurs pour améliorer la lisibilité.

```{r}
# Mauvaise lisibilité
total<-10+2

# Bonne lisibilité
total <- 10 + 2
```

- **Commentaires clairs** : En R, un commentaire commence par le symbole `#`. Tout ce qui est écrit après `#` sur la même ligne ne sera pas exécuté. Utilisez des commentaires pour expliquer des parties de code complexes ou des étapes importantes.

```{r}
# Calcul du total des deux valeurs
total <- 10 + 2  # Ajout de 10 et 2
```

- **Utilisation des parenthèses** : Pour les expressions complexes, utilisez des parenthèses afin de rendre l'ordre des opérations explicite.

```{r}
# Utilisation des parenthèses pour clarifier l'ordre des opérations
resultat <- (10 + 2) * (5 / 14) - (2 * 2)
```

#### Exercice

- **Améliorer la lisibilité** : Reprenez le code suivant et améliorez sa lisibilité en ajoutant des espaces et des commentaires appropriés.

```{r}
resultat<-5*(3+2)-1
```

### L'assignation (création d'objets)

En R, on utilise `<-` pour assigner une valeur à un objet. Cette assignation permet de créer des variables et de les réutiliser plus tard. L'opérateur `<-` est spécifique à R, mais il est possible d'utiliser `=` dans certains cas. Cependant, `<-` est la convention généralement acceptée en R pour éviter toute ambiguïté.

- **Nommer les objets de manière explicite** : Choisissez des noms explicites pour les objets afin de comprendre leur rôle dans le code.

```{r}
# Assignation d'une valeur
moyenne_hauteur <- 170  # Hauteur moyenne en cm
```

- **Réassignation des valeurs** : Lorsque vous réassignez une valeur à un objet, la valeur précédente est perdue.

```{r}
x <- 2
x <- 5  # La valeur de x est maintenant 5
```

- **Suppression d'un objet** : Pour libérer la mémoire, vous pouvez supprimer un objet avec `rm()`.

```{r}
rm(x)  # Supprime l'objet x
```

#### Exercice

- **Créer et réassigner des objets** : Créez un objet `age` et assignez-lui une valeur, puis modifiez cette valeur. Supprimez ensuite l'objet.

### Les différents types d'objets en R

R utilise différents types d'objets pour stocker des données, chacun ayant ses spécificités.

- **Chaînes de caractères** : Les chaînes de caractères sont délimitées par des guillemets.

```{r}
nom <- "Alice"
print(nom)  # Affiche "Alice"
```

- **Vecteurs** : Les vecteurs sont des objets qui contiennent plusieurs valeurs de même type.

```{r}
# Création d'un vecteur de tailles
tailles <- c(156, 164, 197, 147, 173)
tailles_m <- tailles / 100  # Conversion en mètres
```

Les opérations peuvent être appliquées à l'ensemble des valeurs d'un vecteur.

```{r}
tailles_m + 0.1  # Ajoute 0,1 m à chaque valeur du vecteur
```

#### Exercice

- **Manipuler des vecteurs** : Créez un vecteur de 5 poids en kilogrammes. Convertissez-les en grammes.

### Les tableaux de données (`data.frame`)

Les `data.frame` sont des structures de données très courantes qui permettent de stocker des colonnes de types variés.

- **Création d'un `data.frame`** : Combinez des vecteurs de même longueur pour créer un tableau de données.

```{r}
noms <- c("Alice", "Bob", "Charlie")
ages <- c(25, 30, 35)
tableau <- data.frame(noms, ages)
print(tableau)
```

- **Accéder aux colonnes** : Utilisez `$` pour accéder à une colonne spécifique d'un `data.frame`.

```{r}
tableau$ages  # Accède à la colonne 'ages'
```

#### Exercice

- **Créer un `data.frame`** : Créez un `data.frame` avec des noms, des âges et des tailles, puis affichez uniquement la colonne des tailles.

### Les noms d'objets

Les noms des objets doivent être choisis avec soin pour qu'ils soient compréhensibles et explicites.

- **Convention d'écriture** : Utilisez le `snake_case` pour nommer vos objets (par exemple, `moyenne_age`).
- **Éviter les majuscules et caractères spéciaux** : Les majuscules peuvent prêter à confusion, car R est sensible à la casse.

```{r}
# Mauvaise pratique
T1 <- 100

# Bonne pratique
temperature_moyenne <- 100
```

#### Exercice

- **Nommer des objets** : Créez des objets pour représenter la température et la pression, en respectant les bonnes pratiques de nommage.

### Les fonctions

Les fonctions sont des ensembles d'instructions qui effectuent des tâches spécifiques. Elles permettent de réutiliser du code facilement.

- **Créer une fonction** : Utilisez le mot-clé `function` pour créer une fonction.

```{r}
# Fonction qui additionne deux nombres
addition <- function(x, y) {
  return(x + y)
}

resultat <- addition(3, 4)  # Appel de la fonction
print(resultat)  # Affiche 7
```

- **Fonctions natives et packages** : De nombreuses fonctions sont intégrées à R, et d'autres sont disponibles via des packages additionnels.

```{r}
# Utilisation d'une fonction native
somme <- sum(5, 10)
print(somme)  # Affiche 15
```

#### Exercice

- **Créer une fonction** : Créez une fonction qui calcule le carré d'un nombre et testez-la avec différentes valeurs.

### Les structures de contrôle : `if`, `else`, et les boucles

Les structures de contrôle permettent d'exécuter du code conditionnellement ou de manière répétitive.

- **Conditions avec `if` et `else`** : Les instructions `if` et `else` sont utilisées pour exécuter du code en fonction de conditions.

```{r}
x <- 10
if (x > 5) {
  print("x est supérieur à 5")
} else {
  print("x est inférieur ou égal à 5")
}
```

Dans cet exemple, le message "x est supérieur à 5" sera affiché car la condition `x > 5` est vraie.

- **Boucles `for`** : Les boucles `for` permettent de répéter une série d'instructions un certain nombre de fois.

```{r}
for (i in 1:5) {
  print(paste("Itération :", i))
}
```

Ici, la boucle `for` va exécuter l'instruction `print()` pour chaque valeur de `i` allant de 1 à 5.

#### Exercice

- **Utiliser une boucle `for`** : Créez une boucle qui affiche les carrés des nombres de 1 à 10.

### Les valeurs manquantes

Les valeurs manquantes (`NA`) sont courantes dans les jeux de données réels. Il est essentiel de savoir comment les gérer pour éviter des erreurs.

- **Gérer les valeurs manquantes** : Utilisez `na.rm = TRUE` pour ignorer les `NA` dans des opérations.

```{r}
ages <- c(20, 30, NA, 40)
mean(ages) # Renvoie une valeur manquante 
moyenne_ages <- mean(ages, na.rm = TRUE)
```

## Librairies R

Les librairies R sont communément appelées "packages". Plusieurs packages R sont utilisés pour ce projet. Les packages dans R sont des extensions de logiciels qui ajoutent des fonctionnalités spécifiques au langage R de base.

Ils sont conçus pour faciliter l'analyse de données, la visualisation, la modélisation statistique, et bien plus encore. Les packages sont comme des boîtes à outils virtuelles qui permettent aux utilisateurs d'effectuer des tâches analytiques avancées sans avoir à réinventer la roue à chaque fois. Ils permettent de gagner du temps et de se concentrer sur la résolution de problèmes spécifiques à son domaine d'étude, au lieu de vous soucier de la programmation de fonctions de base.

Lors de la rédaction de publications scientifiques, il est important de citer correctement les packages R utilisés dans votre analyse. Assurez-vous d'inclure le nom complet du package ainsi que le nom de son auteur ou des auteurs. Zotero et RStudio permettent aisément d'inclure ces citations dans votre analyse.

Les autres packages mobilisés pour ce cours sont listés dans le bloc de code ci-dessous :

```{r librairies}
library("tidyverse") # Une série de packages pour faciliter la manipulation de données
library("readxl") # Pour lire les fichiers Excel (Carvalho et al. 2018)
library("gt") # Pour des rendus graphiques harmonisés HTML et PDF/LaTeX
library("wdpar") # Pour télécharger simplement la base d'aires protégées WDPA
```

### Le tidyverse

Le "tidyverse" est un ensemble cohérent de packages R conçus pour la manipulation, la visualisation et l'analyse de données de manière cohérente et efficace. Il a été développé pour simplifier le flux de travail de l'analyse de données et pour rendre le code plus lisible et plus facile à comprendre.

### L'opérateur pipeline

Le signe `%>%` est un "tuyau". On peut le lire à haute voix comme "ensuite". Par exemple :

```{r ex. pipe}
library(tidyverse)

a <- 4
b <- 7
c <- 3

d <- a %>%
  addition(b) %>%
  addition(c)
```

### La préparation des données avec dplyr

Le "tidyverse" comprend plusieurs packages populaires, notamment **dplyr**. Ce dernier est très utile pour épurer les données lorsque vous travaillez sur des tableaux (et donc sur des tables attributaires).

Il est utilisé pour la manipulation de données, notamment le filtrage, la sélection, le regroupement et la création de nouvelles variables.

```{r ex.tidyverse}
# On commence par créer les variables (les colonnes du tableau)
noms <- c("John", "Jack", "Cindy", "Samantha")
sexe <- c("homme", "homme", "femme", "femme")
ages <- c(42, 57, 24, NA)
poids <- c(87, 73, NA, NA)
tailles <- c(174, 198, 192, 164)

# On les rassemble dans un tableau 
ma_table <- data.frame(noms, sexe, ages, poids, tailles)

ma_table


# Un exemple qui combine ces opérations
ma_table %>%
  filter(!is.na(ages))

ma_table %>%
  filter(!is.na(ages)) %>%
  select(sexe, ages, tailles, poids)

ma_table %>%
  filter(!is.na(ages)) %>%
  select(sexe, ages, tailles, poids) %>%
  group_by(sexe) %>%
  summarise(nb_pers = n())

ma_table %>%
  filter(!is.na(ages)) %>%
  select(sexe, ages, tailles, poids) %>%
  group_by(sexe) %>%
  summarise(nb_pers = n(),
            somme_poids = sum(poids, na.rm = TRUE),
            taille_max = max(tailles, na.rm = TRUE),
            age_moy = mean(ages, na.rm = TRUE))
```

Voici certaines des fonctions fondamentales de dplyr :
- `select` : choisir des colonnes
- `filter` : choisir des lignes
- `mutate` : modifier des valeurs
- `group_by` : regrouper les données par une ou plusieurs variables
- `summarise` : créer des résumés sur les données

> **Exercice en groupe** : à partir du tableau `ventes_magasin`, utilisez les fonctions précédentes et l'opérateur pipe pour réaliser les opérations suivantes :
>
> 1. Sélectionnez uniquement les colonnes `produit`, `quantite`, et `prix_unitaire` du data frame `ventes_magasin`.
> 2. Ne conservez que les ventes où la quantité vendue est supérieure à 5 unités.
> 3. Ajoutez une nouvelle colonne nommée `montant` qui représente le montant total de chaque vente (quantité multipliée par le prix unitaire) et ajoutez-la au data frame.
> 4. Créez un nouveau tableau `ventes_par_produit`, regroupez les données par `produit` pour calculer la quantité totale vendue de chaque produit.
> 5. Complétez ce tableau avec le montant total et le nombre de ventes.

```{r}
# Création du data frame ventes_magasin
ventes_magasin <- data.frame(
  produit = c("Produit A", "Produit B", "Produit A", "Produit C", "Produit B",
              "Produit A", "Produit C", "Produit B", "Produit A"),
  quantite = c(8, 4, 12, 6, 7, 9, 3, 11, 5),
  prix_unitaire = c(10, 15, 8, 12, 20, 10, 18, 14, 9),
  date_vente = ymd( # Cette fonction interprète des dates year-month-day
    c("2023-01-05", "2023-01-08", "2023-01-09", "2023-01-10", "2023-01-15",
      "2023-01-20", "2023-01-25", "2023-01-30", "2023-02-02"))
  )
```

### Les jointures

Les jointures permettent de fusionner deux tableaux par une variable d'identification ("clé").

```{r ex. jointure}
# Tableau clients
clients <- data.frame(ID = c(1, 2, 3, 4),
                      nom_client = c("Alice", "Bob", "Charlie", "David"))

# Tableau commandes
commandes <- data.frame(ID = c(2, 3, 1, 4),
                        montant = c(100, 150, 50, 200))

# Jointure par ID
resultat <- inner_join(clients, commandes, by = "ID")
```

Cette opération exige toutefois que la **variable d'identification soit écrite de manière identique** dans les deux jeux de données.

Supposons que l'on travaille sur les aires protégées à Madagascar et que l'on dispose de deux jeux de données provenant de sources différentes. On a alors des informations complémentaires que l'on souhaite fusionner en un seul tableau via le nom de l'aire protégée.

Il faudra veiller à ce que les noms aient la même écriture (pas de différences avec des majuscules, des abréviations ou des noms raccourcis).

## Import de données

Pour cette section, nous allons développer l'importation de différents types de fichiers couramment utilisés dans R pour la manipulation et l'analyse de données. R permet d'importer et de manipuler divers formats de fichiers, notamment CSV, Excel et fichiers texte.

### Utilisation du menu interactif de RStudio

Avant de passer à l'importation via du code, il est recommandé de se familiariser avec le menu interactif de RStudio pour importer des fichiers.

- Pour importer un fichier, allez dans le panneau Files en bas à droite de l'interface RStudio.
- Naviguez vers le fichier `data/AP_Vahatra.csv`, faites un clic droit et sélectionnez Import Dataset.
- Un assistant d'import s'ouvrira, vous permettant de vérifier les données et de définir les options d'importation (séparateur, types de colonnes, etc.).
- Une fois satisfait, cliquez sur Import et examinez le code automatiquement généré par RStudio. Ce code pourra être utilisé et modifié par la suite pour automatiser l'importation des données.

### Types de fichiers et comment les importer en ligne de code

1. Fichiers CSV : Les fichiers CSV sont très populaires pour leur simplicité. Pour importer un fichier CSV, vous pouvez utiliser la fonction read.csv() ou read_csv() (package readr, partie du tidyverse).

```{r import csv}
library(readr)

AP_Vahatra <- read_csv("data/AP_Vahatra.csv")
```

**2. Fichiers Excel** : Pour importer des fichiers Excel, on peut utiliser le package readxl. La fonction read_xlsx() permet d'importer un fichier au format .xlsx.

```{r ex_excel, eval=FALSE}
library(readxl)

Mon_objet_R <- read_xlsx("data/mon_fichier.xlsx")
```

**3. Fichiers texte** : Les fichiers texte peuvent être importés avec read.table() ou read_delim() (pour des délimiteurs personnalisés).

```{r ex_read_delim, eval = FALSE}
AP_Vahatra <- read_delim("data/mon_fichier.txt", delim = "\t")
```


### Exercice pratique

Pour vous familiariser avec ces différents formats, voici un petit exercice :

1. Importez un fichier CSV présent dans le dossier `data`. Le fichier s'appelle `AP_Vahatra.csv`. Utilisez read_csv() pour l'importer dans un objet R.
2. Importez un fichier Excel présent dans le dossier `data`. Le fichier s'appelle `AP_Vahatra.xlsx`. Utilisez read_xlsx() pour l'importer dans un objet R.
3. Importez un fichier texte présent dans le dossier `data`. Le fichier s'appelle  `AP_Vahatra.txt`. Utilisez read_delim() pour l'importer dans un objet R.
4. Affichez les premières lignes avec la fonction `head()` des jeux de données pour vérifier l'importation correcte.

## Exploration des données importées

Nous allons maintenant explorer le contenu d'`AP_Vahatra`.

- Afficher les noms des colonnes :
```{r}
colnames(AP_Vahatra)
```


- Sélectionner les 10 premières aires protégées et leur catégorie IUCN :

```{r}
AP_Vahatra %>%
  select(nom, cat_iucn) %>%
  filter(row_number() <= 10)
```


- Explorer les dates de création et de modification :

```{r}
AP_Vahatra %>%
  select(nom, date_creation, date_modification) %>%
  filter(!is.na(date_creation)) %>%
  arrange(date_creation)
```

- Calculer la superficie totale des aires protégées :

```{r}
AP_Vahatra %>%
  summarise(superficie_totale = sum(hectares, na.rm = TRUE))
```

- Lister les aires protégées gérées par "Madagascar National Parks" :

```{r}
AP_Vahatra %>%
  filter(gest_1 == "Madagascar National Parks") %>%
  select(nom, gest_1)
```

- Obtenir des statistiques descriptives sur la superficie des aires protégées :

```{r}
AP_Vahatra %>%
  summarise(superficie_moyenne = mean(hectares, na.rm = TRUE),
            superficie_mediane = median(hectares, na.rm = TRUE),
            superficie_max = max(hectares, na.rm = TRUE),
            superficie_min = min(hectares, na.rm = TRUE))
```


### Exercice supplémentaire

Pour cet exercice, utilisez les données AP_Vahatra que vous avez importées pour produire les statistiques suivantes :

1. Filtrez les aires protégées dont la catégorie IUCN est "II" et affichez uniquement leurs noms.
2. Ajoutez une colonne superficie_km2 à AP_Vahatra en convertissant la valeur hectares en kilomètres carrés.
3. Triez les données par superficie_km2 de manière décroissante.
4. Trouvez le nom des 3 plus grandes aires protégées 
5. Calculez la superficie totale de toutes les aires protégées
6. Produisez un résumé statistique (summary()) des valeurs de superficie_km2.
7. Filtrez les aires protégées ayant une superficie supérieure ou égale au 3ème quartile et calculez leur nombre.



## Production de tableaux avec R

La fonction `gt()` permet d'obtenir des tableaux bien formatés, idéals pour présenter des résultats de manière claire et esthétique. Elle est particulièrement utile pour la création de rapports et la présentation de données tabulaires de manière attrayante. Voici quelques-unes des fonctions essentielles de `gt` :

- **`cols_label()`** : Cette fonction permet de renommer les colonnes pour leur donner des titres plus explicites.
- **`tab_header()`** : Elle permet d'ajouter un titre et un sous-titre au tableau, facilitant ainsi la compréhension de ce que le tableau représente.
- **`fmt_number()`** : Cette fonction permet de formater les nombres, par exemple en définissant le nombre de décimales.
- **`tab_source_note()`** : Elle permet d'ajouter une note de source au tableau, indiquant d'où proviennent les données.

### Exemple d'utilisation de `gt`

Voici un exemple d'utilisation de `gt` pour résumer les superficies des aires protégées par catégorie IUCN.

```{r}
# On va dabord convertir les superficies en hectares dans une nouvelle colonne
AP_Vahatra <- AP_Vahatra %>%
  mutate(superficie_km2 = hectares * 0.01)


# Calcul des superficies totales pour chaque catégorie IUCN
AP_Vahatra_iucn <- AP_Vahatra %>%
  mutate(superficie_km2 = hectares * 0.01) %>%
  filter(!is.na(cat_iucn)) %>%
  group_by(cat_iucn) %>%
  summarise(superficie_totale = sum(superficie_km2))

# Production du tableau
AP_Vahatra_iucn %>%
  gt() %>%
  cols_label(cat_iucn = "Catégorie IUCN",
             superficie_totale = "Superficie totale (km²)") %>%
  tab_header(
    title = "Aires protégées de Madagascar : superficies par catégorie IUCN") %>%
  tab_source_note("Source : données de l'association Vahatra") %>%
  fmt_number(decimals = 2)
```

### Superficie cumulée par année de création

Avant de créer un graphique en nuages de points, nous devons préparer un tableau qui résume la superficie cumulée des aires protégées en fonction de leur année de création.

```{r}
AP_superficie_annees <- AP_Vahatra %>%
  group_by(an_creation) %>%
  summarise(superficie_annuelle = sum(superficie_km2, na.rm = TRUE)) %>%
  arrange(an_creation) %>%
  mutate(superficie_cumulée = cumsum(superficie_annuelle))
```

### Exercice : Créer un tableau synthétique

1. **Résumer la superficie cumulée par année de création** : Utilisez `gt()` pour présenter les résultats de `AP_superficie_annees` de manière claire et lisible.

2. **Ajouter des colonnes d’explication** : Créez des colonnes qui expliquent chaque étape du processus (par exemple, année de création, superficie annuelle ajoutée, superficie cumulée).

3. **Ajouter un titre et une note de source** : Le tableau devrait inclure un titre explicite et une note de source, similaire à l’exemple précédent.

Ces étapes vous aideront à présenter les données de manière élégante et à faciliter la compréhension des tendances liées à la création des aires protégées.



## Production de graphiques avec ggplot2

Pour produire des graphiques de qualité avec R, nous utilisons souvent le package `ggplot2`. Ce package repose sur une approche appelée "la grammaire des graphiques". Cette grammaire est une façon systématique de construire des visualisations, en combinant différents composants graphiques, comme des axes, des légendes, des points, des lignes, etc. Elle offre une grande flexibilité et permet de créer des graphiques complexes de manière progressive.

### Philosophie de la "grammaire des graphiques"

La grammaire des graphiques est une méthode de pensée pour créer des visualisations. Elle repose sur l'idée que tout graphique peut être décomposé en une série de couches. Par exemple :

1. **Données** : La première étape consiste à spécifier les données à utiliser pour le graphique.
2. **Aesthetic mappings (Mappings esthétiques)** : Cela consiste à indiquer comment les variables des données seront représentées visuellement, par exemple, quel axe représente quelle variable, ou quelles couleurs représentent quelles catégories.
3. **Geometries (Géométries)** : Chaque graphique est composé de formes géométriques, comme des points, des lignes, des barres, etc. Ces géométries déterminent la manière dont les données seront visualisées.
4. **Facettes** : Cette étape permet de subdiviser le graphique en plusieurs sous-graphiques basés sur une variable, facilitant ainsi la comparaison entre catégories.
5. **Statistiques** : Certaines visualisations nécessitent des transformations statistiques, comme l'ajout de moyennes, de tendances ou d'intervalles de confiance.
6. **Coordonnées** : Il s'agit de définir les systèmes de coordonnées, tels que les axes cartésiens ou polaires.
7. **Thème** : Enfin, le thème est utilisé pour définir l'apparence générale du graphique, par exemple, les couleurs de fond, la taille des polices, etc.

En combinant ces différentes couches, `ggplot2` permet de construire des visualisations claires et personnalisées, adaptées aux besoins spécifiques de l'analyse.

### Introduction à ggplot2

Le package `ggplot2` suit cette logique en permettant d'ajouter chaque composant graphique avec le signe `+`. Voici une approche progressive pour comprendre `ggplot2` :

1. **Importer le package et les données** :

```{r}
library(ggplot2)
# On suppose que AP_superficie_annees est déjà créé
```

2. **Créer la base du graphique** :

La première étape consiste à spécifier les données et les mappings esthétiques. Par exemple, nous allons indiquer que l'axe des abscisses (`x`) représente l'année de création (`an_creation`) et l'axe des ordonnées (`y`) représente la superficie cumulée (`superficie_cumulée`).

```{r}
ggplot(data = AP_superficie_annees, aes(x = an_creation, y = superficie_cumulée))
```

3. **Ajouter des géométries** :

Pour visualiser les données, nous ajoutons des points (`geom_point()`) et des lignes (`geom_line()`).

```{r}
ggplot(data = AP_superficie_annees, aes(x = an_creation, y = superficie_cumulée)) +
  geom_point() +
  geom_line()
```

4. **Ajouter des labels** :

Pour rendre le graphique plus compréhensible, nous ajoutons des labels pour les axes et un titre.

```{r}
ggplot(data = AP_superficie_annees, aes(x = an_creation, y = superficie_cumulée)) +
  geom_point() +
  geom_line() +
  labs(x = "Année", y = "Superficie cumulée (km²)",
       title = "Superficie cumulée en fonction de l'année de création")
```

5. **Appliquer un thème** :

Le thème permet de personnaliser l'apparence générale du graphique. Ici, nous utilisons `theme_minimal()` pour une apparence épurée.

```{r}
ggplot(data = AP_superficie_annees, aes(x = an_creation, y = superficie_cumulée)) +
  geom_point() +
  geom_line() +
  labs(x = "Année", y = "Superficie cumulée (km²)",
       title = "Superficie cumulée en fonction de l'année de création") +
  theme_minimal()
```

### Exercice : Créer un graphique avec ggplot2

1. **Créer un graphique en nuages de points** : Utilisez `ggplot2` pour créer un graphique qui montre la superficie annuelle des aires protégées en fonction de leur année de création.

2. **Ajouter des lignes de tendance** : Ajoutez une ligne de tendance (`geom_smooth()`) pour montrer l'évolution générale de la superficie annuelle au fil du temps.

3. **Facetter par catégorie IUCN** : Utilisez `facet_wrap()` pour créer des sous-graphiques qui montrent la superficie cumulée par année de création pour chaque catégorie IUCN.

Ces étapes vous permettront de comprendre progressivement comment construire des graphiques en utilisant la grammaire des graphiques, et d'explorer différentes façons de visualiser vos données.