Les bonnes pratiques en R

Les douze commandements

Introduction

Les bonnes pratiques proposées visent principalement à développer des habitudes communes dans la manière d’organiser son travail, structurer et documenter ses programmes, dans le but de faciliter le travail en équipe et les partages de programmes, en interne comme en externe.

Elles doivent notamment faciliter la lisibilité des programmes et inciter à leur documentation.

Ces bonnes pratiques ont donc aussi un intérêt pour soi.

1. Tu créeras des projets RStudio

Créer un projet facilite la gestion des fichiers et des chemins.

🧩 Astuce : Vérifiez dans RStudio que vous travaillez bien dans le bon projet grâce à l’icône en haut à droite.

Avantages - Organisation claire des fichiers - Facilite le travail collaboratif - Compatible avec la science ouverte (simplification des chemins)

2. Tu structureras les répertoires du projet

Organisation recommandée :

  • Data : Fichiers de données
  • Figures : Graphiques et sorties
  • Programme : Scripts et programmes

💡 Astuce : ajoutez des sous-dossiers pour distinguer données brutes et produites.

3. Tu nettoieras l’environnement

Toujours commencer par nettoyer l’espace de travail :

rm(list = ls()) 
gc()
         used (Mb) gc trigger (Mb) max used (Mb)
Ncells 563552 30.1    1288058 68.8   644180 34.5
Vcells 995818  7.6    8388608 64.0  1635426 12.5

ls() : liste tous les objets actuellement dans ton environnement de travail.

rm(list = ls()) : supprime tous les objets de ton environnement.

rm(list = ls(“Table1”, “vecteur2”)) : : supprime les objets listés de ton environnement.

🧹 → C’est l’équivalent de “vider la mémoire visible dans l’onglet Environment” de RStudio.

gc()

Appelle le garbage collector.

Cela libère la mémoire qui était encore occupée par des objets supprimés, mais qui n’était pas encore totalement nettoyée par R.

🧹 → Nettoyage plus profond de la mémoire.

💡 Supprimer au fur et à mesure les tables intermédiaires pour réduire le volume de mémoire de travail mobilisé.

4. Tu chargeras tous les packages nécessaires au programme en début de programme

Charger tous les packages nécessaires à la réalisation du programme dès le début (commande Library) facilite le repérage de la liste des packages nécessaires.

⚠️ Attention : Certaines fonctions peuvent exister dans plusieurs packages. Afin de limiter les risques de confusion, il faut éviter de faire appel à des packages non nécessaires au programme. En d’autres termes, il faut éviter de recopier systématiquement la même liste de packages d’un programme à l’autre.

Pour les exploitations habituelles, privilégier le package Tidyverse.

🔔 Rappel :

- Installation des packages : Installez les packages une seule fois.

- Chargement des packages : Chargez-les à chaque fois dans vos programmes afin de garantir leur disponibilité.

5. Tu préféreras des programmes emboîtés à un programme trop long

Plutôt que d’écrire un programme très long, il peut être préférable de le diviser en plusieurs sous-programmes, chacun dédié une phase particulière de l’exploitation, et de disposer d’un programme principal qui appelle successivement ces sous-programmes.

En cas de programmes emboîtés, charger les packages dans les sous-programmes les utilisant plutôt que de les charger tous dans le programme principal.

6. Tu utiliseras le « pipe » natif dans la rédaction

Pipe natif :

base |> 
  mutate(...)

Pipe non natif :

base %>%
  mutate(...)

🔔 Rappel : Le pipe natif peut être obtenu par défaut par CTRL+MAJ+M avec package dyplr en le paramétrant (dans « Tools » / « Global option » / « Code » ; cocher le fait d’utiliser le « native pipe operator »)

🔔 Rappel : CTRL+MAJ+M, M pour Magritte

7. Tu privilégieras le format rds au format Rdata

Le format .rds permet de sauvegarder qu’un seul objet R, alors que le format Rdata en sauvegarde plusieurs.

8. Tu écriras pour être relu plutôt que pour être efficace

  • Mettre des commentaires pour expliquer ce que fait le programme, en trouvant un juste milieu entre « pas assez » et « trop ».

  • Ecrire de manière explicite plutôt qu’implicite, en particulier, écrire le nom des paramètres dans les fonctions même quand on pourrait s’en passer.

  • Dans les « pipes », aller à la ligne après chaque |> de façon à mettre en évidence l’enchaînement des opérations successives.

  • Eclaircir le code en en mettant des espaces, notamment avant et après les opérateurs (=, +, ==, -, <-,…)

  • Respecter l’indentation lorsque l’on va à la ligne (l’indentation est le fait de mettre des tabulations en début de ligne ).

Difficile à lire

head(summarise(group_by(filter(Base_efe, tx_acc > 0.2),top1_c5),moyenne = mean(tx_acc), médiane = median(tx_acc)))
# A tibble: 2 × 3
  top1_c5 moyenne médiane
  <chr>     <dbl>   <dbl>
1 C5i        39.7    40.3
2 C5m        12.4    12.4

Simple à lire

Base_efe |> 
  # filtre si le taux accès est superieur à 20 %
    filter(tx_acc > 0.2) |> 
  # en fonction de la variable top1_c5
    group_by(top1_c5) |> 
  # La moyenne et la médiane
    summarise(moyenne = mean(tx_acc), médiane = median(tx_acc)) |> 
    head()
# A tibble: 2 × 3
  top1_c5 moyenne médiane
  <chr>     <dbl>   <dbl>
1 C5i        39.7    40.3
2 C5m        12.4    12.4

9. Tu mettras les noms des variables/colonnes en minuscules et n’utiliseras pas d’accents et de caractères spéciaux

La fonction clean_names() du package Janitor permet de mettre les noms des colonnes d’une table en minuscules et de supprimer les caractères spéciaux et accents. Cette fonction peut être appliquée après importation d’une table pour « nettoyer » les noms des variables/colonnes.

library(janitor)

Base_efe <- Base_efe |> 
  rename(TauxACCès = tx_acc)

head(Base_efe)
# A tibble: 6 × 30
  TauxACCès ns_txacc tx_form ns_txform tx_courses ns_txcourses tx_autres
      <dbl>    <dbl>   <dbl>     <dbl>      <dbl>        <dbl>     <dbl>
1      39.6        0    30.2         0       28.3            0      1.91
2      14.3        0    19.0         0       17.7            0      1.30
3      52.6        0    36.8         0       32.8            0      3.98
4      27.3        0    27.2         0       25.6            0      1.65
5      38.6        0    30.6         0       28.8            0      1.78
6      39.5        0    36.5         0       34.2            0      2.30
# ℹ 23 more variables: ns_txautres <dbl>, heurstag <dbl>, heurstag_sal <dbl>,
#   top1_c5 <chr>, top2_c5 <chr>, top3_c5 <chr>, top1_c5_tx <dbl>,
#   top2_c5_tx <dbl>, top3_c5_tx <dbl>, top1_d3 <chr>, top2_d3 <chr>,
#   top3_d3 <chr>, top1_d3_tx <dbl>, top2_d3_tx <dbl>, top3_d3_tx <dbl>,
#   top1_e1 <chr>, top2_e1 <chr>, top3_e1 <chr>, top1_e1_tx <dbl>,
#   top2_e1_tx <dbl>, top3_e1_tx <dbl>, taille <chr>, secteur <chr>
Base_efe <- clean_names(Base_efe)

head(Base_efe)
# A tibble: 6 × 30
  taux_ac_ces ns_txacc tx_form ns_txform tx_courses ns_txcourses tx_autres
        <dbl>    <dbl>   <dbl>     <dbl>      <dbl>        <dbl>     <dbl>
1        39.6        0    30.2         0       28.3            0      1.91
2        14.3        0    19.0         0       17.7            0      1.30
3        52.6        0    36.8         0       32.8            0      3.98
4        27.3        0    27.2         0       25.6            0      1.65
5        38.6        0    30.6         0       28.8            0      1.78
6        39.5        0    36.5         0       34.2            0      2.30
# ℹ 23 more variables: ns_txautres <dbl>, heurstag <dbl>, heurstag_sal <dbl>,
#   top1_c5 <chr>, top2_c5 <chr>, top3_c5 <chr>, top1_c5_tx <dbl>,
#   top2_c5_tx <dbl>, top3_c5_tx <dbl>, top1_d3 <chr>, top2_d3 <chr>,
#   top3_d3 <chr>, top1_d3_tx <dbl>, top2_d3_tx <dbl>, top3_d3_tx <dbl>,
#   top1_e1 <chr>, top2_e1 <chr>, top3_e1 <chr>, top1_e1_tx <dbl>,
#   top2_e1_tx <dbl>, top3_e1_tx <dbl>, taille <chr>, secteur <chr>

10. Tu mettras les noms des objets avec une majuscule en première lettre puis en minuscules

Notamment pour les noms de tables

11. Tu utiliseras des verbes d’action pour les fonctions et mettras des underscores entre les mots

# Fonction pour additionner deux chiffres
additionner <- function(a, b) {
  return(a + b)
}

# Exemple d'utilisation
resultat <- additionner(5, 3)
print(resultat)
[1] 8

12. Tu utiliseras la fonction sommaire pour naviguer plus facilement dans ton programme.

Ton code peut être structuré en parties et sous-parties de façon simple en identifiant des noms de parties et sous-parties. Pour cela : - Le nom des parties de niveau 1 correspondent aux lignes commençant par un # et terminant par au moins 4 tirets - Le nom des sous parties de niveau 2 correspondent aux lignes commençant par deux # et terminant par au moins 4 tirets - Le nom des sous parties de niveau 3 correspondent aux lignes commençant par trois # et terminant par au moins 4 tirets.

En cliquant dans la fenêtre du script sur l’icône à droite de « source », on peut voir alors apparaître le sommaire de son programme et naviguer ainsi plus rapidement dedans.

Les douze commandements