# Installation de la suite de packages du Tidyverse (Il est surement déjà installé chez vous !)
install.packages("tidyverse")Formation R - Module 4 : Découverte du Tidyverse
Introduction
Bienvenue dans le Module 4 de notre formation R, où nous explorerons le monde du Tidyverse. Le Tidyverse est une collection de packages R conçus pour rendre l’analyse de données plus efficace, intuitive et esthétique. Dans ce module, nous allons nous plonger dans les bases du Tidyverse et apprendre à manipuler, transformer et visualiser des données de manière élégante.
I - Qu’est-ce que le Tidyverse ?
Le Tidyverse est un ensemble de packages R développés par Hadley Wickham et d’autres membres de la communauté R. Il est basé sur une philosophie de travail avec des données d’une manière “tidy”, c’est-à-dire organisée et cohérente. Les principaux packages du Tidyverse incluent ggplot2 pour la visualisation, dplyr pour la manipulation de données, tidyr pour le nettoyage et la transformation des données, et bien d’autres encore. La syntaxe des fonctions du tidyverse est claire et cohérente, mais celui-ci nécessite des données bien rangées, ordonnées (tidy). C’est à dire :
Chaque variable est une colonne ; chaque colonne est une variable.
Chaque observation est une ligne ; chaque ligne est une observation.
Chaque valeur est une cellule ; chaque cellule est une seule valeur.
La première valeur d’une colonne est le nom de la variable.
Tout jeu de données qui ne suit pas ces règles est qualifié communément de “messy data”. Mais ne vous en faites pas, on peux y remédier facilement avec R.
II - Pourquoi utiliser le Tidyverse ?
Le Tidyverse offre plusieurs avantages pour les analystes de données :
1. Cohérence et simplicité : Les packages du Tidyverse sont conçus pour fonctionner ensemble de manière harmonieuse, ce qui rend l’analyse de données plus fluide et intuitive.
2. Syntaxe verbale : Les fonctions du Tidyverse sont nommées de manière descriptive, ce qui rend le code plus facile à comprendre pour les débutants et les experts.
3. Visualisation élégante : Avec ggplot2, vous pouvez créer des graphiques de qualité publication avec relativement peu de code.
4. Manipulation efficace des données : Les packages comme dplyr et tidyr offrent des outils puissants pour filtrer, trier, agréger et nettoyer les données de manière efficace.
III - Installation et chargement du Tidyverse
Pour commencer à utiliser la suite de packages du Tidyverse, vous devez d’abord l’installer et le charger dans votre environnement R. Voici comment procéder :
On le rappelle : Tout script commence par le chargement des packages nécessaires. C’est une convention, c’est comme ça !
# Chargement du Tidyverse et d'autres packages nécessaires ...
library(tidyverse)── Attaching core tidyverse packages ──────────────────────── tidyverse 2.0.0 ──
✔ dplyr 1.1.4 ✔ readr 2.1.5
✔ forcats 1.0.0 ✔ stringr 1.5.1
✔ ggplot2 3.5.1 ✔ tibble 3.2.1
✔ lubridate 1.9.3 ✔ tidyr 1.3.1
✔ purrr 1.0.2
── Conflicts ────────────────────────────────────────── tidyverse_conflicts() ──
✖ dplyr::filter() masks stats::filter()
✖ dplyr::lag() masks stats::lag()
ℹ Use the conflicted package (<http://conflicted.r-lib.org/>) to force all conflicts to become errorslibrary(here)here() starts at D:/utils/noe.barthelemy/Bureau/Formation_R_Quarto/01_codeIV - Principaux packages du Tidyverse
Voici un aperçu des packages les plus couramment utilisés du Tidyverse :
1. ggplot2 : Utilisé pour créer des graphiques esthétiques et hautement personnalisables. Difficile à maîtriser, mais indispensable.
2. dplyr : Pour la manipulation efficace des données, y compris le filtrage, le tri et l’agrégation. LA BASE.
3. tidyr : Utile pour le nettoyage et la transformation des données en suivant les principes de la “tidy data”.
4. readr : Pour l’importation de données à partir de divers formats de fichiers, tels que CSV, Excel, etc.
5. purrr : Offre des outils pour travailler avec des fonctions et des vecteurs de manière plus efficace.
6. stringr : Pour la manipulation de chaînes de caractères.
V - Exemple de manipulation de données avec le Tidyverse
Voici un exemple simple de manipulation de données utilisant les packages du Tidyverse. Nous allons ici nous baser sur les données du RP extraites dans “Formation R - Module 2 : Analyse du RP”. Le jeu de données sera “RP2019NC_OD_ind_3Provinces”. Soyez bien sûr(e) de l’avoir chargé dans votre environnement Rstudio.
RP2019NC_OD_ind_Iles <- readr::read_delim(here("..", "02_donnees", "RP2019NC_OD_ind_Iles.csv"),
delim = ";", escape_double = FALSE, trim_ws = TRUE)
RP2019NC_OD_ind_Nord <- readr::read_delim(here("..", "02_donnees", "RP2019NC_OD_ind_Nord.csv"),
delim = ";", escape_double = FALSE, trim_ws = TRUE)
RP2019NC_OD_ind_Sud1 <- readr::read_delim(here("..", "02_donnees", "RP2019NC_OD_ind_Sud1.csv"),
delim = ";", escape_double = FALSE, trim_ws = TRUE)
RP2019NC_OD_ind_Sud2 <- readr::read_delim(here("..", "02_donnees", "RP2019NC_OD_ind_Sud2.csv"),
delim = ";", escape_double = FALSE, trim_ws = TRUE)
RP2019NC_OD_ind_3Provinces <- rbind(RP2019NC_OD_ind_Iles, RP2019NC_OD_ind_Nord, RP2019NC_OD_ind_Sud1, RP2019NC_OD_ind_Sud2)Exploration des données
Ok, jettons-y un coup d’oeil avec la fonction “View”.
View(RP2019NC_OD_ind_3Provinces)Je crée un nouveau chunk ci-dessous pour obtenir un résumé du contenu de notre jeu de données. Bien sur, la page @Jeu_de_donnees_RP2019.qmd décrit déjà le jeu de données et contient même le dictionnaire des variables.
paste("Nombre de colonnes :", ncol(RP2019NC_OD_ind_3Provinces))[1] "Nombre de colonnes : 43"paste("Nombre de lignes :", nrow(RP2019NC_OD_ind_3Provinces))[1] "Nombre de lignes : 271407"paste("Variable :", colnames(RP2019NC_OD_ind_3Provinces)) [1] "Variable : ID" "Variable : IDLOG" "Variable : AGEA"
[4] "Variable : AGER" "Variable : ANNINS" "Variable : APE"
[7] "Variable : CNAT" "Variable : COUPLE" "Variable : CPAYSN"
[10] "Variable : CPAYSRA" "Variable : CS24" "Variable : CS42"
[13] "Variable : CS8" "Variable : CSSAL" "Variable : DIPL"
[16] "Variable : EMPL" "Variable : EXER" "Variable : GAD"
[19] "Variable : GAQ" "Variable : GENRE" "Variable : ILN"
[22] "Variable : IRA" "Variable : MINE" "Variable : NAT"
[25] "Variable : PROV" "Variable : PROVRA" "Variable : PROVTRA"
[28] "Variable : RECH" "Variable : SAL" "Variable : SCOL"
[31] "Variable : SECT10" "Variable : SECT21" "Variable : SECT5"
[34] "Variable : STAT" "Variable : STATANT" "Variable : STM"
[37] "Variable : TACT" "Variable : TP" "Variable : TRAANT"
[40] "Variable : TRANS" "Variable : TYP" "Variable : TYPEMPL"
[43] "Variable : TYPMENR"Avec la fonction slice, on peut sélectionner certaines parties du jeu de données.
Pour obtenir la 20ème ligne tu tableau :
slice(RP2019NC_OD_ind_3Provinces, 20)# A tibble: 1 × 43
ID IDLOG AGEA AGER ANNINS APE CNAT COUPLE CPAYSN CPAYSRA CS24 CS42
<dbl> <dbl> <dbl> <dbl> <dbl> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
1 330 180 9 9 NA <NA> NA NA NA NA NA NA
# ℹ 31 more variables: CS8 <dbl>, CSSAL <dbl>, DIPL <chr>, EMPL <dbl>,
# EXER <dbl>, GAD <dbl>, GAQ <dbl>, GENRE <dbl>, ILN <dbl>, IRA <dbl>,
# MINE <dbl>, NAT <dbl>, PROV <chr>, PROVRA <chr>, PROVTRA <chr>, RECH <dbl>,
# SAL <dbl>, SCOL <dbl>, SECT10 <chr>, SECT21 <chr>, SECT5 <dbl>, STAT <dbl>,
# STATANT <dbl>, STM <dbl>, TACT <dbl>, TP <dbl>, TRAANT <dbl>, TRANS <dbl>,
# TYP <dbl>, TYPEMPL <dbl>, TYPMENR <dbl>Pour obtenir les lignes 30 à 40 tu tableau :
slice(RP2019NC_OD_ind_3Provinces, 30:40)# A tibble: 11 × 43
ID IDLOG AGEA AGER ANNINS APE CNAT COUPLE CPAYSN CPAYSRA CS24 CS42
<dbl> <dbl> <dbl> <dbl> <dbl> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
1 472 63718 9 9 NA <NA> NA NA NA NA NA NA
2 514 67224 84 84 NA <NA> NA 1 NA NA NA NA
3 549 19695 33 32 NA 8411Z NA 1 NA NA 51 52
4 556 98336 16 16 NA <NA> NA 2 NA NA NA NA
5 560 61932 25 25 NA 8413Z NA 1 NA NA 66 68
6 569 91976 83 83 NA <NA> NA 1 NA NA NA NA
7 574 14269 5 4 NA <NA> NA NA NA NA NA NA
8 575 39159 0 0 NA <NA> NA NA NA NA NA NA
9 603 55110 75 75 NA <NA> NA 2 NA NA NA NA
10 613 31904 63 63 NA <NA> NA 2 NA NA NA NA
11 650 35575 45 45 NA <NA> NA 1 NA NA 55 55
# ℹ 31 more variables: CS8 <dbl>, CSSAL <dbl>, DIPL <chr>, EMPL <dbl>,
# EXER <dbl>, GAD <dbl>, GAQ <dbl>, GENRE <dbl>, ILN <dbl>, IRA <dbl>,
# MINE <dbl>, NAT <dbl>, PROV <chr>, PROVRA <chr>, PROVTRA <chr>, RECH <dbl>,
# SAL <dbl>, SCOL <dbl>, SECT10 <chr>, SECT21 <chr>, SECT5 <dbl>, STAT <dbl>,
# STATANT <dbl>, STM <dbl>, TACT <dbl>, TP <dbl>, TRAANT <dbl>, TRANS <dbl>,
# TYP <dbl>, TYPEMPL <dbl>, TYPMENR <dbl>Mais attention, slice est versatile ! Voici ses variantes :
slice_headpour sélectionner les premières lignes.slice_tailpour sélectionner les dernières lignes.slice_maxpour sélectionner les valeurs les plus hautes.slice_minpour sélectionner les valeurs les plus basses.slice_samplepour sélectionner des lignes aléatoires !
On spécifie le nombre de lignes souhaitées avec n, ou la proportion avec prop. Dans le cas de slice_max et slice_min , on doit spécifier order_by .
Par exemple, pour sélectionner les 30% les plus vieux parmi nos individus :
slice_max(RP2019NC_OD_ind_3Provinces, order_by = AGEA , prop = 0.3)# A tibble: 85,135 × 43
ID IDLOG AGEA AGER ANNINS APE CNAT COUPLE CPAYSN CPAYSRA CS24 CS42
<dbl> <dbl> <dbl> <dbl> <dbl> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
1 119998 80059 104 104 NA <NA> NA 1 NA NA NA NA
2 136932 NA 103 103 1970 <NA> NA 2 NA NA NA NA
3 122456 NA 102 102 NA <NA> NA 2 NA NA NA NA
4 20728 27351 101 101 1983 <NA> NA 2 NA NA NA NA
5 82141 70463 101 100 NA <NA> NA 2 NA NA NA NA
6 142806 70272 101 101 1983 <NA> NA 2 NA NA NA NA
7 2849 8106 100 100 NA <NA> NA 2 NA NA NA NA
8 43639 NA 100 99 NA <NA> NA 2 NA NA NA NA
9 111260 66022 100 100 NA <NA> NA 2 NA NA NA NA
10 162898 41063 100 100 NA <NA> NA 2 NA NA NA NA
# ℹ 85,125 more rows
# ℹ 31 more variables: CS8 <dbl>, CSSAL <dbl>, DIPL <chr>, EMPL <dbl>,
# EXER <dbl>, GAD <dbl>, GAQ <dbl>, GENRE <dbl>, ILN <dbl>, IRA <dbl>,
# MINE <dbl>, NAT <dbl>, PROV <chr>, PROVRA <chr>, PROVTRA <chr>, RECH <dbl>,
# SAL <dbl>, SCOL <dbl>, SECT10 <chr>, SECT21 <chr>, SECT5 <dbl>, STAT <dbl>,
# STATANT <dbl>, STM <dbl>, TACT <dbl>, TP <dbl>, TRAANT <dbl>, TRANS <dbl>,
# TYP <dbl>, TYPEMPL <dbl>, TYPMENR <dbl>Maintenant, profitons en pour tester un maximum de fonctions communément utilisées par les utilisateurs de R, à commencer par celles du package dplyr. dplyr est une grammaire de manipulation de données, fournissant un ensemble cohérent de verbes qui vous aident à résoudre les défis de manipulation de données les plus courants :
filter() sélectionne des cas en fonction de leurs valeurs.
select() sélectionne des variables en fonction de leurs noms.
mutate() ajoute de nouvelles variables qui sont des fonctions de variables existantes
arrange() change l’ordre des lignes.
summarise(), count() et d’autres travaillent de concert pour résumer les données.
Tous ces éléments se combinent naturellement avec group_by(), qui vous permet d’effectuer toute opération “par groupe”.
V.1) Enchaîner les opérations avec le pipe
Quand vous manipulerez vos données, vous serez amenés à réaliser plusieurs opérations à la suite. Par exemple, lors d’un nettoyage de données, on va filtrer les données manquantes avec filter, puis on va renommer une variable avec rename, avant de finir par un select pour éliminer des variables inutiles.
R est très flexible, et il existe au moins 3 manières d’enchaîner ces actions :
Méthode 1 : “A l’ancienne”
Ici, on va enchaîner les actions en créant à chaque fois une copie de l’objet qu’on souhaite transformer.
Donnees1 <- filter(.data = RP2019NC_OD_ind_3Provinces, !is.na(AGEA)) # Filtrer les lignes avec des données manquantes dans la variable AGEA. On indique le tableau cible avec ".data =".
Donnees2 <- rename(.data = Donnees1, Age = AGEA) # Rennomer AGEA en Age
Donnees3 <- select(.data = Donnees2, ID, Age ) # Sélectionner les variables ID et Age.
head(Donnees3)# A tibble: 6 × 2
ID Age
<dbl> <dbl>
1 14 34
2 19 13
3 82 1
4 86 1
5 99 17
6 106 54Ca fait le job, l’ordre des opérations est respecté et c’est correctement lisible. En revanche, on crée des tableaux intermédiaires dont on se serait bien passé, et qui contribuent à rendre le code très long à lire ! De plus, on doit spécifier les données sources à chaque opération …
Méthode 2 : “Compact”
Une autre méthode est de compacter les opérations en les emboîtant.
Donnees4 <- select(rename(filter(RP2019NC_OD_ind_3Provinces, !is.na(AGEA)), Age = AGEA), ID, Age)
head(Donnees4)# A tibble: 6 × 2
ID Age
<dbl> <dbl>
1 14 34
2 19 13
3 82 1
4 86 1
5 99 17
6 106 54Cette méthode peut paraître intuitive pour certains, mais c’est une très mauvaise méthode. Certes, on ne crée pas autant d’objets intermédiaires comme avec la première méthode, mais c’est ILLISIBLE ! De plus, les opérations apparaissent dans l’ordre inverse de leur réalisation. Ici on effectue d’abord le filter, puis le rename, puis le select, alors qu’à la lecture du code c’est le select qui apparaît en premier.
A bannir donc.
Méthode 3 : Avec le Tidyverse !
Avec le tidyverse, on utilise le plus souvent le pipe (%>%, inséré avec ctrl+Maj+M). Le pipe, pour “tuyau” en anglais, est un opérateur qui passe ce qui est à sa gauche vers ce qui est à sa droite, à la manière d’un tuyau ! Plus formellement, le code à gauche du pipe sera executé, puis utilisé comme objet cible par le code qui se situe à droite du pipe, jusqu’à ce qu’on aie été au bout des opérations.
Donnees5 <- RP2019NC_OD_ind_3Provinces %>%
filter(!is.na(AGEA)) %>%
rename(Age = AGEA) %>%
select(ID, Age)
head(Donnees5)# A tibble: 6 × 2
ID Age
<dbl> <dbl>
1 14 34
2 19 13
3 82 1
4 86 1
5 99 17
6 106 54Le code de la méthode 1 et 2 et celui de la méthode 3 renverront donc le même résultat, et seront executés de la même manière. En revanche, le dernier est bien plus lisible, ce qui, dans un script de 5 000 lignes, croyez-moi, n’est pas du tout un détail !
Utilisez le pipe !!!
V.2) Filter
Filtrer les données, c’est important. Rien de plus facile avec filter !
# Trois remarques, valables TOUT LE TEMPS :
# 1) Je n'opère pas directement filter sur notre jeu de données de départ, mais j'en crée une copie sur laquelle j'effectue mon opération. Ceci est fait avec l'opérateur d'assignation " <- ".
# 2) Le nom de notre 'copie' est différent du nom de l'original ! Cela évite de le remplacer, et permet de garder une séquence logique dans les opérations. Ici je l'appelle "V2". Faites le aussi ou vous aurez des problèmes ...
# 3) J'utilise l'opérateur "%>%" AKA le 'pipe' (pour tuyau en anglais), pour "tuyauter" l'opération vers le jeu de données. Pensez y comme si il voulait dire "et puis" :
RP2019NC_OD_ind_3Provinces_V2 <- RP2019NC_OD_ind_3Provinces %>% # Je crée une copie avec un nouveau nom ET PUIS (%>%) ...
filter(., AGEA > 0) %>% # ... je filtre les individus qui ont plus de 0 ans, le reste disparais, ET PUIS ...
filter(., DIPL == 14 & CPAYSN == 514) # je filtre les personnes ayant le Bac général (DIPL == 14) qui sont nés en NC (CPAYSN == 514).On peut également placer des fonctions dans un filter, ce qui nous permet par exemple de filtrer les individus ayant un âge supérieur à la moyenne :
#Remarquez que je crée à nouveau une nouvelle version. Idéalement, j'aurais ajouté ce filter à la suite du précédent afin de rendre le code plus compact.
RP2019NC_OD_ind_3Provinces_V2_BIS <- RP2019NC_OD_ind_3Provinces_V2 %>%
filter(., AGEA > mean(AGEA)) # 'mean' est la fonction pour calculer une moyenne. tapez ?mean dans la console pour en savoir plus.Combien de personnes à on perdu ?
# Calculons la différence dans le nombre de lignes dans chaque versions.
nrow(RP2019NC_OD_ind_3Provinces_V2) - nrow(RP2019NC_OD_ind_3Provinces_V2_BIS)[1] 123V.3) Select et rename
select() permet de sélectionner (hé oui!) des colonnes dans un tableau. Allons-y ! Sélectionnons les variables en lien avec l’âge et le type d’activité professionnelle.
RP2019NC_OD_ind_3Provinces_V2_reduit <- RP2019NC_OD_ind_3Provinces_V2 %>% # Je prend la version 2 pour garder tous les individus.
select(., TRANS, AGEA, SECT10, SECT21, SECT5, STAT, STATANT, TACT)Nous avons bien séléctionné nos variables, la preuve avec head() :
head(RP2019NC_OD_ind_3Provinces_V2_reduit)# A tibble: 6 × 8
TRANS AGEA SECT10 SECT21 SECT5 STAT STATANT TACT
<dbl> <dbl> <chr> <chr> <dbl> <dbl> <dbl> <dbl>
1 4 26 BE C 2 3 NA 1
2 1 24 MN M 4 3 NA 2
3 1 54 OQ O 5 3 NA 1
4 4 44 OQ O 5 3 NA 1
5 4 44 OQ O 5 3 NA 1
6 4 46 <NA> <NA> NA NA 1 6Tiens, j’ai sélectionné la variable TRANS (Mode de transport) par mégarde. Je vais m’en débarasser en ajoutant un “-” devant cette variable dans mon prochain select :
RP2019NC_OD_ind_3Provinces_V2_reduit_V2 <- RP2019NC_OD_ind_3Provinces_V2_reduit %>%
select(., - TRANS)
head(RP2019NC_OD_ind_3Provinces_V2_reduit_V2)# A tibble: 6 × 7
AGEA SECT10 SECT21 SECT5 STAT STATANT TACT
<dbl> <chr> <chr> <dbl> <dbl> <dbl> <dbl>
1 26 BE C 2 3 NA 1
2 24 MN M 4 3 NA 2
3 54 OQ O 5 3 NA 1
4 44 OQ O 5 3 NA 1
5 44 OQ O 5 3 NA 1
6 46 <NA> <NA> NA NA 1 6La colonne est éliminée au lieu d’être sélectionnée !
Comme expliqué dans l’excellent cours de J. Barnier sur dplyr, select comprend toute une série de fonctions facilitant la sélection de colonnes multiples. Par exemple, starts_with, ends_width, contains ou matches permettent d’exprimer des conditions sur les noms de variables.
Essayons :
# Sélectionner toutes les colonnes dont le nom commence par "S" :
RP2019NC_OD_ind_3Provinces_V2_reduit_V2 %>%
select(., starts_with("S")) %>%
head()# A tibble: 6 × 5
SECT10 SECT21 SECT5 STAT STATANT
<chr> <chr> <dbl> <dbl> <dbl>
1 BE C 2 3 NA
2 MN M 4 3 NA
3 OQ O 5 3 NA
4 OQ O 5 3 NA
5 OQ O 5 3 NA
6 <NA> <NA> NA NA 1# Sélectionner toutes les colonnes dont le nom FINIT par "T" :
RP2019NC_OD_ind_3Provinces_V2_reduit_V2 %>%
select(., ends_with("T")) %>%
head()# A tibble: 6 × 3
STAT STATANT TACT
<dbl> <dbl> <dbl>
1 3 NA 1
2 3 NA 2
3 3 NA 1
4 3 NA 1
5 3 NA 1
6 NA 1 6# Sélectionner toutes les colonnes dont le nom contient "AT" :
RP2019NC_OD_ind_3Provinces_V2_reduit_V2 %>%
select(., contains("AT")) %>%
head()# A tibble: 6 × 2
STAT STATANT
<dbl> <dbl>
1 3 NA
2 3 NA
3 3 NA
4 3 NA
5 3 NA
6 NA 1Plus complexe et plus puissante, la fonction matches permet d’utiliser des expressions régulières (une syntaxe technique permettant de trouver TOUT type de pattern dans un texte. Tous les mots contenant 5 lettres en minuscules, suivies d’un chiffre entre 45 et 50 par exemple.
# Cette expression régulière sélectionne les mots commencant par un S avec "^S", et finissant par deux chiffre avec "[0-9]{2}$", avec 3 lettres entre les deux avec "[A-Z]{3}".
# On va donc match SECT10 et SECT21 mais pas SECT5 car il contient une lettre de moins !
RP2019NC_OD_ind_3Provinces_V2_reduit_V2 %>%
select(matches("^S[A-Z]{3}[0-9]{2}$")) %>%
head()# A tibble: 6 × 2
SECT10 SECT21
<chr> <chr>
1 BE C
2 MN M
3 OQ O
4 OQ O
5 OQ O
6 <NA> <NA> Enfin, avec rename, on peut simplement renommer des variables selon le format nouveau_nom = ancien_nom.
# Vous avez remarqué que, depuis un moment, on ne crée plus de nouvelles copies du jeu de données comme on le faisait avec " <- " précedemment ? C'est volontaire, le but étant de simplement montrer le résultat des fonctions de dyplr, sans nécessité de stocker ce résultat dans un nouvel objet :)
RP2019NC_OD_ind_3Provinces_V2_reduit_V2 %>%
rename(., Age_new = AGEA, "statut pro" = STAT)# A tibble: 250 × 7
Age_new SECT10 SECT21 SECT5 `statut pro` STATANT TACT
<dbl> <chr> <chr> <dbl> <dbl> <dbl> <dbl>
1 26 BE C 2 3 NA 1
2 24 MN M 4 3 NA 2
3 54 OQ O 5 3 NA 1
4 44 OQ O 5 3 NA 1
5 44 OQ O 5 3 NA 1
6 46 <NA> <NA> NA NA 1 6
7 26 <NA> <NA> NA NA 1 6
8 46 <NA> <NA> NA NA 1 6
9 23 <NA> <NA> NA NA 1 4
10 60 OQ P 5 3 NA 1
# ℹ 240 more rows# Ici, comme le nouveau nom "statut pro" contenait un espace, j'ai du le mettre entre guillemet, c'est pourquoi on remplace DES QUE POSSIBLE les espaces par des underscores (aka tiret du 8).Bon, évidemment, si vous avez un dictionnaire des variables par ailleurs, évitez de les rennomer (sauf si vous y apportez des modifications bien sûr, auquel cas les renommer devient indispensable !).
V.4) Mutate
mutate, c’est le must !
Avec cette fonction, vous pourrez créer de nouvelles variables, en fournissant une expression. Par exemple, je veux une nouvelle variable qui aie pour valeur la moitié de l’âge de mes individus. Rien de plus simple :
RP2019NC_reduit_V3 <- RP2019NC_OD_ind_3Provinces_V2_reduit_V2 %>%
mutate(., Demi_Age = AGEA / 2) # On divise simplement AGEA par 2 !Plus complexe : Je souhaite catégoriser les individus en fonction de leur âge :
Moins de 30 ans : Jeunes
Entre 30 et 60 ans : Entre_deux
Plus de 60 ans : Vieux
On va utiliser case_when , une fonction qui fonctionne sur le mode du “Si A est vrai, la variable devient X, sinon, elle devient Y” (cas le plus simple).
RP2019NC_reduit_V4 <- RP2019NC_reduit_V3 %>%
mutate(., Categorie_age = case_when(
AGEA <= 30 ~ "Jeune",
AGEA > 30 & AGEA < 60 ~ "Jeune_Vieux",
AGEA >= 60 ~ "Vieux",
TRUE ~ NA
))
# Affichons les stats de cette nouvelle variable avec table()
table(RP2019NC_reduit_V4$Categorie_age)
Jeune Jeune_Vieux Vieux
77 134 39 mutate permet de faire énormément de choses, soyez créatifs !
V.5) Arrange
arrange permet de “réarranger” un tableau en fonction de critères donnés.
RP2019NC_OD_ind_3Provinces_V2_reduit_V2 %>%
arrange(., AGEA) %>%
slice_head(., n = 5)# A tibble: 5 × 7
AGEA SECT10 SECT21 SECT5 STAT STATANT TACT
<dbl> <chr> <chr> <dbl> <dbl> <dbl> <dbl>
1 14 <NA> <NA> NA NA NA 3
2 17 <NA> <NA> NA NA NA 3
3 18 <NA> <NA> NA NA 1 3
4 19 <NA> <NA> NA NA NA 3
5 19 GI G 4 3 NA 1Le comportement par défaut est d’afficher en “ascendant”, donc du plus petit au plus grand, mais on peut changer ce comportement avec desc() .
RP2019NC_OD_ind_3Provinces_V2_reduit_V2 %>%
arrange(., desc(AGEA)) %>%
slice_head(., n = 5)# A tibble: 5 × 7
AGEA SECT10 SECT21 SECT5 STAT STATANT TACT
<dbl> <chr> <chr> <dbl> <dbl> <dbl> <dbl>
1 87 <NA> <NA> NA NA 2 5
2 80 <NA> <NA> NA NA 1 5
3 80 <NA> <NA> NA NA 1 5
4 80 <NA> <NA> NA NA NA 5
5 78 <NA> <NA> NA NA 1 5V.6) Les opérations groupées
VI - Conclusion
Dans ce module, nous avons exploré les bases du Tidyverse et ses avantages pour l’analyse de données. En utilisant les packages du Tidyverse, vous serez en mesure de manipuler, transformer et visualiser vos données de manière plus efficace et élégante.
N’hésitez pas à poser des questions et à explorer davantage les fonctionnalités du Tidyverse par vous-même.
Bonne exploration !
— Et pour finir, voici la fiche mémoire de dplyr (vous en trouverez d’autres sur la page “trouver de l’aide” de ce site) —
VII - Crédits & sources
Ce chapitre à été inspiré de ma connaissance du tidyverse, mais également du cours de Julien Barnier (dans lequel j’ai parfois récupéré des formulations que je n’ai pas su améliorer), que je remercie : https://juba.github.io/tidyverse/10-dplyr.html