Formation R initiation
20/02/2025
Ce diaporama de formation a été rédigé dans le but d’être le support visuel des formations dispensées au MASA.
Ces formations s’adressent à des agents qui ont suivi les fondamentaux de la programmation.
Elles sont données en présentiel sur une durée de 2 jours.
Champ couvert par cette formation
Ce support couvre une initiation au language R avec R-studio et une découverte de l’environnement de production du MASA.
Pour information, les thêmes abordés sont:
01 - Présentation
02 - Les objets de R
03 - Manipulation de données
04 - Outils DPLYR & TIDYR
Ils sont orientés pour être utile aux agents du SSM Agriculture et se concentrent sur une utilisation de R via RStudio qui est mise à disposition des agents sur la plateforme interne Cerise basée sur RStudio Workbench.
Logiciel de traitement de données et analyse statistique :
offre un environnement interactif de développement statistique, analytique et graphique ; est doté d’un langage de programmation R ;
permet d’accéder à des données, de les manipuler et les analyser ;
S’interface avec les bases de données : Oracle, SYBASE, PostgreSQL, SQLITE…
Remplace SAS ou SPSS
Logiciel IDE : Integrated Development Environment
⇒ EN BAS A GAUCHE
permet de saisir des lignes de commande
affiche la log et les résultats
Log : historique des commandes, messages, etc.
→ cela signifie que R est disponible et en attente de la prochaine commande
→ cela signifie que R considère que la commande de la ligne précédente n’est pas terminée et qu’il « attend la suite »
Il faut alors :
- compléter la commande
ou
- sortir et recommencer en appuyant sur Echap
Possibilité de naviguer dans la console avec les flèches ↑ ou ↓
Appuyer sur Entrée pour exécuter une commande, ou cliquer sur
Pour effacer le contenu de la console : menu Edit > Clear console
ou Ctrl+L
⇒ EN HAUT A GAUCHE
→ Pour soumettre la ligne ou la sélection depuis le script, il faut cliquer sur Run ou Ctrl + Entrée
Deux possibilités pour entrer une ligne de commande :
depuis le Script ⇒ plutôt pour les commandes à conserver
directement dans la Console ⇒ plutôt pour les commandes de vérifications
Je besoin de … | J’écris … |
---|---|
Trouver pour vérification le minimum d’une variable | Console |
Faire un tableau qui sera à refaire chaque mois | Script |
Créer un référentiel qu’il faudra compléter/modifier | Script |
Afficher une ligne d’un tableau pour vérifier l’exactitude de données | Console |
Afficher une ligne d’un tableau pour écrire un primeur | Script |
Cerise est organisé en plusieurs répertoires :
00-Espace-Personnel => espaces personnels des agents, accessible par l’agent uniquement
01-Espace-de-Partage => lieu de partage général entre les différents acteurs
=> Ces deux derniers espaces sont découpés par opérations statistiques
Sous Cerise, le chemin “~/” fait référence à son espace personnel
On peut reconstituer facilement un chemin complexe de l’arborescence Cerise en utilisant l’auto-complétion de R :
Je commence par taper le chemin pointant vers l’espace personnel “~/”
Je place le curseur après le slash, et j’appuie sur la touche tabulation du clavier : l’arborescence est proposée
⇒ Sur le serveur, le répertoire de travail est l’espace personnel
Pour connaître le répertoire de travail : commande getwd()
Pour changer le répertoire de travail :
commande setwd(“chemin du rép souhaité”)
Ou dans l’onglet Files
Dans la page d’accueil Maafluence de Cerise, on peut trouver des liens vers divers outils utiles :
https://orion.agriculture/confluence/display/CER/CERISE_Espace+Utilisateurs
Une FAQ sur Cerise avec les questions récurrentes, les actualités
Des documents d’aide : le guide des bonnes mani’R, les fiches méthodologiques, les documents de formation
Le lien vers le forum R du ministère, toujours vif à répondre à toutes les questions
Le lien vers les actualités et les présentations du Groupe Utilisateurs R :
https://orion.agriculture/confluence/display/CER/Le+groupe+utilisateur+R
Quand on programme, il est préférable d’écrire les commandes dans un fichier texte plutôt que dans la console
Avantages:
Sauvegarde des opérations effectuées
Obligation de commenter son code
Code reproductible
Possibilité de partager son code
Les scripts sont des fichiers texte - ils portent l’extension .R
Pour exécuter des commandes d’un script, se positionner sur la ligne ou bien sélectionner l’ensemble des commandes à exécuter puis Ctrl+Entrée ou Code > Run Selected line(s) ou
Pour interrompre une exécution, on utilise le bouton « stop » de la console :
Pour exécuter tout le code d’un script préprogrammé, on utilise la fonction
source(file ="V:/FormationR/Prog/mon_fichier.R")
ou sous RStudio :
(dans ce cas, rien ne s’affiche dans la console lors de l’exécution)
R est sensible à la casse ⇒ Les caractères en minuscules ou en MAJUSCULES sont différents |
|
Les commentaires s’écrivent après le symbole # | |
Dans les chemins Windows, les \ doivent être remplacés par des / ou des \\ |
Nombreuses possibilités avec installation de base de R …
… Mais parfois besoin de nouvelles fonctionnalités
⇒ Utilisation de packages :
Boîte à outils : fonctions spécifiques (et parfois des données) relatives à un domaine particulier
Développés et maintenus par la communauté des utilisateurs de R, et diffusés via le CRAN (Comprehensive R Archive Network = réseau de serveurs)
Pour pouvoir utiliser un package, il doit être installé et chargé en mémoire :
un package n’a besoin d’être installé qu’une seule fois : « achat de la boîte à outils »
il faut le charger à chaque nouvelle session pour l’utiliser : « prendre la boite du placard »
En local
Un certain nombre de packages (base) sont fournis lors de l’installation de R et n’ont pas besoin d’être installés.
Sur Cerise
Les « packages du socle commun » sont déjà installés → onglet Packages : System Library
Possibilité d’installer des packages par les utilisateurs → onglet Packages : User Library
L’installation d’un package se fait de l’une des façons suivantes :
En cliquant sur les menus en haut de la fenêtre : Tools → Install packages
Via une ligne de syntaxe dans le code : install.packages(“nom_package”)
Via l’onglet packages dans la fenêtre en bas à droite : bouton Install
Charger un package (à chaque utilisation)
utiliser la ligne de commande library(nom_package) (conseillé pour la reproductibilité du programme)
cocher sur RStudio (déconseillé car si quelqu’un reprend le programme, il ne saura pas qu’il faut cocher)
RStudio: l’onglet Packages de la fenêtre en bas à droite indique les packages installés.
Les packages cochés sont ceux chargés, et donc utilisables.
Lorsqu’on essaie d’utiliser une fonction d’un package sans l’avoir chargé, un message d’erreur s’affiche
En plus des raccourcis claviers usuels (Enregistrer, copier-coller, annuler l’action précédente), un certain nombre de raccourcis clavier peuvent être très utiles au quotidien dans R :
Raccourci clavier | Action |
---|---|
Ctrl + shift + n | Ouvrir un nouveau script |
Ctrl + shift + m | Écrire un pipe %>% ou avec la nouvelle écriture |> |
Ctrl + shift + c | Passer les lignes de code sélectionnées en commentaires |
Ctrl + shift + r | Introduire un titre de section en commentaires |
Ctrl + l | Vider la console |
Crtl + f | Ouvrir un module pour du chercher-remplacer dans le script |
Ctrl + i | Indenter automatiquement les lignes de code sélectionnées |
Dossier pour la formation initiation avec 3 sous-dossiers :
Dans quel répertoire êtes vous ? Le modifier pour que ce soit le dossier consacré à la formation
Quand on lance une commande (dans la console ou depuis un script), R fait le calcul (ou l’opération demandée) et affiche le résultat dans la console
⇒ Pour réutiliser, appeler ou modifier un résultat dans la suite du programme : stocker le résultat dans un objet ⇒ c’est l’affectation
⇒ Tout ce qui n’est pas stocké dans un objet n’est pas gardé en mémoire !
C’est comme si je voulais modifier un fichier Excel, il faut bien que je stocke mon travail !
Affectation : affecter à un objet une valeur Opérateur : <-
Affecter une valeur à un objet le crée en même temps
Pour afficher la valeur d’un objet, il suffit de saisir son nom
Possibilité de créer autant d’objets que l’on souhaite
Les objets créés apparaissent dans la fenêtre en haut à droite
La commande ls() liste tous les objets en mémoire
Si un objet est utilisé dans une opération, R le remplace par sa valeur
⇒ lorsqu’on assigne une nouvelle valeur à un objet déjà existant, la valeur précédente est perdue
Comme dans un tableur : si dans une cellule je colle une valeur, la précédente est écrasée
⇒ lorsqu’on assigne un objet à un autre, cela ne crée pas de lien entre eux : modifier le premier objet ne va pas modifier le second
Différent du tableur: b ne change pas si a change
rm(nom_objet) supprime l’objet nom_objet de la mémoire.
rm(list=ls()) supprime tous les objets en mémoire.
RStudio : L’icône de l’onglet Environment supprime aussi les objets. En utilisant l’affichage Grid, on peut effectuer une sélection.
R travaille en mémoire vive :
Environnement « trop plein » = impact sur les temps d’exécution et les performances de R
Cerise : mémoire partagée entre tous les utilisateurs
Les noms des objets doivent commencer par une lettre
Il est possible :
- d’utiliser des majuscules et des minuscules
- d’utiliser des chiffres, l’underscore (_) et le point (.)
Il est déconseillé :
- d’utiliser les caractères accentués
- de choisir des noms de variables non explicites, trop longs ou trop courts
- d’écraser les noms de fonctions existantes
Il est impossible :
- d’utiliser un espace
- d’utiliser certains noms réservés au système (else, for, T, F, …)
- d’écraser les noms de fonctions existantes
En R, les données sont stockées dans différents objets :
Vecteur : ensemble de valeurs de même nature
Data.frame : concaténation de plusieurs vecteurs (=colonnes), de natures potentiellement différentes
⇒ similaire à un tableau de données d’un tableur
Avancé:
Matrice : ensemble de valeurs de même nature (que des nombres, que des chaînes de caractères, que des booléens…)
Liste : objet regroupant différents objets
c() est une fonction qui concatène plusieurs informations de même nature
Attention : Si des éléments sont de modes différents, R les convertit automatiquement au même mode :
Rappel: c() permet de créer un objet, pour l’utiliser il faut le stocker et donc l’affecter !
Un vecteur peut être de quatre types :
numérique
caractère
logique (vrai ou faux)
facteur : vecteur dont les seules valeurs possibles sont les modalités d’une variable quantitative (ex : régions, départements…)
Valeur particulière : NA lorsqu’une variable est en valeur manquante
On détermine le type d’un vecteur avec mode(), on peut tester les types avec les fonctions is.numeric(), is.character(), is.logical(), is.na() etc :
data.frame: plusieurs vecteurs (colonnes) de même longueur et de mode potentiellement différents
⇒ C’est ce que l’on utilise le plus souvent
⇒ C’est un tableau de données, avec les observations en lignes et les variables en colonnes
Pour connaître les caractéristiques d’un data.frame, il y a plusieurs outils utiles :
str() donne la structure de la table (liste des colonnes, avec le type et les premières valeurs)
names() renvoie le vecteur des noms de colonnes
head() et tail() donnent respectivement les 6 premières et les 6 dernières lignes de la table (6 par défaut, peut être modifié)
nrow() et ncol() donnent respectivement le nombre de lignes et de colonnes de la table
Pour accéder aux différentes variables d’un data.frame, on utilise l’opérateur $
Mise en place :
Créer un nouveau programme et l’enregistrer
Charger les librairies : dplyr, tidyr, readr
Travail sur un data.frame : iris est un jeu de données fourni avec R
Combien de colonnes ? De lignes ?
Quel est le nom des variables ?
Afficher les 10 premières lignes
Quel est le type de chacune des variables ?
Il y a plusieurs bonnes manière de faire : il faut expérimenter !
Sous R, les ‘’objets’’ sont des données (vecteurs, data.frames…) ou des fonctions
⇒ Les fonctions permettent de transformer les données.
Comme sous Excel ou calc, une fonction reçoit en entrée des données et des arguments (=paramètres)
Une fonction renvoie des données et peut avoir des effets collatéraux (ex : modification d’une colonne)
resultat ← fonction(donnee, arg=TRUE,…)
Fonctions disponibles avec R de base et différents packages
Ou possibilité de créer des fonctions (module R perfectionnement)
Une multitude de fonctions : voir fiche mémo
Retourne des informations sur les objets : names(), ncol(), mode() …
Numériques : sum(), mean() …
Traitements des chaînes de caractères : substr(), toupper(), …
Il n’est pas nécessaire de connaître par cœur toutes les fonctions et leurs arguments : habitudes, mémo, aide de R, nombreuses ressources en ligne
On peut appliquer une fonction à un vecteur et donc à une colonne d’un data.frame, mais aussi à un élément
On peut modifier une colonne avec une fonction ou créer une nouvelle
3) Programmes et manipulation des données
Calculer la moyenne de la variable Sepal.Length
Mettre en majuscule la variable Species
Est-ce que les modifications ont été stockées ?
AVANT LA SUITE DE LA FORMATION / PENSER A NETTOYER VOTRE ENVIRONNEMENT
La partie Manipulation de données va fournir les outils nécessaires aux traitements classiques à opérer sur une table de données.
A part pour la lecture et l’écriture de fichiers, les outils proposés relèvent des packages dplyr) et tidyr) : ils sont d’un usage plus aisé que les outils R de base et couvrent beaucoup des fonctionnalités les plus courantes.
Objectif: découvrir et utiliser les outils (packages) nécessaires aux traitements classiques à opérer sur une table de données
Lecture et écriture de fichier : readr, readxl, etc.
Fonctionnalités les plus courantes de manipulation des données : dplyr et tidyr
Créer un data.frame :
data.frame()
importer des données de différents formats
Format du fichier source | Fonction * |
---|---|
format de données « plats » (csv, txt…) | read_delim, read_csv, read_csv2 |
RDS | readRDS |
XLSX, XLS | read.xlsx, read_excel |
ODS | read_ods |
SAS, SAV | read_sas, read_spss |
parquet | read_parquet |
* Le détail des fonctions est dans les diapos masquées ou facilement trouvable en ligne ou dans l’onglet help
Pour la plupart des formats (csv, txt,…), il faut spécifier le type des colonnes :
exploitations <- read_csv2("mes_donnees_exploitations.csv",
col_types = cols(.default = col_character(),
SAU = col_double(),
UGB = col_double()))
Avantage du format RDS :
Conserve l’image exacte d’un objet : type de variable, encodage, etc.
Format plus léger
C’est le format recommandé pour travailler sous R (enregistrement de tables de travail, de tables de mise à disposition, etc.)
Rstudio dispose également d’un assistant d’import pour les fichiers text
Sur le serveur, on ne peut importer des données que si elles sont sauvegardées sur le serveur. Pour importer des données enregistrées en local, il faut auparavant les enregistrer sur le serveur.
⇒ pour importer une table de l’ordinateur local sur Cerise, on utilise le bouton Upload de l’onglet Files en bas à droite de l’interface.
Enregistrer le data.frame résultat dans un fichier externe
Format du fichier source | Fonction * |
---|---|
format de données « plats » (csv, txt…) | write_delim, write_csv, write_csv2 format recommandé pour l’utilisation dans d’autres logiciels que R |
RDS | SaveRDS format recommandé pour l’utilisation dans R |
XLSX, XLS | write.xlsx |
ODS | write_ods |
SAS, SAV | NON RECOMMANDE |
parquet | write_parquet |
* Le détail des fonctions est dans les diapos masquées ou facilement trouvable en ligne ou dans l’onglet help
2 packages à charger en début de programme
Objectif de dplyr : rassembler dans un seul package les outils de manipulation de données les plus importants pour l’analyse des données
Deux principes pour les packages tidyr et dplyr :
Usage de fonctions « verbe » toutes construites sur le même principe : le premier paramètre est la table de données sur laquelle on travaille.
Usage de l’opérateur pipe (issu du package magrittr)
Dans R-Studio, le raccourci clavier pour cet opérateur est : Ctrl + Shift + M
L’opérateur pipe %>% ou |> permet d’enchaîner les traitements dans une seule commande.
Dans le cas d’enchaînement de traitements avec l’opérateur pipe, on peut aérer le code en allant à la ligne après chaque pipe.
ATTENTION : Si on passe à la ligne avant le pipe, la suite des traitements ne s’effectue pas, la commande s’arrête.
Pour sélectionner des colonnes dans une table, on utilise la fonction select()
maTable %>% select(noms_des_colonnes)
→ on renseigne l’ensemble des colonnes à conserver, séparés par une virgule
→ pour anti-sélectionner, on fait précéder le nom de la colonne par le signe -
→ L’ordre des colonnes dans les parenthèses sera l’ordre dans la table en sortie
nouvelle_table <- ma_table %>% select(nom_des_colonnes)
ma_table <- ma_table %>% select(nom_des_colonnes)
Rappel: Si on ne fait pas l’affectation, on aura la table réduite affichée dans la console mais le changement ne sera pas stocké
Quelques outils supplémentaires :
Description | Syntaxe |
---|---|
Sélectionner la 2ème, la 3ème et les 6ème colonne de ma_table | ma_table%> % select(2, 3, 6) |
Sélectionner l’ensemble des colonnes comprises entre les colonnes VarDeb et VarFin de ma_table | ma_table%> % select(VarDeb:VarFin) |
Sélectionner les colonnes qui contiennent exactement « Surface » dans leur nom | ma_table%> % select(contains(“Surface”, ignore.case = FALSE)) |
Sélectionner les colonnes dont le nom commence par « SURF » ou « surf » ou « Surf »… | ma_table%> % select(starts_with(“SURF”, ignore.case = TRUE)) |
Sélectionner les colonnes dont le nom termine par « _1 » | ma_table%> % select(ends_with(“_1”)) |
on utilise la fonction filter()
maTable %>% filter(conditions)
→ Les conditions peuvent être séparées par des virgules ou par les séparateurs de conditions habituelles &, | ou xor.
nouvelle_table <- ma_table %>% filter(conditions)
ma_table <- ma_table %>% filter(conditions)
Opérateur | Exemple syntaxe | Signification |
---|---|---|
== | ma_table %>% filter(region == “53”) | On ne garde que les lignes pour lesquelles la variable région est égale à 53 | → Attention au double égal !!! |
!= | ma_table %>% filter(region != “53”) | On garde toutes les lignes pour lesquelles la variable région est différente de 53 |
> | ma_table %>% filter(SAU > 10) | On garde les lignes pour lesquelles la variable SAU est supérieure stricte à 10 |
< | ma_table %>% filter(SAU < 10) | On garde les lignes pour lesquelles la variable SAU est inférieure stricte à 10 |
>= | ma_table %>% filter(SAU >= 10)) | On garde les lignes pour lesquelles la variable SAU est supérieure ou égale à 10 |
Opérateur | Exemple syntaxe | Signification |
---|---|---|
<= | ma_table %>% filter(SAU <= 10) | On garde les lignes pour lesquelles la variable SAU est inférieure ou égale à 10 |
%in% | ma_table %>% filter(reg %in% c(“52”, “53”)) | On garde les lignes pour lesquelles la variable SAU est inférieure ou égale à 10 |
& | ma_table %>% filter(reg == “53” & SAU > 10) | On garde les lignes pour lesquelles la variable reg vaut 53 et la SAU est supérieure stricte à 10 (les deux conditions en même temps) |
| | ma_table %>% filter(SAU > 10 | EFF > 50) | On garde les lignes pour lesquelles la variable SAU est supérieure stricte à 10 ou la variable EFF est supérieure stricte à 50 (l’une ou l’autre des conditions seulement ou les deux) |
xor | ma_table %>% filter(xor(SAU > 10, EFF > 50)) | On garde les lignes pour lesquelles la variable SAU est supérieure stricte à 10 ou celles pour lesquelles la variable |
maTable %>% slice(paramètres)
Exemples :
maTable %>% slice(1:10)
⇒ renvoie les lignes 1 à 10 de maTable maTable %>% slice_max(nombre,n=10)
⇒ renvoie les 10 lignes de maTable avec les valeurs max de la variable nombre
maTable %>% distinct(var_doublon, .keep_all = FALSE)
var_doublon correspond aux variables qui, combinées, permettent d’identifier les doublons.
si .keep_all = FALSE, la table résultat ne contiendra que les variables citées dans var_doublon. Si .keep_all = TRUE, toutes les variables de la table sont conservées.
maTable %>% distinct()
Objectif de l’exercice : à partir des données du RA2020, reproduire ce tableau
À faire :
1) Préparer l’environnement
2) Importer les données
3) Après avoir découvert les données, réduire la table aux informations (colonnes et lignes) nécessaires
4) Existe-t-il des doublons ?
5) Identifier les différentes orientations technico-économiques
Pour trier une table selon une ou plusieurs variables, on utilise la fonction arrange()
maTable %>% arrange(variables_de_tri)
→ possibilité de trier selon plusieurs colonnes : les variables de tri doivent être séparées par une virgule.
→ on encadre les variables qu’il faut trier de façon décroissante par la fonction desc().
nouvelle_table_triee <- ma_table %>% arrange(variables_de_tri)
ma_table <- ma_table %>% arrange(variables_de_tri)
Pour renommer une ou plusieurs colonnes dans une table, on utilise la fonction rename()
maTable %>% rename(nouveau_nom = ancien_nom)
On peut renommer plusieurs variables dans un seul rename, en séparant les instructions par des virgules.
nouvelle_table <- ma_table %>% rename(nouveau_nom = ancien_nom)
ma_table <- ma_table %>% rename(nouveau_nom = ancien_nom)
À faire :
Trier la table par département, OTEFDA_COEF17 et SAU_TOT décroissante
Renommer la variable OTEFDA_COEF17 en OTEFDA, la variable UGBIFS.TOT en UGB et la variable SAU_TOT en SAU
Supprimer le préfixe “SIEGE_” dans les variables géographiques.
Pour créer une nouvelle variable ou modifier une variable déjà existante dans une table, on utilise la fonction mutate()
maTable %>% mutate(variables_créées)
→ possibilité de créer plusieurs variables en une seule instruction, en séparant les différentes variables par des virgules
On peut modifier ou créer une variable :
À partir d’une constante
À partir d’une ou plusieurs autres variables de la table
À partir d’une ou plusieurs autres variables d’une autre table
Les expressions successives prennent en compte les résultats des calculs précédents
→ il est donc possible de créer une variable à partir d’une variable créée précédemment dans la même instruction
Créer une variable se fait selon cette formule :
nom_nouvelle_variable = instructions
Par défaut : nouvelle variable ajoutée comme dernière colonne
⇒ possibilité d’indiquer la position des variables à créer dans la table. On utilise les paramètres .before et .after sur le modèle des paramètres de la fonction relocate :
À vous de créer ou modifier les variables nécessaires à la réalisations du tableau final !
Le tableau final devra contenir de “beaux” libellés de région et de département.
On va donc commencer par corriger les variables LIB_REG et LIB_DEP.
str_to_title() du package stringr
Le tableau résultat contient un décompte des exploitations selon qu’elles aient une spécialisation végétale, animale ou bien mixte. La variable OTEFDA est trop détaillée
⇒ créer la variable SPECIALISATION
maTable %>% count(variable)
→ la fonction compte le nombre d’occurrences pour chaque modalité de la variable
→ la table en sortie contient deux variables : la variable pour laquelle on compte les modalités, et une variable appelée n qui contient les effectifs
mutate(part = n/sum(n) * 100)
maTable %>% summarise(fonctions_stat(variable))
→ possibilité de calculer plusieurs statistiques, en séparant les instructions par une virgule
→ on peut utiliser les fonctions statistiques de base telles que max, min, mean, sd, n…
summarise(nom_variable_résumé = fonction_stat)
Pour calculer des statistiques sur plusieurs variables à la fois et/ou selon plusieurs fonctions, on utilisera across(). Quelques exemples :
Description | Syntaxe |
---|---|
Calculer la moyenne de toutes les variables de la table | maTable %>% summarise(across(everything(), mean)) |
Calculer la somme de chacune des variables numériques de la table | maTable %>% summarise(across(where(is.numeric), sum)) |
Calculer la somme de chacune des variables numériques de la table | maTable %>% summarise(across(everything(), ~sum(is.na(.)))) |
Calculer la moyenne et la somme, d’une variable x de la table | maTable %>% summarise(across(x, list(moy = mean, somme = sum))) |
Calculer la moyenne et la somme de toutes les variables de la table | maTable %>% summarise(across(everything(), list(moy = mean, somme = sum))) |
maTable %>%
group_by(var_groupe) %>%
summarise(fonctions_stat(variable))
%>% ungroup()
Rappel : pour cet exemple, pas d’affectation, le résultat s’affiche dans la console mais ne sera pas stocké
On peut aussi combiner la fonction group_by() avec la fonction mutate() : dans ce cas les statistiques par groupe sont directement intégrées à la table de données individuelles
Données agrégées de la région
⇒ Penser à affecter le résultat !
Dénombrer le nombre d’exploitations relevant de chaque spécialisation
⇒ Penser à affecter le résultat !
Et par département ? Faire les calculs agrégés à ce niveau
Pour accoler deux tables horizontalement (rajouter des lignes), on utilise la fonction bind_rows()
bind_rows(maTable1, maTable2)
# ou précédé d'un pipe
maTable1 %>% bind_rows(maTable2)
⇒ Les colonnes ayant le même nom vont s’empiler. Les autres vont se compléter avec des valeurs manquantes.
La fonction bind_cols() permet de la même façon de rajouter des colonnes à une table sans passer par une variable de jointure.
Attention: sans variable de jointure signifie que rien ne garantit que les lignes correspondent
Pour fusionner deux tables en utilisant une ou plusieurs variables de jointure, on utilise les fonctions XXX_join()
XXX_join(maTable1, maTable2, by = variables_de_fusion) # ou précédé d'un pipe maTable1 %>% XXX_join(maTable2, by = variables_de_fusion)
Les noms des variables de jointures doivent être indiqués entre guillemets Il n’est pas nécessaire de trier les tables avant de faire la jointure
Il est possible de réaliser une jointure à l’aide de plusieurs variables identifiantes : l’argument by s’écrit alors c(‘’id1’‘,’‘id2’’, …)
Lorsque les variables de jointure ont des noms différents dans les deux tables, l’argument by prend comme paramètre un vecteur du type c(‘’id1_tab1’’ = ‘’id1_tab2’‘,’‘id2_tab1’’ = ‘’id2_tab2’’,…)
Si rien n’est précisé, la fusion se fait sur l’ensemble des variables portant le même nom dans les deux tables
suffix = c(''suffix_tab1'', ''suffix_tab2'')
Remarque:
pivot_longer(maTable, cols, names_to, values_to) # ou précédé d'un pipe
maTable %>% pivot_longer(cols, names_to, values_to)
pivot_wider(maTable, names_from, values_from) # ou précédé d'un pipe
maTable %>% pivot_wider(names_from, values_from)
names_from = nom de la variable dont les modalités deviendront les intitulés de colonne values_from = nom de la variable à utiliser pour remplir les colonnes
cols = colonnes pivotantes
names_to = nom de la première colonne à créer et qui recevra les actuels noms des colonnes pivotantes
values_to = nom de la deuxième colonne à créer et qui recevra les valeurs des colonnes pivotantes
Moyen mnémotechnique pour différencier les deux fonctions : avec pivot_longer, la table devient plus longue
Quelques paramètres supplémentaires et utiles de la fonction pivot_longer:
ma_df %>% pivot_longer(
cols = birth_child1:birth_child3, ← colonnes à pivoter (ou starts_with(‘’birth_child’’))
names_to = ‘’child_number’’, ← nom de la colonne recevant les noms des colonnes à
pivoter values_to = ‘’date_of_birth’’, ← nom de la colonne &érecevant les valeurs des colonnes pivotées
names_prefix = ‘’birth_child’’, ← préfixe à enlever des noms de colonnes à pivoter
values_drop_na = TRUE ← le résultat ne contient pas des lignes avec des NA dans la colonne indiquée dans le paramètre values_to
)
Transposer les tables spécialisation pour avoir une ligne par département et une ligne total régional
Fusionner les tables départementales
Accoler les tables régionales
=> Concaténer ces deux tables
Selon le temps :
Denier chipotage pour une belle table à exporter :
Déplacer les variables de SAU et d’UGB en fin de table
Exprimer les variables SAU_tot et UGB_tot en milliers.
Arrondir les variables SAU_tot, SAU_moy et UGB_tot à l’unité.
Renommer les colonnes “en français”.
Export du résultat !
Nom de la fonction | Usage |
---|---|
select() | sélectionner des variables |
relocate() | réorganiser des variables |
rename() | renommer des variables |
filter() | sélectionner des observations selon une ou plusieurs conditions |
mutate() | créer ou modifier des variables |
summarise() | agréger les observations en effectuant une fonction « résumé » sur une ou plusieurs variables |
arrange() | ordonner les observations selon une ou plusieurs variables |
group_by() | grouper les observations selon une ou plusieurs variables (avant d’effectuer des calculs) |
pivot_wider() | réorganiser les variables dans les lignes |
pivot_longer() | réorganiser les variables dans les lignes |
Introduction à R et au tidyverse : https://juba.github.io/tidyverse/ (en français)
Formations R aux MTES & MCTRCT : https://mtes-mct.github.io/parcours-r/ (en français)
Formations sous GEDSI :
Forum CIRAD : http://forums.cirad.fr/logiciel-R/ (forum francophone)
Les aides-mémoires : https://www.rstudio.com/resources/cheatsheets/ (aides-mémoire en anglais)
Sans oubli er les recherches Google qui renvoient très souvent une aide en français ou Chat GPT
1.4 Comment travailler avec R au MASA
Depuis la plate-forme CERISE :
⇒ Adresse : https://rstudio.agriculture.rie.gouv.fr
⇒ PISTACHE : Pistache > Traitements statistiques et Diffusion > R > Migration SPSS et SAS vers R > Accès au WIKI Cerise - R > Accéder à Cerise
Cerise permet l’accès aux ressources déposées sur le serveur, la sauvegarde, le partage de code et le travail simultané. C’est l’usage recommandé.
En local sur son poste, sans intervention de Pastel
Existence d’une plate-forme CERISE de Préproduction :