Maîtriser l'analyse de données relationnelles en R avec dplyr

Bienvenue dans l’univers de la manipulation de données ! Dans ce blog, tu vas découvrir comment le package dplyr peut transformer ta manière d’organiser et d’analyser les données en R. Je te présente les concepts fondamentaux qui structureront ta compréhension du travail avec des bases de données relationnelles en R.

Ces concepts sont comme des outils précieux qui t’aideront à naviguer avec confiance dans le monde des données. Tu pourras utiliser dplyr avec efficacité pour assembler des jeux de données complexes et produire des analyses pertinentes.

🌘 Modèle relationnel : clés, tables et enregistrements en R

Ta première étape vers la maîtrise des données relationnelles commence avec le modèle relationnel, une changement de paradigme dans la gestion des données introduite par Edgar F. Codd en 1969. Ce modèle représente une approche structurée pour organiser l’information de manière cohérente et logique, basé sur la théorie des ensembles et les mathématiques modernes.

Dans ce modèle, tu spécifies les données et les requêtes de façon déclarative, presque comme si tu parlais un langage naturel. Tu exprimes simplement ce que tu veux obtenir, et le système de gestion de données se charge de trouver le meilleur moyen de stocker et de récupérer ces informations. C’est le rôle de l’optimisateur de requêtes.

Le langage le plus courant pour travailler avec ce modèle est SQL, qui est devenu, avec les années, le langage universel des bases de données. En R, le package dplyr offre une alternative élégante et intuitive, permettant de travailler de manière fonctionnelle ou déclarative avec des dataframes. C’est un ORM, mais plus sophistiqué que ceux que tu peux trouver en Python, parce qu’il est aussi fonctionnel. Son approche claire et lisible transforme des opérations complexes en code R facile à comprendre et à maintenir.

🌘 Concepts du modèle relationnel

Pour bien comprendre ce modèle, tu dois d’abord maîtriser les concepts fondamentaux qui structurent les données relationnelles :

Un enregistrement est un tuple unique de valeurs identifié par une clé. C’est comme une fiche d’information complète dans une base de données, ou une ligne dans un dataframe R. Chaque enregistrement représente une entité spécifique dans ton analyse.
Une relation est un lien entre une clé et des attributs. Dans le monde des bases de données, c’est ce qu’on appelle une table, et en R, cela correspond à un dataframe. Une relation organise les données de manière structurée pour faciliter leur manipulation.
Une clé est l’élément essentiel qui permet de relier des enregistrements provenant de différentes tables via un opérateur de jointure (join).
- Une clé primaire est l’identifiant unique d’un enregistrement dans une relation, garantissant qu’aucun doublon n’existe.
- Une clé étrangère est un identifiant qui pointe vers un enregistrement dans une autre relation, créant ainsi des liens entre les tables.
- Une clé substitut (ou surrogate key) est une clé que tu crées lorsque tu n’as pas de clé primaire naturelle. Dans dplyr, la fonction row_number peut être utilisée pour générer ces identifiants uniques.
Un attribut est un ensemble de valeurs associées à une clé via un nom d’attribut. C’est ce qu’on appelle une colonne dans une base de données, ou une variable (ou facteur) en R. Les attributs définissent les caractéristiques mesurables de tes données.

Concepts du modèle relationnel en R avec dplyr
[1]

🌘 Opérations SQL dans le modèle relationnel, et leur équivalent dans dplyr

Maintenant que tu connais les concepts de base, explorons les quatre opérations fondamentales que tu peux effectuer sur tes données, que ce soit dans une base de données ou avec des fichiers plats.

Créer (Create) : En SQL, tu utilises l’instruction INSERT pour ajouter de nouveaux enregistrements. En dplyr, la fonction bind_rows joue ce rôle, s’apparentant à l’opérateur OUTER UNION en SQL. Cette opération permet d’ajouter de nouvelles observations à ton analyse.
Lire (Read) : En SQL, tu utilises l’instruction SELECT pour extraire les informations qui t’intéressent. En dplyr, la fonction select te permet de choisir les colonnes pertinentes pour ton analyse.
Mettre à jour (Update) : En SQL, l’instruction UPDATE permet de modifier les valeurs des attributs. En dplyr, la fonction mutate est utilisée pour mettre à jour un enregistrement ou créer de nouvelles variables. L’approche recommandée en R est de considérer chaque dataframe comme immuable, créant ainsi un nouvel objet plutôt que de modifier l’original. Tu peux ensuite nettoyer ton espace de travail en supprimant les dataframes inutiles avec rm, l’équivalent de DROP TABLE en SQL.
Supprimer (Delete) : En dplyr, tu utilises la fonction filter pour créer un nouveau dataframe sous-ensemble. Cette opération est similaire à l’opérateur WHERE en SQL, te permettant de ne conserver que les lignes qui correspondent à tes critères d’analyse.

🌘 Grammaire de données avec dplyr : verbes et jointures

Passons maintenant à la pratique avec la grammaire de manipulation des données de dplyr. Si les opérations CRUD (Create, Read, Update, Delete) sont les fondations de la manipulation de données, dplyr élève cette approche à un niveau supérieur avec une grammaire élégante et expressive.

dplyr propose une collection d’outils bien organisés, où chaque fonction a un rôle précis et un nom intuitif. Tu peux facilement comparer les verbes de dplyr aux différents opérateurs SQL que tu connais déjà :

arrange correspond à ORDER BY - pour organiser tes données dans un ordre spécifique
group_by correspond à GROUP BY - pour regrouper tes données selon des critères communs
filter remplace à la fois WHERE et HAVING - pour ne conserver que les lignes qui répondent à tes critères
summarise remplace les fonctions d’agrégation dans les instructions SELECT - pour condenser tes données en statistiques récapitulatives

La véritable puissance de dplyr opère lorsque tu commences à combiner ces fonctions. De manière similaire, tu peux joindre des tables à l’aide des verbes de jointure de dplyr. Pour cela, tu définis les clés dans chaque table avec un argument by, dont la syntaxe est la suivante :

by = c(
    "variable_dans_table_1" = "variable_dans_table_2",
    "variable_dans_table_1" = "variable_dans_table_2", 
    ...)

Visualisons ces opérations avec les diagrammes de Venn qui illustrent parfaitement comment les jointures affectent les variables :

Diagramme de Venn des jointures avec dplyr : inner_join, left_join

dplyr propose également des opérateurs de jointure de filtrage qui affectent directement les enregistrements :

semi_join(x, y) conserve toutes les observations de x qui ont une correspondance dans y.
anti_join(x, y) supprime toutes les observations de x qui ont une correspondance dans y.

🌘 Opérateurs ensemblistes en R : union, intersect et setdiff

Pour compléter ta boîte à outils, explorons les opérateurs ensemblistes de l’algèbre relationnelle. Ces opérateurs te permettent de combiner et de comparer des ensembles de données de manière précise.

Trois opérateurs ensemblistes principaux sont disponibles :

Intersection : INTERSECT en SQL, intersect en dplyr - pour trouver ce qui est commun à deux ensembles de données
Union : UNION en SQL, union en dplyr - pour combiner deux ensembles de données en un seul
Différence ensembliste : MINUS en SQL, setdiff en dplyr - pour trouver ce qui existe dans un ensemble mais pas dans l’autre

Ces opérateurs sont des outils essentiels pour manipuler des ensembles de données, permettant de créer des analyses précises et structurées. Avec ces fonctions, tu peux maintenant construire des analyses de données solides et professionnelles.

🌘 Pipelines en R : chaîner les opérations avec %>%

Le package magrittrpropose un opérateur de séquence qui permet de transformer des données de façon linéaire, sans avoir à réfléchir à l’ordre traditionnel des fonctions dans le langage SQL. Si tu veux filtrer les données, les aggréger, pour ensuite les fusionner à des données externes, tu peux l’écrire dans cet ordre. Voici un exemple:

# Charger les packages nécessaires
library(magrittr)
library(dplyr)

# Création de données d'exemple
donnees_ventes <- data.frame(
  produit = c("A", "B", "A", "C", "B", "A"),
  region = c("Nord", "Sud", "Nord", "Est", "Sud", "Est"),
  ventes = c(100, 150, 200, 130, 170, 110),
  mois = c("Jan", "Fev", "Jan", "Fev", "Jan", "Fev")
)

# Données externes à fusionner
donnees_region <- data.frame(
  region = c("Nord", "Sud", "Est"),
  responsable = c("Alice", "Bob", "Claire")
)

# Exemple de transformation linéaire avec l'opérateur %>%
resultat <- donnees_ventes %>%
  filter(mois == "Jan") %>%                          # Filtrer les ventes de Janvier
  group_by(produit, region) %>%                      # Grouper par produit et région
  summarise(total_ventes = sum(ventes), .groups = "drop") %>%  # Agréger les ventes
  left_join(donnees_region, by = "region") %>%       # Fusionner avec les données externes
  arrange(desc(total_ventes))                        # Trier par ventes décroissantes

# Afficher le résultat
print(resultat)

Je commence par charger les packages magrittr et dplyr. Je définis ensuite un jeu de données simple, donnees_ventes, qui contient des informations sur des ventes par produit, région, mois et montant.

Je veux transformer ces données étape par étape, exactement dans l’ordre où je pense le processus. Pour ça, j’utilise l’opérateur %>%, qui me permet de passer d’une opération à la suivante sans avoir à tout imbriquer.

D’abord, je filtre les lignes où le mois est “Jan” avec filter, pour conserver seulement les données du mois de janvier. Ensuite, je regroupe les données par produit et région avec group_by, puis j’agrège les ventes avec summarise pour obtenir le total par groupe.

Une fois ces calculs faits, je veux enrichir mes résultats en ajoutant le nom du responsable de chaque région, alors je fusionne avec donnees_region grâce à left_join. Enfin, pour une lecture plus claire, je trie les résultats du plus grand au plus petit avec arrange.

L’avantage de cette façon de faire c’est que chaque étape s’enchaîne naturellement, comme si je racontais une histoire. Avec ce style, tu n’as plus besoin de lire le code de l’intérieur vers l’extérieur, ni de créer des tables intermédiaires pour rendre le code lisible.

🌘 À retenir

Les données relationnelles en R sont gérées avec dplyr comme dans une base de données.
Une clé primaire identifie un enregistrement de manière unique ; une clé étrangère relie deux tables.
Les jointures (inner_join, left_join, etc.) sont essentielles pour combiner des dataframes.
group_by() et summarise() permettent d’agréger des données efficacement.
L’opérateur %>% rend le code plus lisible et linéaire.
dplyr fonctionne aussi avec des bases de données externes via dbplyr.

🌘 FAQ

Q : Quelle est la différence entre inner_join et left_join ?
R : inner_join ne conserve que les lignes avec une correspondance dans les deux tables. left_join conserve toutes les lignes de la table de gauche, même sans correspondance.

Q : Peut-on utiliser dplyr avec une base de données SQL ?
R : Oui ! Avec dbplyr, tu peux écrire du code dplyr qui est automatiquement traduit en SQL.

Q : À quoi sert l’opérateur %>% ?
R : Il permet de chaîner les opérations de manière lisible, sans imbriquer les fonctions.

🌘 Références

🌘 Images

[1] Par User:AutumnSnow - Travail personnel, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=1313684

Maîtriser l'analyse de données relationnelles en R avec dplyr - jointures, clés et pipelines