Embedded Files
Chapitre 1 : Un Langage Puissant pour la Science des Données
Chapitre 1 : Un Langage Puissant pour la Science des Données
1. Genèse et avantages de R
1. Genèse et avantages de R
Le logiciel R trouve ses origines dans les années 1970 avec le développement du langage S par John Chambers et son équipe aux Bell Laboratories. À cette époque, S représentait une avancée majeure dans le domaine des statistiques, car il proposait une alternative interactive et programmable aux logiciels traditionnels, souvent rigides et peu flexibles. Ce langage offrait aux statisticiens la possibilité d’explorer les données de manière dynamique, d’automatiser des analyses complexes et de produire des visualisations avancées, bien que son utilisation fût alors limitée aux environnements Unix des Bell Labs.
C’est en 1993 que deux chercheurs de l’Université d’Auckland, en Nouvelle-Zélande, Ross Ihaka et Robert Gentleman, ont entrepris de créer R, un langage open source librement accessible, directement inspiré de S. Leur ambition était de démocratiser l’analyse statistique en fournissant un outil puissant, sans contraintes commerciales. Le nom « R » fait d’ailleurs référence à la fois au langage S dont il s’inspire et aux initiales de ses deux créateurs. Une première version stable de R a été publiée en 1995, suivie en 1997 par la création du CRAN (Comprehensive R Archive Network), un dépôt centralisé de packages qui constitue encore aujourd’hui l’épine dorsale de son écosystème.
Dès les années 2000, R a connu un essor remarquable, notamment grâce à son adoption massive dans les milieux universitaires, où il a progressivement remplacé des logiciels propriétaires comme SPSS, Minitab ou Stata. Cette popularité s’est accentuée avec l’émergence de packages innovants comme « ggplot2 » pour la visualisation, « dplyr » pour la manipulation de données ou caret pour le « machine learning ». R s’est également imposé dans le monde industriel, intégré dans les processus analytiques de grandes entreprises telles que Google, Facebook, Microsoft ou Netflix.
L’un des atouts majeurs de R réside dans sa gratuité et sa licence libre, ce qui le rend accessible aux étudiants, aux chercheurs, aux start-ups et aux organisations publiques ou à but non lucratif. Cette accessibilité favorise la transparence, la reproductibilité scientifique et l’expérimentation à grande échelle, éléments essentiels dans un contexte où la science ouverte prend une place croissante.
Au-delà de son caractère libre, R est reconnu pour la richesse de ses fonctionnalités statistiques. Il permet de réaliser aussi bien des analyses classiques (régression, ANOVA, tests d’hypothèse) que des approches plus avancées comme l’analyse bayésienne, l’apprentissage automatique, l’analyse spatiale ou le traitement de séries temporelles. Cet éventail en fait un outil de référence pour les statisticiens, les data scientists et les chercheurs de nombreuses disciplines.
L’écosystème de R repose sur un modèle particulièrement dynamique : les utilisateurs peuvent enrichir le langage via des packages, extensions qui permettent d’adresser des besoins très spécifiques. Cela a donné naissance à des infrastructures spécialisées telles que Bioconductor en bioinformatique, qui facilite l’analyse des données génomiques. Cette modularité a fait de R un environnement capable d’évoluer en permanence avec les besoins de la recherche et de l’industrie.
La cohérence syntaxique de nombreux outils R, en particulier ceux du « tidyverse », constitue également un avantage pédagogique et technique important. En suivant une logique unifiée de manipulation, transformation, visualisation et communication des données, R permet de structurer efficacement un projet tout en facilitant la lecture et la maintenance du code.
Techniquement, bien que R soit un langage interprété, il offre des interfaces performantes avec le C, le C++ et le Fortran, ce qui lui permet d’exécuter des calculs intensifs avec efficacité. Des outils comme Rcpp, data.table ou parallel permettent par ailleurs d’optimiser les performances ou de paralléliser les traitements pour traiter des volumes de données conséquents.
L’interopérabilité est un autre point fort de R : il peut communiquer facilement avec d’autres langages de programmation comme Python (via reticulate), interagir avec des bases de données relationnelles ou NoSQL, s’intégrer à des environnements Big Data comme Hadoop et Spark, ou encore s’adapter à des infrastructures cloud (AWS, Google Cloud, etc.). Cette capacité à s’insérer dans des architectures modernes fait de R un outil parfaitement aligné avec les exigences actuelles en matière de science des données.
Enfin, R s’appuie sur une communauté mondiale active, solidaire et très productive. Elle contribue non seulement au développement de nouveaux packages, mais aussi à la diffusion des bonnes pratiques via des forums, conférences internationales, livres, tutoriels interactifs et cours en ligne. Cette dynamique collective constitue un levier puissant pour apprendre, progresser, et résoudre rapidement des problèmes complexes.
L'engagement de cette communauté en faveur de la recherche reproductible s’est également concrétisé à travers le développement d’outils comme « rmarkdown », « knitr » et plus récemment « Quarto » [1], qui permettent de produire des rapports dynamiques mêlant texte, code, visualisations et résultats dans un format transparent et partageable. Cela renforce l’intégrité des analyses et favorise la collaboration entre chercheurs, professionnels et décideurs.
Ainsi, maîtriser R aujourd’hui ne revient pas seulement à apprendre un langage de programmation statistique, mais à s’approprier un véritable écosystème, en constante évolution, qui allie rigueur scientifique, souplesse technique et puissance collaborative. Que l’on soit étudiant, chercheur ou professionnel des données, investir dans l’apprentissage de R, c’est acquérir un avantage stratégique durable dans un monde de plus en plus guidé par la donnée.
2. R et la science des données
2. R et la science des données
La science des données est un domaine vaste qu’il est impossible de maîtriser dans son intégralité d’un seul coup. L’essentiel est de construire une base solide sur les outils fondamentaux et de développer la capacité à trouver les bonnes ressources pour approfondir ses connaissances en fonction des besoins. Un projet typique en science des données suit généralement un processus structuré.
La première étape d’un projet en science des données consiste à importer les données dans R. Cela signifie souvent lire des données stockées dans un fichier (comme un fichier CSV), une base de données ou une API web, pour les charger dans un tableau de données (appelé data frame dans R). Sans cette étape, toute analyse devient impossible, car si les données ne sont pas dans R, il n’y a rien à analyser.
Une fois les données importées, il est essentiel de les organiser correctement. Cette étape, qu’on appelle souvent la mise en forme « tidy », consiste à structurer les données de manière cohérente : chaque colonne représente une variable, et chaque ligne une observation. Ce format facilite grandement le travail, car il permet d’appliquer les fonctions d’analyse sans avoir à adapter sans cesse la structure des données.
Une fois les données rangées, on passe à leur transformation. Cela peut consister à filtrer les observations pertinentes (comme un pays spécifique ou une période donnée), à créer de nouvelles variables à partir de celles existantes (par exemple, calculer une vitesse à partir d’une distance et d’un temps), ou encore à produire des statistiques résumées (moyennes, totaux, pourcentages, etc.). Ranger et transformer les données sont des opérations regroupées sous le terme data wrangling, qui traduit bien l’idée que préparer les données est parfois un véritable défi.
Avec des données propres et bien préparées, deux approches complémentaires permettent d’en extraire des connaissances : la visualisation et la modélisation. Dans la pratique, on alterne souvent entre les deux, car chacune éclaire les données sous un angle différent.
La visualisation est une activité profondément humaine. Elle permet de détecter des tendances inattendues, de poser de nouvelles questions, ou de réaliser que certaines données ne répondent pas vraiment à la problématique initiale. Une bonne visualisation peut surprendre, mais elle ne s’automatise pas facilement : elle nécessite l’interprétation humaine.
La modélisation, à l’inverse, repose sur des méthodes mathématiques ou statistiques. Elle permet d’apporter des réponses précises à des questions bien définies, et s’adapte bien à l’automatisation. Même si certains modèles exigent une puissance de calcul importante, il est généralement plus facile d’ajouter des ressources informatiques que de mobiliser plus d’analystes. Toutefois, un modèle repose sur des hypothèses qu’il ne remet pas en question : il peut répondre, mais il ne peut pas vous surprendre.
L’étape suivante, souvent sous-estimée mais cruciale, est la communication. Peu importe la qualité de vos visualisations ou de vos modèles, si vous n’arrivez pas à transmettre clairement vos résultats, votre analyse aura peu d’impact. Que ce soit à travers un rapport, une présentation ou un tableau de bord interactif, partager vos conclusions de manière compréhensible est indispensable.
Toutes ces étapes sont soutenues par une compétence transversale : la programmation. Même s’il n’est pas nécessaire d’être un développeur expert, progresser en programmation permet d’automatiser les tâches répétitives, d’explorer des pistes plus complexes, et de travailler de manière plus efficace. C’est un apprentissage progressif, mais qui porte ses fruits à long terme.
Les outils présentés ici constituent le socle fondamental de tout projet en science des données. Ils permettent d’aborder les étapes clés : importer, organiser, transformer, visualiser, modéliser et communiquer les données. Ce cadre s’applique à la grande majorité des situations, quel que soit le domaine d’application, et constitue une méthode de travail robuste et réutilisable.
Cela dit, la réalité des projets est souvent plus complexe. La diversité des contextes, des données et des objectifs fait qu’aucun ensemble d’outils, aussi complet soit-il, ne peut couvrir tous les cas. Les fondations présentées ici permettent de traiter environ 80 % des besoins courants, mais certains projets exigent d’aller au-delà. Il peut s’agir de volumes de données très importants, de formats non standards, de visualisations interactives avancées, de modèles prédictifs sophistiqués, ou encore d’intégration dans des systèmes d’information existants. Ces situations demandent souvent de faire preuve de souplesse, d’exploration, voire de créativité.
Cela ne doit pas décourager. Au contraire : maîtriser les bases donne une véritable autonomie. Cela vous permet d’aborder vos projets avec méthode, de poser les bonnes questions, de structurer votre réflexion et d’identifier clairement les limites des outils. Cette lucidité est précieuse, car elle oriente vos choix et vous aide à décider quand une solution simple suffit, et quand il est pertinent de chercher plus loin. En somme, les fondamentaux sont le point de départ pour progresser dans un domaine aussi riche qu’évolutif.
Pour illustrer cette idée de manière concrète, je reprends ici une analogie bien connue proposée par Greg Snow, statisticien reconnu et contributeur actif de la communauté R, notamment auteur du package TeachingDemos pour l’enseignement de la statistique. Il compare les logiciels comme SPSS à des bus : faciles à utiliser, tant que l’on connaît l’itinéraire, les arrêts, et qu’on a un ticket. Ils conviennent parfaitement aux trajets simples et standardisés. Mais dès qu’on souhaite sortir des parcours prévus, ils deviennent limités, voire frustrants. R, en revanche, est comparable à un SUV tout-terrain – écologique, avec un vélo accroché à l’arrière, un kayak sur le toit, des chaussures de randonnée sur le siège passager, et même du matériel d’escalade dans le coffre. En d’autres termes, c’est un outil extrêmement polyvalent, capable de vous mener là où aucun bus ne va. Il permet d’explorer des terrains complexes, de personnaliser l’analyse et d’innover – à condition d’apprendre à se servir de tout cet équipement.
Cette métaphore souligne parfaitement que R demande plus d’apprentissage au départ, mais qu’il offre en échange une liberté et une puissance analytique inégalées, particulièrement précieuses dans un monde guidé par la donnée.
3. Prérequis
3. Prérequis
Avant de commencer, il est utile d’avoir quelques bases pour tirer pleinement parti du contenu de ce document. Il est recommandé d’avoir une certaine aisance avec les chiffres (sans être expert en statistiques), et si vous avez déjà une petite expérience de la programmation, ce sera un plus. Si ce n’est pas le cas, pas de panique : il est tout à fait possible de progresser en parallèle.
Ce dont vous avez besoin pour démarrer :
Ce dont vous avez besoin pour démarrer :
Pour exécuter du code R dans de bonnes conditions, vous aurez besoin de quatre éléments principaux :
1. R : le langage de base à installer sur votre ordinateur.
2. RStudio : un environnement de développement (IDE) convivial qui facilite l’utilisation de R.
3. Le tidyverse : un ensemble de packages incontournables pour la manipulation, la visualisation et l’analyse des données.
4. Quelques packages complémentaires : utiles selon les types de données ou d’analyses que vous souhaitez réaliser.
1. Installer R
1. Installer R
R est le moteur de votre travail. Pour l’installer, rendez-vous sur le site officiel du CRAN : https://cloud.r-project.org. Une version majeure sort chaque année, accompagnée de quelques mises à jour mineures.
Il est conseillé de mettre R à jour régulièrement pour profiter des dernières améliorations. À noter : lorsqu’une version majeure sort, il peut être nécessaire de réinstaller vos packages, ce qui peut sembler contraignant… mais attendre trop longtemps rend les choses encore plus complexes. Pour commencer, utilisez idéalement R version 4.5.0 ou ultérieure.
Accueil du site CRAN : Choix de votre système d’exploitation :
Le site CRAN héberge les fichiers d’installation de R pour différents systèmes d’exploitation. Téléchargez la version de R adaptée à votre système (Windows, macOS ou Linux). Cliquez sur le lien « Download R for Windows » si vous utilisez un ordinateur sous Windows.
Choix de la version de R pour Windows :
Téléchargez l’installateur pour une première installation de R en cliquant sur le lien « install R for the first time », situé en haut à droite. Ce lien vous redirige vers la dernière version stable de R adaptée aux utilisateurs débutants ou non-développeurs.
Téléchargement de la version actuelle de R pour Windows :
Vous êtes maintenant sur la page qui vous permet de télécharger la dernière version de R (ici, la version 4.5.0). Lancez le téléchargement de l’installateur en cliquant sur « Download R-4.5.0 for Windows » (le lien principal en bleu) pour télécharger le fichier .exe (installateur de R).
2. Installer RStudio
2. Installer RStudio
RStudio est actualisé plusieurs fois par an et vous informera automatiquement lorsqu’une nouvelle version est disponible. Pour bien débuter, assurez-vous d’avoir au minimum la version 2025.05.0.
Lorsque vous ouvrez RStudio, vous verrez quatre zones principales :
Ci-dessus, la fenêtre de RStudio sous Windows, affichée dans sa configuration par défaut. En suivant le sens des aiguilles d’une montre, on y trouve : la zone de script (où l’on écrit le code), l’environnement (qui affiche les objets créés), l’onglet des packages (pour gérer les extensions R), et enfin la console (où le code est exécuté).
3. Comprendre et utiliser les packages dans R
3. Comprendre et utiliser les packages dans R
Un package R est un module qui regroupe des fonctions, des jeux de données, et de la documentation visant à étendre les capacités de R. C’est l’un des atouts majeurs de ce langage : une communauté active développe continuellement de nouveaux outils pour répondre à des besoins variés – modélisation statistique, visualisation, traitement de texte, interaction avec des bases de données, apprentissage automatique, etc.
Quand vous installez R, seuls les packages originels (appelés base packages) sont disponibles. Pour accéder à d'autres fonctionnalités avancées, vous devrez installer et charger les packages correspondants.
Installer puis charger un package
Pour installer un package depuis le CRAN (dépôt officiel de R), utilisez la commande suivante dans la console R :
install.packages("nom_du_package")
Par exemple, pour installer le package ggplot2 :
install.packages("ggplot2")
Vous n'avez besoin d'installer un package qu'une seule fois sur une machine. En revanche, vous devrez le charger à chaque nouvelle session avec library() pour pouvoir utiliser ses fonctions.
Une fois le package installé, vous pouvez le charger avec :
library(nom_du_package)
Par exemple :
library(ggplot2)
Si vous oubliez de charger le package, R ne reconnaîtra pas les fonctions qu’il contient.
Il est conseillé de respecter les bonnes pratiques suivantes avec les packages :
Chargez toujours vos packages au début de vos scripts pour plus de clarté.
Pour nettoyer l’environnement de travail (par exemple quand un package entre en conflit avec un autre), utilisez detach() ou redémarrez la session.
Pour consulter la documentation d’un package : help(package = "nom_du_package") ou ?nom_fonction.
Le tidyverse : un écosystème cohérent
Le tidyverse est un ensemble de packages développés pour rendre l’analyse de données plus fluide, cohérente et lisible. Ils partagent une grammaire commune, facilitent le chaînage des opérations avec le pipe (|>) ou (%>%), et s’appuient sur le principe des données bien rangées (tidy data).
Pour installer l’ensemble du tidyverse :
install.packages("tidyverse")
Puis pour le charger :
library(tidyverse)
Cette commande active un ensemble de packages essentiels :
ggplot2 : pour la visualisation de données.
dplyr : pour la manipulation de tableaux de données (filtrage, regroupement, résumé).
tidyr : pour restructurer les jeux de données.
readr : pour lire rapidement des fichiers plats (.csv, .tsv).
purrr : pour la programmation fonctionnelle (itérations).
tibble : une version modernisée des data frames.
stringr : pour manipuler des chaînes de caractères.
forcats : pour manipuler des variables catégorielles (facteurs).
lubridate : pour travailler efficacement avec les dates et les heures.
Les packages du tidyverse (et les autres) évoluent régulièrement. Pour vérifier si une mise à jour est disponible pour l’un d’entre eux, utilisez :
tidyverse_update()
Pour mettre à jour tous les packages installés :
update.packages(ask = FALSE)
Explorer l’univers des packages
Vous trouverez des milliers de packages sur le CRAN, mais aussi sur GitHub, Bioconductor (pour la bio-informatique), ou d'autres dépôts spécialisés.
Pour rechercher un package en fonction d’un besoin :
Utilisez Rseek.org, rdocumentation.org, ou le moteur de recherche du CRAN.
Essayez install.packages("pacman"), puis pacman::p_search("keyword") pour une recherche directe depuis R.
4. Gérer les dépendances avec renv : bonnes pratiques de projet
Travailler sur un projet R implique souvent l'utilisation de nombreux packages. Or, ces packages sont régulièrement actualisés. Un code qui fonctionne aujourd’hui peut échouer demain si un package change ou disparaît.
Problème : Sans gestion explicite des dépendances, il devient difficile de reproduire une analyse dans le futur, ou sur un autre ordinateur.
Solution : Le package renv permet de créer un environnement de travail isolé pour chaque projet, dans lequel les versions exactes des packages sont enregistrées et restaurables à tout moment.
renv signifie REproducible eNVironments. C’est un outil qui :
Crée un environnement isolé pour un projet R (similaire à un « environnement virtuel » en Python).
Sauvegarde toutes les versions des packages utilisés dans ce projet dans un fichier renv.lock.
Permet de recréer le même environnement sur une autre machine ou plus tard.
Imaginons que vous réalisez une étude économétrique en 2025 avec dplyr, ggplot2, et fixest. Un an plus tard, vous reprenez votre code mais vos résultats sont différents… Pourquoi ? Parce qu’un package a été mis à jour ou que sa syntaxe a changé. Avec renv, ce genre de mauvaise surprise est évité.
Comment mettre en place renv dans un projet :
Étape 1 : Initialiser un projet RStudio
Avant tout, créez un projet RStudio (File > New Project). Cela permet de bien séparer vos différents projets analytiques.
Étape 2 : Installer et activer renv
Une seule fois sur votre machine :
install.packages("renv")
Ensuite, dans le projet en question :
renv::init()
Remarque : Contrairement à la plupart des packages R, vous n’avez pas besoin de faire library(renv) à chaque session. Dès que vous initialisez un projet avec renv::init(), R charge automatiquement les fonctions nécessaires de renv en arrière-plan pour assurer le bon fonctionnement de l’environnement isolé.
Cette commande :
crée un dossier renv/ dans votre projet,
installe les packages localement dans ce dossier,
génère un fichier renv.lock qui liste les packages utilisés et leurs versions exactes.
Une fois "renv" initialisé, vous pouvez travailler normalement. Tous les packages que vous installez seront stockés localement dans le projet, pas dans votre bibliothèque globale. Cela garantit que d'autres projets ne seront pas affectés.
Étape 3 : Sauvegarder l’environnement
Après avoir installé ou mis à jour des packages, vous devez mettre à jour le fichier renv.lock :
renv::snapshot()
Ce fichier contient toutes les informations nécessaires pour reconstruire votre environnement à l’identique, y compris sur un autre ordinateur.
Étape 4 : Restaurer un environnement
Si vous ouvrez ce projet sur un autre ordinateur (ou après plusieurs mois), vous pouvez restaurer l’environnement avec :
renv::restore()
renv téléchargera automatiquement les versions de packages mentionnées dans renv.lock, assurant ainsi la reproductibilité intégrale.
Chapitre 2 : Visualisation de données avec ggplot2
Chapitre 2 : Visualisation de données avec ggplot2
“The simple graph has brought more information to the data analyst’s mind than any other device.” - John Tukey.
Cette citation résume une idée fondamentale en analyse des données : une visualisation claire et bien conçue peut révéler des insights plus efficacement qu’un tableau de chiffres ou un modèle complexe. Un graphique simple (comme un nuage de points, un histogramme ou un boxplot) permet de détecter visuellement des tendances, des anomalies ou des corrélations qui pourraient passer inaperçues dans des données brutes. Par exemple, une droite de régression montrant une relation entre deux variables est plus parlante qu’un coefficient seul. L’œil humain excelle à repérer des motifs, et un bon graphique exploite cette capacité. John Tukey, pionnier de l’analyse exploratoire, insistait sur ce point : pour comprendre les données, il faut d’abord les voir. Contrairement aux outils statistiques opaques, un graphique rend l’information accessible et actionnable. C’est pourquoi, dans la pratique, un simple tracé vaut souvent mieux qu’un long rapport.
R propose plusieurs approches pour réaliser des graphiques, mais « ggplot2 » est l’une des plus élégantes et puissantes. Il repose sur la grammaire des graphiques (grammar of graphics), un langage structuré qui permet de construire des visualisations de manière claire, progressive et cohérente.
Dans ce chapitre, nous nous appuierons sur ggplot2 pour explorer plusieurs types de données économiques et financières, notamment les séries macroéconomiques, comme le PIB, l’inflation, le chômage ou les taux d’intérêt, que l’on peut représenter à travers des graphiques temporels, et les données de marchés financiers, telles que les cours boursiers, les rendements ou les volumes de transactions, souvent visualisées avec des courbes ou des chandeliers.
Grâce à ggplot2, vous apprendrez à représenter visuellement ces données de manière expressive et structurée, pour en faciliter la compréhension, l’analyse et la communication.
Dans ce chapitre, vous allez :
Créer vos premiers graphiques avec ggplot2.
Visualiser la distribution de variables économiques.
Analyser les relations entre plusieurs variables (ex. : chômage et inflation).
Enregistrer vos graphiques.
Apprendre à interpréter les erreurs fréquentes.
Ce chapitre repose sur les packages suivants :
library(tidyverse) # ggplot2, dplyr, tidyr, etc.
library(ggthemes) # Thèmes graphiques (dont palettes daltoniens)
library(WDI) # Accès aux données de la Banque mondiale
library(quantmod) # Données boursières
library(tidyquant) # Interface tidyverse pour données financières
Si l’un de ces packages n’est pas installé, exécutez au préalable :
install.packages("nom_du_package")
Vous pouvez aussi installer plusieurs packages R en une seule commande avec install.packages() en passant un vecteur de noms de packages :
install.packages(c("tidyverse", "ggthemes", "WDI", "quantmod", "tidyquant"))
1. Premiers pas
1. Premiers pas
Posons une question simple : Les périodes de forte inflation sont-elles associées à une baisse du chômage ? C’est le cœur du dilemme de la courbe de Phillips illustrant le conflit entre deux objectifs économiques majeurs : la stabilité des prix et le plein emploi. À court terme, la courbe de Phillips suggère une relation inverse entre l'inflation et le chômage : une politique économique expansionniste (comme une hausse des dépenses publiques ou une baisse des taux d'intérêt) peut stimuler la demande, réduire le chômage, mais aussi provoquer une hausse des prix. Inversement, une politique restrictive (comme une baisse des dépenses publiques ou une hausse des taux) peut freiner l'inflation mais risque d'augmenter le chômage.
Avant de modéliser, on commence toujours par visualiser :
Quelle est la forme de la relation inflation ↔ chômage ?
Est-elle linéaire ? négative ? non linéaire ?
Varie-t-elle selon le pays ou l’époque ?
1.1 Chargement et exploration des données
1.1 Chargement et exploration des données
Nous utilisons ici les données de la Banque mondiale via le package WDI :
library(WDI)
indics <- c("FP.CPI.TOTL.ZG", "SL.UEM.TOTL.ZS") # inflation et chômage
df <- WDI(country = c("FRA", "DEU", "USA"), indicator = indics, start = 2000, end = 2020)
glimpse(df)
Variables clés :
country: nom du pays
year: année
FP.CPI.TOTL.ZG: inflation (%)
SL.UEM.TOTL.ZS: taux de chômage (%)
Renommons pour simplifier :
df <- df |> rename(inflation = FP.CPI.TOTL.ZG, unemployment = SL.UEM.TOTL.ZS)
1.2 Visualisation avec ggplot
1.2 Visualisation avec ggplot
Nous allons créer une visualisation qui montre la relation entre taux d’inflation et chômage, avec :
chaque point représentant un pays et une année
une courbe de tendance superposée
des couleurs distinctes pour chaque pays
Création d’un graphique ggplot
On commence par la structure de base :
ggplot(df, aes(x = unemployment, y = inflation))
Rien ne s’affiche encore — c’est une toile vide.
Ajoutons les points :
ggplot(df, aes(x = unemployment, y = inflation)) + geom_point()
Graphique simple, avec des points pour chaque pays/année.
Ajoutons une couleur pour différencier les pays :
ggplot(df, aes(x = unemployment, y = inflation, color = country)) + geom_point()
Ajoutons maintenant une courbe de tendance linéaire :
ggplot(df, aes(x = unemployment, y = inflation, color = country)) +
geom_point() + geom_smooth(method = "lm", se = FALSE)
Chaque pays a sa propre droite de régression.
Mais si nous voulons une tendance globale (sans distinction par pays), on place color = country uniquement dans geom_point() :
ggplot(df, aes(x = unemployment, y = inflation)) + geom_point(aes(color = country)) +
geom_smooth(method = "lm", se = FALSE)
Ajoutons maintenant titre, sous-titre, légendes et palette adaptée :
ggplot(df, aes(x = unemployment, y = inflation)) +
geom_point(aes(color = country)) +
geom_smooth(method = "lm", se = FALSE) +
labs(title = "Inflation et chômage (2000–2020)",
subtitle = "Relation pour les États-Unis, l’Allemagne et la France",
x = "Taux de chômage (%)",
y = "Taux d’inflation (%)",
color = "Pays" ) + scale_color_colorblind()
Et voilà : une visualisation économiquement pertinente !
2. Appels à ggplot2
2. Appels à ggplot2
Jusqu’ici, nous avons utilisé des appels très explicites à ggplot(), avec des noms d’arguments comme data = ..., mapping = aes(...), etc.
Exemple détaillé :
ggplot(data = df, mapping = aes(x = unemployment, y = inflation)) + geom_point()
Mais en pratique, les deux premiers arguments de ggplot() (data et mapping) sont tellement fréquents qu’on peut écrire plus simplement:
ggplot(df, aes(x = unemployment, y = inflation)) + geom_point()
Cela améliore la lisibilité et réduit la saisie, en mettant en avant ce qui change vraiment d’un graphique à l’autre.
Utilisation du pipe (|>)
Pour rendre votre code plus fluide, vous pouvez également utiliser l’opérateur pipe (|>), introduit dans R 4.1 :
df |> ggplot(aes(x = unemployment, y = inflation)) + geom_point()
Ce style est recommandé dans les projets d’analyse reproductible.
Étape par étape
✅ 1. df |>
df est un data frame (un tableau de données en R).
Le symbole |> est l'opérateur pipe natif de R (introduit depuis R 4.1).
Il permet de passer df comme premier argument à la fonction suivante (ici ggplot()).
C’est une manière plus lisible d’enchaîner des opérations sans trop de parenthèses imbriquées.
⚠️ Alternative équivalente :
ggplot(df, aes(x = unemployment, y = inflation)) + geom_point()
✅ 2. ggplot(aes(x = unemployment, y = inflation))
Appelle la fonction ggplot() du package ggplot2.
Définit le graphe de base, en disant que :
o unemployment (chômage) est placé sur l’axe des x,
o inflation est placé sur l’axe des y.
aes() signifie aesthetics : c’est ici qu’on déclare quelles variables vont contrôler la position, la couleur, la taille, etc.
✅ 3. + geom_point()
geom_point() ajoute une couche graphique (layer) de type nuage de points (scatter plot).
Cela permet de visualiser chaque observation sous forme de point (x, y).
Chaque point du graphique représentera donc un couple (unemployment, inflation).
📈 Ce que fait le code au final
Il crée un nuage de points représentant la relation entre le taux de chômage (unemployment) et le taux d’inflation (inflation) dans le jeu de données df.
3. Visualisation de distributions
3. Visualisation de distributions
Visualiser la distribution d’une variable permet de :
comprendre sa forme (symétrie, asymétrie…)
détecter des anomalies
préparer des modèles statistiques
La méthode dépend du type de variable :
catégorielle : diagramme en barres
numérique : histogramme, densité, boxplot
Une variable catégorielle
Prenons l’exemple d’un jeu de données contenant des pays classés par revenu :
install.packages("gapminder")
library(gapminder)
data(gapminder)
# Convertissons le niveau de revenu en facteur pour illustrer un cas catégoriel
gapminder <- gapminder |>
mutate(income_group = case_when(
gdpPercap < 3000 ~ "Low",
gdpPercap < 10000 ~ "Lower-Middle",
gdpPercap < 25000 ~ "Upper-Middle",
TRUE ~ "High" )) |>
mutate(income_group = factor(income_group, levels = c("Low", "Lower-Middle", "Upper-Middle", "High")))
Diagramme en barres :
ggplot(gapminder, aes(x = income_group)) + geom_bar()
Cela montre combien de pays appartiennent à chaque groupe de revenu dans l’échantillon.
Réordonner les barres selon la fréquence :
ggplot(gapminder, aes(x = fct_infreq(income_group))) + geom_bar()
Une variable numérique
Prenons la variable psavert (taux d’épargne personnelle) du jeu economics (fourni par ggplot2) :
ggplot(economics, aes(x = psavert)) + geom_histogram(binwidth = 1)
Histogramme du taux d’épargne personnelle des ménages américains
Distribution légèrement asymétrique, pic autour de 5 à 10 %
Effet de binwidth :
# Trop petit
ggplot(economics, aes(x = psavert)) + geom_histogram(binwidth = 0.1)
Effet de binwidth :
# Trop grand
ggplot(economics, aes(x = psavert)) + geom_histogram(binwidth = 5)
Alternative : courbe de densité
ggplot(economics, aes(x = psavert)) + geom_density()
Cela donne une version lissée de l’histogramme, utile pour visualiser la forme générale de la distribution.
Comparaison : histogramme vs densité
ggplot(economics, aes(x = psavert)) +
geom_histogram(aes(y = ..density..), binwidth = 1, fill = "lightblue", color = "white") +
geom_density(color = "darkblue", linewidth = 1)
Cette superposition permet de comparer les deux approches.
4. Visualiser des relations
4. Visualiser des relations
Pour représenter une relation, il faut au minimum deux variables. Vous allez apprendre à :
créer des nuages de points pour deux variables numériques
faire des boxplots ou diagrammes en barres empilées pour des croisements de variables catégorielles et numériques
ajouter des esthétiques supplémentaires (couleur, forme, taille…)
utiliser le facettage pour créer des sous-graphes
Une variable numérique et une variable catégorielle
Prenons l’exemple de la variable gdpPercap (PIB par habitant) du jeu gapminder, et analysons sa répartition par continent (variable catégorielle).
Boîte à moustaches
ggplot(gapminder, aes(x = continent, y = gdpPercap)) + geom_boxplot()
Ce graphique montre comment le PIB par habitant varie selon les continents.
On peut y détecter :
la médiane
la variabilité
d’éventuels valeurs extrêmes (outliers)
Densité par groupe
ggplot(gapminder, aes(x = gdpPercap, color = continent)) + geom_density(linewidth = 1)
Les distributions sont superposées, ce qui permet de comparer la forme (asymétrie, étendue) entre continents.
Densité remplie avec transparence
ggplot(gapminder, aes(x = gdpPercap, fill = continent, color = continent)) + geom_density(alpha = 0.4)
L’argument alpha règle la transparence (entre 0 et 1). Cela permet de visualiser les recouvrements.
Deux variables catégorielles
Imaginons que vous souhaitez représenter la répartition des régions du monde selon le groupe de revenu (income_group) défini précédemment:
ggplot(gapminder, aes(x = continent, fill = income_group)) +
geom_bar()
Les barres représentent le nombre de pays dans chaque continent, décomposé par niveau de revenu.
Pour afficher les proportions relatives :
ggplot(gapminder, aes(x = continent, fill = income_group)) +
geom_bar(position = "fill")
Chaque barre a une hauteur de 1 et affiche les parts relatives par catégorie.
Deux variables numériques
Prenons l’exemple de la durée médiane du chômage (uempmed) et du taux d’épargne (psavert) dans le jeu economics :
ggplot(economics, aes(x = uempmed, y = psavert)) + geom_point()
Ce nuage de points montre s’il existe une relation entre la durée moyenne de chômage et l’épargne des ménages.
Ajout d’une courbe de tendance :
ggplot(economics, aes(x = uempmed, y = psavert)) + geom_point() + geom_smooth(method = "lm")
Le graphique montre une relation négative entre la durée médiane du chômage (uempmed) et le taux d’épargne personnelle (psavert) : à mesure que la durée du chômage augmente, le taux d’épargne tend à diminuer. Cette tendance est illustrée par la droite de régression descendante, accompagnée d’un intervalle de confiance. Cela suggère qu’en période de chômage prolongé, les ménages réduisent leur capacité à épargner, probablement en raison de la baisse de revenu et de la nécessité de puiser dans leur épargne pour subvenir à leurs besoins.
Trois variables ou plus
Ajoutons une 3ème variable avec la couleur, par exemple l’année :
ggplot(economics, aes(x = uempmed, y = psavert)) + geom_point(aes(color = date)) + geom_smooth(method = "lm", se = FALSE)
Les couleurs forment un dégradé temporel. Cela donne une dimension chronologique à l’analyse.
Ce graphique illustre une relation négative entre la durée médiane du chômage (uempmed) et le taux d’épargne personnelle (psavert), tout en intégrant la dimension temporelle via une échelle de couleurs représentant les années. On observe que les points plus récents (bleu clair, années 2000–2010) sont associés à des durées de chômage plus longues et des taux d’épargne plus faibles, tandis que les observations plus anciennes (noir à bleu foncé, années 1970–1980) se situent principalement dans la zone de faible chômage et épargne plus élevée. Cette évolution suggère qu’au fil des décennies, la relation entre chômage prolongé et baisse de l’épargne s’est intensifiée, possiblement en lien avec des transformations structurelles du marché du travail et des comportements économiques des ménages.
Facettage par période
On peut aussi découper le graphe selon des sous-groupes. Créons une période (avant/après 2008) :
economics <- economics |> mutate(period = ifelse(date < as.Date("2008-01-01"), "Avant 2008", "Après 2008"))
ggplot(economics, aes(x = uempmed, y = psavert)) + geom_point() + facet_wrap(~period)
Deux sous-graphes distincts sont produits, facilitant la comparaison avant/après crise.
Ce graphique compare la relation entre la durée médiane du chômage (uempmed) et le taux d’épargne personnelle (psavert) avant et après 2008. On observe qu’avant 2008, la durée du chômage est généralement plus courte (entre 4 et 10 semaines) et le taux d’épargne plus dispersé, avec des valeurs souvent supérieures à 7 %. En revanche, après 2008, la durée médiane du chômage devient beaucoup plus longue (souvent supérieure à 15 semaines), tandis que le taux d’épargne reste globalement plus faible et moins variable. Ce changement suggère un effet durable de la crise financière de 2008, marquée par un allongement du chômage et une épargne plus contrainte ou stabilisée à un niveau bas.
5. Sauvegarder vos graphiques
5. Sauvegarder vos graphiques
Quand vous créez un graphique avec ggplot2 ou une autre fonction graphique dans R, vous pouvez soit :
Le sauvegarder manuellement via l'interface graphique de RStudio,
Soit le sauvegarder automatiquement en utilisant une commande R.
Méthode manuelle (via RStudio)
Une fois votre graphique affiché dans l’onglet Plots (en bas à droite de RStudio) :
Cliquez sur le bouton Export.
Choisissez Save as Image (image PNG, JPEG, etc.) ou Save as PDF.
Donnez un nom au fichier, choisissez un emplacement sur votre ordinateur.
Ajustez la taille et la résolution si nécessaire, puis cliquez sur Save.
Méthode scriptée (via commande R)
Vous pouvez utiliser la fonction ggsave() du package ggplot2 pour sauvegarder automatiquement un graphique.
# Créer un graphique
p <- ggplot(gapminder, aes(x = continent, fill = income_group)) +
geom_bar(position = "fill")
# Sauvegarder le graphique
ggsave("graphique_barre.png", plot = p, width = 8, height = 6, dpi = 300)
Cette commande sauvegarde le graphique p dans un fichier PNG nommé "graphique_barre.png" dans le dossier de travail courant.
Paramètres utiles de ggsave() :
filename : nom du fichier à créer (extension = format)
plot : l’objet graphique (optionnel si c’est le dernier graphique affiché)
width, height : taille en pouces
dpi : résolution (300 = bonne qualité pour impression)
Astuce : vérifier ou changer le répertoire de travail
Avant de sauvegarder un graphique, vous pouvez voir où il sera enregistré :
getwd() # Affiche le dossier de travail actuel
Vous pouvez changer ce dossier si nécessaire :
setwd("C:/Utilisateurs/mon_nom/Documents/Mes_graphiques"
Chapitre 3 : Workflow et bases du langage R
Chapitre 3 : Workflow et bases du langage R
Vous avez déjà commencé à écrire vos premières lignes de code en R, et c’est une excellente chose. Même si nous n’avons pas encore exploré tous les détails, votre progression prouve que vous avez franchi les premières étapes essentielles avec succès.
Il est tout à fait normal de rencontrer quelques blocages en chemin : apprendre à programmer, c’est aussi apprendre à dialoguer avec une machine qui, parfois, se montre intransigeante. Une virgule oubliée ou une parenthèse mal placée peuvent suffire à bloquer l’exécution d’un code. Mais ces petits obstacles sont inhérents à l’apprentissage, et ils deviennent vite plus faciles à surmonter avec un peu de pratique et de patience.
Avant d’approfondir davantage, prenons un moment pour consolider les bases : voyons comment exécuter correctement du code R et découvrons ensemble quelques fonctionnalités précieuses de RStudio qui vous accompagneront tout au long de votre parcours.
1. Le workflow de base : écrire, exécuter, corriger
1. Le workflow de base : écrire, exécuter, corriger
1.1. Notions fondamentales de codage
1.1. Notions fondamentales de codage
Revenons sur quelques bases que nous avons volontairement mises de côté jusque-là pour vous faire passer rapidement à la visualisation.
R peut être utilisé comme une calculatrice :
1 / (200 * 30)
(59 + 73 + 2) / 3
sin(pi / 2)
Vous pouvez créer des objets avec l’opérateur d’affectation <- :
x <- 3 * 4
Notez que la valeur de x n’est pas affichée automatiquement. Si vous souhaitez la voir, tapez simplement x dans la console.
Vous pouvez regrouper plusieurs éléments dans un vecteur avec la fonction c() :
primes <- c(2, 3, 5, 7, 11, 13)
Et les opérations mathématiques de base s’appliquent à chaque élément du vecteur :
primes * 2 # [1] 4 6 10 14 22 26
primes - 1 # [1] 1 2 4 6 10 12
Toutes les instructions d’affectation ont cette forme :
nom_objet <- valeur
Quand vous lisez cela, dites-vous dans votre tête : « le nom d'objet reçoit la valeur ».
Vous allez effectuer de nombreuses affectations, et <- est un peu long à taper. Gagnez du temps avec le raccourci clavier de RStudio : Alt + - (le signe moins). RStudio entoure automatiquement <- d’espaces, ce qui améliore la lisibilité du code — un bon réflexe à adopter dès le départ.
1.2. Les commentaires
1.2. Les commentaires
R ignore tout texte placé après un # sur une ligne. Cela permet d’écrire des commentaires, c’est-à-dire des textes qui seront lus par les humains, mais ignorés par R. Nous incluons parfois des commentaires dans nos exemples pour expliquer le fonctionnement du code.
Par exemple :
# créer un vecteur de nombres premiers
primes <- c(2, 3, 5, 7, 11, 13)
# multiplier les nombres premiers par 2
primes * 2
Avec un code aussi court, les commentaires peuvent sembler superflus. Mais dès que votre code devient plus complexe, les commentaires vous feront gagner un temps précieux.
Conseil : utilisez les commentaires pour expliquer le pourquoi du code, pas seulement ce qu’il fait. Le « quoi » et le « comment » peuvent souvent être déduits en lisant le code. En revanche, le « pourquoi » est souvent perdu si vous ne le notez pas.
Exemple : la fonction geom_smooth() accepte un argument span qui contrôle le degré de lissage de la courbe (plus la valeur est grande, plus la courbe est lisse). Si vous changez span de 0.75 à 0.9, il est facile de voir ce que fait le code, mais sans commentaire, personne ne saura pourquoi vous avez modifié cette valeur.
library(ggplot2)
# Visualisation de la relation entre la cylindrée (displ) et la consommation sur autoroute (hwy)
ggplot(mpg, aes(x = displ, y = hwy)) +
geom_point() +
# Application d'une courbe de lissage avec un span plus élevé
geom_smooth(span = 0.9, se = FALSE)
# Nous utilisons ici span = 0.9 pour rendre la courbe plus lisse,
# car les données sont très dispersées et un span trop bas génèrerait
# une courbe trop irrégulière qui risquerait de surinterpréter le bruit.
Dans une analyse de données, utilisez les commentaires pour décrire votre plan général et consignez les idées importantes au fil de l’exploration. Ces éléments ne peuvent pas être retrouvés en relisant simplement le code.
1.3. Ce qu’il y a dans un nom
1.3. Ce qu’il y a dans un nom
Les noms d’objets doivent :
commencer par une lettre,
contenir uniquement des lettres, des chiffres, des points (.) et des traits de soulignement (_).
Il est important que vos noms soient parlants, donc vous aurez besoin d'une convention pour les noms composés. Voici plusieurs styles utilisés en pratique :
i_use_snake_case : recommandé (mots en minuscules séparés par _)
otherPeopleUseCamelCase : majuscule au début de chaque mot sauf le premier
some.people.use.periods : chaque mot séparé par un point
And_aFew.People_RENOUNCEconvention : à éviter !
Faisons une affectation :
this_is_a_really_long_name <- 2.5
Vous pouvez tester l’autocomplétion de RStudio : tapez this, appuyez sur TAB, complétez jusqu’à un préfixe unique, puis appuyez sur Entrée.
Si vous vous rendez compte que la valeur devait être 3.5 et non 2.5, vous pouvez rappeler la dernière commande avec ↑, la modifier et la relancer. Ou tapez this, puis appuyez sur Ctrl/Cmd + ↑ pour voir toutes les commandes précédentes commençant par this.
Encore une affectation :
r_rocks <- 2^3
Puis testez des erreurs :
r_rock # Erreur : objet non trouvé
R_rocks # Erreur : casse incorrecte
Cela illustre bien le contrat implicite entre vous et R : R se charge des calculs, mais en échange, vous devez être précis dans vos instructions. Les fautes de frappe et erreurs de casse (r_rocks ≠ R_rocks) provoquent des erreurs. R ne devine pas ce que vous vouliez dire.
1.4. Appeler des fonctions
1.4. Appeler des fonctions
R possède un grand nombre de fonctions intégrées, qui se présentent ainsi :
nom_fonction(argument1 = valeur1, argument2 = valeur2, ...)
Essayons la fonction seq(), qui génère une séquence régulière :
seq(from = 1, to = 10)
# [1] 1 2 3 4 5 6 7 8 9 10
Souvent, on omet les noms des premiers arguments si leur signification est claire :
seq(1, 10)
Tapez ce qui suit pour tester les guillemets :
x <- "hello world"
Les guillemets et les parenthèses doivent toujours être par paires. Si vous oubliez de fermer une parenthèse ou un guillemet, R affichera le symbole +, indiquant qu’il attend encore des instructions.
Exemple :
> x <- "hello
+
Appuyez sur ESCAPE pour revenir à l’invite normale.
1.5. Carte de référence R : Fonctions essentielles
1.5. Carte de référence R : Fonctions essentielles
Le contenu de cette annexe est inspiré et adapté de la « R Reference Card » rédigée par Tom Short, un document de référence publié en domaine public. Il s’agit d’une fiche synthétique qui recense les fonctions les plus couramment utilisées en R, classées par thématique. La version originale en anglais est disponible sur le site du CRAN à l’adresse suivante :
https://cran.r-project.org/doc/contrib/Short-refcard.pdf
Cette version a été réorganisée et reformulée en français dans un but pédagogique, afin de faciliter son intégration dans des supports de cours ou d’auto-formation à R.
Vous avez déjà commencé à écrire vos premières lignes de code en R, et c’est une excellente chose. Même si nous n’avons pas encore exploré tous les détails, votre progression prouve que vous avez franchi les premières étapes essentielles avec succès.
Il est tout à fait normal de rencontrer quelques blocages en chemin : apprendre à programmer, c’est aussi apprendre à dialoguer avec une machine qui, parfois, se montre intransigeante. Une virgule oubliée ou une parenthèse mal placée peuvent suffire à bloquer l’exécution d’un code. Mais ces petits obstacles sont inhérents à l’apprentissage, et ils deviennent vite plus faciles à surmonter avec un peu de pratique et de patience.
Avant d’approfondir davantage, prenons un moment pour consolider les bases : voyons comment exécuter correctement du code R et découvrons ensemble quelques fonctionnalités précieuses de RStudio qui vous accompagneront tout au long de votre parcours.
2. Le workflow de base : écrire, exécuter, corriger
2. Le workflow de base : écrire, exécuter, corriger
2.1. Notions fondamentales de codage
2.1. Notions fondamentales de codage
Revenons sur quelques bases que nous avons volontairement mises de côté jusque-là pour vous faire passer rapidement à la visualisation.
R peut être utilisé comme une calculatrice :
1 / (200 * 30)
(59 + 73 + 2) / 3
sin(pi / 2)
Vous pouvez créer des objets avec l’opérateur d’affectation <- :
x <- 3 * 4
Notez que la valeur de x n’est pas affichée automatiquement. Si vous souhaitez la voir, tapez simplement x dans la console.
Vous pouvez regrouper plusieurs éléments dans un vecteur avec la fonction c() :
primes <- c(2, 3, 5, 7, 11, 13)
Et les opérations mathématiques de base s’appliquent à chaque élément du vecteur :
primes * 2 # [1] 4 6 10 14 22 26
primes - 1 # [1] 1 2 4 6 10 12
Toutes les instructions d’affectation ont cette forme :
nom_objet <- valeur
Quand vous lisez cela, dites-vous dans votre tête : « le nom d'objet reçoit la valeur ».
Vous allez effectuer de nombreuses affectations, et <- est un peu long à taper. Gagnez du temps avec le raccourci clavier de RStudio : Alt + - (le signe moins). RStudio entoure automatiquement <- d’espaces, ce qui améliore la lisibilité du code — un bon réflexe à adopter dès le départ.
2.2. Les commentaires
2.2. Les commentaires
R ignore tout texte placé après un # sur une ligne. Cela permet d’écrire des commentaires, c’est-à-dire des textes qui seront lus par les humains, mais ignorés par R. Nous incluons parfois des commentaires dans nos exemples pour expliquer le fonctionnement du code.
Par exemple :
# créer un vecteur de nombres premiers
primes <- c(2, 3, 5, 7, 11, 13)
# multiplier les nombres premiers par 2
primes * 2
Avec un code aussi court, les commentaires peuvent sembler superflus. Mais dès que votre code devient plus complexe, les commentaires vous feront gagner un temps précieux.
Conseil : utilisez les commentaires pour expliquer le pourquoi du code, pas seulement ce qu’il fait. Le « quoi » et le « comment » peuvent souvent être déduits en lisant le code. En revanche, le « pourquoi » est souvent perdu si vous ne le notez pas.
Exemple : la fonction geom_smooth() accepte un argument span qui contrôle le degré de lissage de la courbe (plus la valeur est grande, plus la courbe est lisse). Si vous changez span de 0.75 à 0.9, il est facile de voir ce que fait le code, mais sans commentaire, personne ne saura pourquoi vous avez modifié cette valeur.
library(ggplot2)
# Visualisation de la relation entre la cylindrée (displ) et la consommation sur autoroute (hwy)
ggplot(mpg, aes(x = displ, y = hwy)) +
geom_point() +
# Application d'une courbe de lissage avec un span plus élevé
geom_smooth(span = 0.9, se = FALSE)
# Nous utilisons ici span = 0.9 pour rendre la courbe plus lisse,
# car les données sont très dispersées et un span trop bas génèrerait
# une courbe trop irrégulière qui risquerait de surinterpréter le bruit.
Dans une analyse de données, utilisez les commentaires pour décrire votre plan général et consignez les idées importantes au fil de l’exploration. Ces éléments ne peuvent pas être retrouvés en relisant simplement le code.
2.3. Ce qu’il y a dans un nom
2.3. Ce qu’il y a dans un nom
Les noms d’objets doivent :
commencer par une lettre,
contenir uniquement des lettres, des chiffres, des points (.) et des traits de soulignement (_).
Il est important que vos noms soient parlants, donc vous aurez besoin d'une convention pour les noms composés. Voici plusieurs styles utilisés en pratique :
i_use_snake_case : recommandé (mots en minuscules séparés par _)
otherPeopleUseCamelCase : majuscule au début de chaque mot sauf le premier
some.people.use.periods : chaque mot séparé par un point
And_aFew.People_RENOUNCEconvention : à éviter !
Faisons une affectation :
this_is_a_really_long_name <- 2.5
Vous pouvez tester l’autocomplétion de RStudio : tapez this, appuyez sur TAB, complétez jusqu’à un préfixe unique, puis appuyez sur Entrée.
Si vous vous rendez compte que la valeur devait être 3.5 et non 2.5, vous pouvez rappeler la dernière commande avec ↑, la modifier et la relancer. Ou tapez this, puis appuyez sur Ctrl/Cmd + ↑ pour voir toutes les commandes précédentes commençant par this.
Encore une affectation :
r_rocks <- 2^3
Puis testez des erreurs :
r_rock # Erreur : objet non trouvé
R_rocks # Erreur : casse incorrecte
Cela illustre bien le contrat implicite entre vous et R : R se charge des calculs, mais en échange, vous devez être précis dans vos instructions. Les fautes de frappe et erreurs de casse (r_rocks ≠ R_rocks) provoquent des erreurs. R ne devine pas ce que vous vouliez dire.
2.4. Appeler des fonctions
2.4. Appeler des fonctions
R possède un grand nombre de fonctions intégrées, qui se présentent ainsi :
nom_fonction(argument1 = valeur1, argument2 = valeur2, ...)
Essayons la fonction seq(), qui génère une séquence régulière :
seq(from = 1, to = 10)
# [1] 1 2 3 4 5 6 7 8 9 10
Souvent, on omet les noms des premiers arguments si leur signification est claire :
seq(1, 10)
Tapez ce qui suit pour tester les guillemets :
x <- "hello world"
Les guillemets et les parenthèses doivent toujours être par paires. Si vous oubliez de fermer une parenthèse ou un guillemet, R affichera le symbole +, indiquant qu’il attend encore des instructions.
Exemple :
> x <- "hello
+
Appuyez sur ESCAPE pour revenir à l’invite normale.
2.5. Carte de référence R : Fonctions essentielles
2.5. Carte de référence R : Fonctions essentielles
Le contenu de cette annexe est inspiré et adapté de la « R Reference Card » rédigée par Tom Short, un document de référence publié en domaine public. Il s’agit d’une fiche synthétique qui recense les fonctions les plus couramment utilisées en R, classées par thématique. La version originale en anglais est disponible sur le site du CRAN à l’adresse suivante :
https://cran.r-project.org/doc/contrib/Short-refcard.pdf
Cette version a été réorganisée et reformulée en français dans un but pédagogique, afin de faciliter son intégration dans des supports de cours ou d’auto-formation à R.
Astuce finale :
Toutes ces fonctions peuvent être explorées plus en détail avec: ?nom_de_la_fonction dans R. Exemple : ?plot ou ?read.table.
Voici une sélection de fonctions R essentielles, présentées de manière claire et illustrées par des exemples concrets. L’objectif est de vous aider à comprendre leur utilité et leur contexte d’utilisation, afin de pouvoir les mobiliser efficacement dans vos propres analyses.
Aide et exploration
help() ou ?
Permet d’afficher l’aide intégrée à R pour mieux comprendre une fonction.
?mean
Explication : Affiche la documentation complète de la fonction mean(), avec sa syntaxe, ses arguments, et des exemples d'utilisation.
str()
Affiche la structure interne d’un objet (utile pour les jeux de données complexes).
str(mtcars)
Explication : Résume les types de chaque variable dans le data frame mtcars, le nombre de lignes, de colonnes et les premières valeurs de chaque colonne.
summary()
Fournit un résumé statistique ou descriptif d’un objet.
summary(mtcars$mpg)
Explication : Donne le minimum, le 1er quartile, la médiane, la moyenne, le 3e quartile et le maximum de la variable mpg (consommation).
Lecture et écriture de fichiers
read.csv()
Importe un fichier CSV (valeurs séparées par des virgules).
data <- read.csv("donnees.csv")
Explication : Charge les données depuis un fichier CSV dans un data frame appelé data.
write.table()
Exporte un tableau R vers un fichier texte.
write.table(data, file = "resultats.txt", sep = "\t")
Explication : Sauvegarde le tableau data dans un fichier texte avec tabulations comme séparateurs.
Création de vecteurs et de structures
c(), seq(), rep()
Fonctions de base pour créer des vecteurs.
x <- c(2, 4, 6)
y <- seq(1, 5, by = 1)
z <- rep("R", times = 3)
Explication :
c() crée un vecteur de valeurs.
seq() génère une séquence régulière.
rep() répète une valeur plusieurs fois.
data.frame()
Crée une table de données avec des colonnes nommées.
df <- data.frame(nom = c("Alice", "Bob"), age = c(25, 30))
Explication : Crée un tableau de deux lignes avec les colonnes nom et age.
Accès et manipulation des données
subset()
Filtre les lignes selon une condition.
subset(mtcars, cyl == 4)
Explication : Renvoie les voitures du data frame mtcars qui ont 4 cylindres.
match() et %in%
Vérifient si une valeur existe dans un vecteur.
"Toyota Corolla" %in% rownames(mtcars)
Explication : Renvoie TRUE si la voiture "Toyota Corolla" est une ligne de mtcars.
is.na() et na.omit()
Détecte ou supprime les valeurs manquantes.
x <- c(1, NA, 3)
is.na(x) # -> TRUE pour l'élément manquant
na.omit(x) # -> supprime l’élément manquant
Explication : Permet de gérer les données incomplètes dans les analyses.
Statistiques de base
mean(), sd(), cor()
Calcule la moyenne, l'écart-type, et la corrélation entre deux variables.
mean(mtcars$mpg)
sd(mtcars$hp)
cor(mtcars$mpg, mtcars$hp)
Explication :
Moyenne de consommation (mpg),
Écart-type de puissance (hp),
Corrélation linéaire entre consommation et puissance.
Fonctions mathématiques
log(), exp(), sqrt()
Fonctions usuelles : logarithme, exponentielle, racine carrée.
log(100) # Logarithme népérien
exp(2) # e^2
sqrt(16) # Racine carrée
Explication : Utilisées dans de nombreux calculs mathématiques ou statistiques.
Programmation
function()
Déclare une fonction personnalisée.
carre <- function(x) {
return(x^2)
}
carre(3)
Explication : Définit une fonction qui retourne le carré de son argument.
ifelse()
Applique une condition à chaque élément d’un vecteur.
x <- 1:5
ifelse(x %% 2 == 0, "pair", "impair")
Explication : Renvoie "pair" ou "impair" selon la parité de chaque nombre de x.
Chaînes de caractères
paste(), substr()
Concatène des chaînes ou extrait une sous-chaîne.
paste("Bonjour", "le monde")
substr("Statistique", 1, 4)
Explication :
paste() renvoie "Bonjour le monde".
substr() extrait "Stat" (les 4 premiers caractères).
Dates
as.Date() et seq.Date()
Gère des objets date et génère des séquences.
d <- as.Date("2023-01-01")
seq(d, by = "month", length.out = 3)
Explication : Crée une séquence de 3 mois à partir du 1er janvier 2023.
Visualisation de base
plot() et hist()
Crée un graphique de dispersion ou un histogramme.
plot(mtcars$hp, mtcars$mpg)
hist(mtcars$mpg)
Explication :
plot() montre la relation entre puissance et consommation.
hist() montre la répartition de la consommation.
Régression linéaire
lm() et summary()
Ajuste un modèle linéaire et affiche ses résultats.
mod <- lm(mpg ~ hp + wt, data = mtcars)
summary(mod)
Explication : Ajuste un modèle où mpg est expliqué par hp (puissance) et wt (poids). summary() donne les coefficients, R², etc.
3. Les fondations du langage R : les objets et structures de données
3. Les fondations du langage R : les objets et structures de données
Maintenant que vous êtes à l’aise avec l’exécution de code et l’écriture de vos premières instructions, il est temps de découvrir ce qui fait la véritable structure du langage R : ses objets. Ce sont eux qui portent toutes vos données, vos modèles, vos résultats. Apprendre à les connaître, c’est apprendre à parler le langage de R.
3.1. Tout est objet
3.1. Tout est objet
Quand vous travaillez avec R, vous ne manipulez jamais directement des valeurs isolées, mais des objets. C’est un concept fondamental : en R, toute donnée, tout résultat, toute fonction est un objet. Cela signifie que tout ce que vous créez, utilisez ou modifiez a une structure, un type et un comportement. Comprendre cette logique, c’est apprendre à « penser comme R ».
Un objet est une entité que vous créez avec un nom (variable) et qui contient une information. Par exemple :
x <- 5 # x est un objet qui contient la valeur 5
pays <- "France" # pays est un objet de type texte (character)
Ces objets peuvent représenter :
des valeurs simples (nombre, texte, booléen),
des vecteurs (suite de valeurs),
des matrices,
des listes,
des tables de données (data frames),
ou même des fonctions, des modèles statistiques, des graphiques, etc.
Comment connaître la nature d’un objet ?
R vous fournit plusieurs fonctions pour interroger un objet :
class(objet) : Indique la classe de l’objet (type général)
mode(objet) : Indique la nature du contenu
typeof(objet) : Indique le type interne (plus technique)
length(objet) : Donne le nombre d’éléments dans l’objet
attributes(objet) : Liste les attributs supplémentaires
str(objet) : Affiche une vue structurée de l’objet
➤ Exemple 1 : valeur simple
a <- 3.14
class(a) # "numeric"
length(a) # 1
➤ Exemple 2 : vecteur économique
inflation <- c(2.1, 2.5, 1.9)
names(inflation) <- c("2021", "2022", "2023")
class(inflation) # "numeric"
attributes(inflation) # montre les noms attachés
➤ Exemple 3 : fonction comme objet
f <- mean # on assigne la fonction "mean" à un objet
class(f) # "function"
f(c(1, 2, 3)) # 2
Même les fonctions sont des objets ! Vous pouvez les stocker, les manipuler, les passer en argument à d'autres fonctions.
Un objet peut avoir plusieurs dimensions
Un objet peut contenir d'autres objets, comme :
une liste (chaque élément est un objet à part entière),
un data frame (chaque colonne est un vecteur),
une fonction (elle peut contenir des instructions, des paramètres, etc.).
entreprise <- list( nom = "BNP", actifs = c(1000, 1100, 1050), cotée = TRUE)
str(entreprise)
Résumé à retenir
En R, tout est un objet.
Un objet a une classe, un contenu, et parfois des attributs.
Les fonctions, les modèles, les tableaux, les vecteurs… tout est manipulé comme un objet.
Connaître la structure d’un objet est essentiel pour le manipuler correctement.
3.2. Les vecteurs : la brique de base en R
3.2. Les vecteurs : la brique de base en R
En R, le vecteur est la structure de données la plus simple et la plus fondamentale.
C’est un peu comme la cellule d’un tableur ou la ligne d’un tableau : tout repose sur lui. Même un nombre seul est en réalité un vecteur de longueur 1.
En comprenant bien les vecteurs, vous posez les bases de toute manipulation de données en R, que ce soit pour :
stocker des séries temporelles (ex : taux de croissance),
enregistrer des données d’enquête (ex : réponses à un questionnaire),
effectuer des calculs statistiques simples.
Qu’est-ce qu’un vecteur ?
Un vecteur est un ensemble ordonné de valeurs qui ont toutes le même type (numérique, texte, logique…).
inflation <- c(2.1, 2.3, 1.8, 2.5)
Vous venez de créer un vecteur inflation contenant 4 nombres (type numeric). Ces valeurs sont automatiquement indexées de 1 à 4.
La fonction c() (pour combine) sert à créer un vecteur en combinant plusieurs valeurs.
pays <- c("France", "Allemagne", "Italie")
annees <- c(2020, 2021, 2022)
taux_chomage <- c(7.1, 6.8, 7.0)
Chaque ligne crée un vecteur de même type :
pays est un vecteur de texte (character),
annees et taux_chomage sont numériques (numeric).
Les types de vecteurs les plus courants sont :
numeric : Nombres réels ou entiers; exemple c(1.5, 2.0, 3.2)
character : Chaînes de caractères (textes); exemple c("euro", "yen", "dollar")
logical : Valeurs booléennes : TRUE ou FALSE; exemple c(TRUE, FALSE, TRUE)
integer : Nombres entiers (moins utilisé); exemple c(1L, 2L, 3L)
Attention : si vous mélangez les types dans un c(), R convertira automatiquement vers le type le plus général.
mixte <- c("France", 2023) # devient : c("France", "2023")
Vous pouvez utiliser ces fonctions pour interroger un vecteur :
length(x) : Longueur du vecteur (nombre d’éléments)
class(x) : Classe de l’objet (ex. "numeric")
typeof(x) : Type interne (plus précis)
is.numeric(x) : Teste si c’est un vecteur numérique
is.character(x) : Teste si c’est un vecteur de texte
On peut ajouter des noms aux éléments d’un vecteur pour rendre les données plus lisibles.
inflation <- c(1.5, 2.0, 1.8)
names(inflation) <- c("2020", "2021", "2022")
inflation["2021"] # renvoie 2.0
Opérations vectorielles
Les opérations mathématiques sont automatiquement appliquées à chaque élément.
prix <- c(100, 120, 150)
prix_TTC <- prix * 1.2
Le résultat est c(120, 144, 180).
C’est ce qu’on appelle la vectorisation : pas besoin de boucle.
Le recyclage des vecteurs
Quand deux vecteurs de longueurs différentes sont utilisés ensemble, R répète (ou « recycle ») les valeurs du plus court.
c(1, 2) + c(10, 20, 30, 40)
# Résultat : c(11, 22, 31, 42)
Si la longueur du long vecteur n’est pas un multiple exact de celle du court, R affiche un message d’avertissement.
Vecteurs logiques et filtrage
Les vecteurs logiques (TRUE, FALSE) sont très utiles pour filtrer des données.
revenus <- c(2000, 1800, 2500, 3000)
revenus > 2000 # [1] FALSE FALSE TRUE TRUE
revenus[revenus > 2000] # [1] 2500 3000
Quelques fonctions utiles avec les vecteurs :
sum(x) : Somme des éléments
mean(x) : Moyenne
sd(x) : Écart-type
min(x), max(x) : Minimum et maximum
sort(x) : Tri
unique(x) : Valeurs uniques
which(x > y) : Renvoie les positions où la condition est vraie
Exemples d’application économique
➤ Série de taux d’intérêt :
taux_interet <- c(0.5, 1.0, 1.5, 2.0)
names(taux_interet) <- 2019:2022
➤ Filtrer les pays avec un taux de chômage élevé :
chomage <- c(6.2, 5.1, 9.0)
names(chomage) <- c("France", "Allemagne", "Espagne")
chomage[chomage > 6]
# Résultat : "France" et "Espagne"
À retenir
Les vecteurs sont omniprésents en R.
Ils doivent être homogènes (même type).
Ils supportent des opérations vectorielles.
Ils peuvent être nommés, triés, filtrés.
Ils permettent de traiter rapidement des données numériques ou textuelles.
3.3. Matrices et tableaux : structurer les données à deux dimensions (ou plus)
3.3. Matrices et tableaux : structurer les données à deux dimensions (ou plus)
Dans le monde des données, il est fréquent de devoir organiser l’information en lignes et colonnes, comme dans un tableau Excel. En R, on utilise pour cela :
les matrices : pour des tableaux de valeurs homogènes (même type),
les tableaux (arrays) : pour des structures à plus de deux dimensions.
Ces objets sont très utiles pour :
représenter des séries économiques croisées (ex : taux d’inflation par pays et par année),
effectuer des opérations mathématiques matricielles (très fréquentes en économétrie),
organiser des données multidimensionnelles (ex : indicateurs pour différents pays, années, et secteurs).
Une matrice est un vecteur auquel on ajoute une structure en deux dimensions : un nombre de lignes et de colonnes.
Toutes les données d’une matrice doivent être du même type (généralement numérique).
Créer une matrice avec matrix()
m <- matrix(1:6, nrow = 2, ncol = 3)
Cela donne :
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
Par défaut, R remplit colonne par colonne. Pour remplir ligne par ligne :
m2 <- matrix(1:6, nrow = 2, byrow = TRUE)
Cela donne :
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
Nommage des lignes et colonnes
Comme pour les vecteurs, vous pouvez donner des noms aux lignes et colonnes :
rownames(m) <- c("France", "Allemagne")
colnames(m) <- c("2020", "2021", "2022")
Cela facilite l’interprétation, surtout avec des données économiques.
Exemple concret : taux de croissance du PIB
croissance <- matrix(c(1.5, 1.8, 2.0, 2.1, 1.9, 2.3), nrow = 2, byrow = TRUE)
rownames(croissance) <- c("France", "Allemagne")
colnames(croissance) <- c("2020", "2021", "2022")
croissance
Résultat :
2020 2021 2022
France 1.5 1.8 2.0
Allemagne 2.1 1.9 2.3
Accéder à des éléments d’une matrice
Les crochets [ligne, colonne] permettent de lire ou modifier un élément:
Accéder à une cellule : croissance[1, 2]; résultat France 1.8
Accéder à une ligne entière : croissance["France", ]; résultat 1.5 1.8 2.0
Accéder à une colonne entière : croissance[ , "2021"]; résultat France Allemagne .8 1.9
Opérations sur matrices
➤ Sommes par ligne ou colonne
rowSums(croissance) # Somme des lignes
colMeans(croissance) # Moyenne par année
➤ Transposer une matrice
t(croissance)
La fonction t() inverse lignes et colonnes.
Le concept de dimension
R considère une matrice comme un vecteur structuré. Sa structure est définie par l’attribut dim :
dim(croissance) # renvoie c(2, 3)
is.matrix(croissance) # TRUE
Vous pouvez créer une matrice à partir d’un vecteur :
x <- 1:12
dim(x) <- c(3, 4) # transforme x en matrice 3x4
Les tableaux (array) : au-delà de 2 dimensions
Un tableau en R est une extension des matrices à plus de deux dimensions.
a <- array(1:24, dim = c(3, 4, 2))
Vous obtenez 2 matrices 3×4 empilées comme des couches d’un cube :
, , 1
[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
, , 2
[,1] [,2] [,3] [,4]
[1,] 13 16 19 22
[2,] 14 17 20 23
[3,] 15 18 21 24
Voici un exemple contextualisé qui montre pourquoi et comment utiliser un tableau (array) dans R, à travers une application réaliste en économie. L’objectif est de montrer qu’un tableau devient utile lorsque les données ont plus de deux dimensions — ce que ne permettent pas les matrices ou les data frames.
Vous travaillez dans un institut de statistiques économiques. Vous devez analyser l’évolution de la productivité (mesurée ici en milliers d’euros par salarié) pour :
3 pays : France, Allemagne, Espagne
sur 2 années : 2021 et 2022
dans 2 secteurs : Industrie et Services
Vous avez donc 3 dimensions : Pays × Années × Secteurs
# Données brutes : 3 pays × 2 années × 2 secteurs = 12 valeurs
valeurs <- c(
85, 88, # France, 2021 : Industrie, Services
90, 93, # France, 2022
92, 95, # Allemagne, 2021
96, 98, # Allemagne, 2022
70, 72, # Espagne, 2021
75, 78 # Espagne, 2022
)
# Création du tableau
productivite <- array(valeurs,
dim = c(2, 2, 3), # 2 secteurs, 2 années, 3 pays
dimnames = list(
Secteur = c("Industrie", "Services"),
Annee = c("2021", "2022"),
Pays = c("France", "Allemagne", "Espagne")
))
En tapant : productivite, vous obtenez :
, , France
2021 2022
Industrie 85 90
Services 88 93
, , Allemagne
2021 2022
Industrie 92 96
Services 95 98
, , Espagne
2021 2022
Industrie 70 75
Services 72 78
Chaque "bloc" correspond à un pays : les lignes sont les secteurs, les colonnes les années.
Pourquoi un tableau est utile ici ?
Vous avez plus de 2 dimensions (pas gérable dans un matrix).
Vous pouvez accéder aux données par nom de dimension.
Vous pouvez effectuer des calculs sur une dimension à la fois.
A partir de là, vous pouvez extraire des données cibles :
productivite["Services", "2022", ]
# Résultat : France = 93, Allemagne = 98, Espagne = 78
productivite["Industrie", , "Allemagne"]
# Résultat : 92 96
Pour obtenir la moyenne par pays sur tous les secteurs et années :
apply(productivite, 3, mean)
# Résultat : France = 89, Allemagne = 95.25, Espagne = 73.75
Comme vous pouvez transformer un tableau en data frame (aplatir un tableau) pour faire une visualisation ou une analyse :
df <- as.data.frame(as.table(productivite))
head(df)
Vous obtenez:
Secteur Annee Pays Freq
1 Industrie 2021 France 85
2 Services 2021 France 88
3 Industrie 2022 France 90
4 Services 2022 France 93
5 Industrie 2021 Allemagne 92
6 Services 2021 Allemagne 95
Opérations élémentaires (vectorisées)
Comme pour les vecteurs, les opérations arithmétiques s’appliquent élément par élément.
croissance * 100 # pour exprimer en pourcentage
croissance + 0.5 # hypothèse de scénario optimiste
Les fonctions comme log(), exp(), round() s’appliquent aussi à toutes les cellules.
Fonctions utiles avec matrices:
dim() : Donne les dimensions
nrow(), ncol() : Nombre de lignes / colonnes
rownames(), colnames() : Noms des lignes / colonnes
t() : Transposée
rbind(), cbind() : Coller lignes ou colonnes
as.vector() : Aplatir une matrice
matrix() : Reconvertir un vecteur en matrice
Applications économiques
➤ Tableaux macroéconomiques
deficit <- matrix(c(-2.5, -3.0, -1.8, -4.2), nrow = 2)
rownames(deficit) <- c("France", "Espagne")
colnames(deficit) <- c("2021", "2022")
➤ Indicateurs boursiers par entreprise et année
cours <- matrix(c(55, 60, 58, 70), nrow = 2)
rownames(cours) <- c("TotalEnergies", "Airbus")
colnames(cours) <- c("2022", "2023")
À retenir :
matrix() : Crée une matrice 2D homogène
array() : Crée un tableau à plusieurs dimensions
dim() : Attribut pour les dimensions d’un objet
[i, j] : Accès à une cellule, ligne ou colonne
rbind() / cbind() : Ajout de lignes ou de colonnes
3.4. Listes : le conteneur universel de R
3.4. Listes : le conteneur universel de R
Une liste est une structure extrêmement souple qui permet de stocker des objets de types différents, parfois de formes différentes (vecteurs, matrices, modèles, fonctions…). Contrairement aux matrices ou data frames, qui imposent une homogénéité, la liste vous laisse composer librement un ensemble d’objets liés.
Une liste, c’est comme une boîte compartimentée dans laquelle chaque case peut contenir un objet différent.
Vous pouvez stocker dans une liste :
un nom (texte),
un chiffre d’affaires (vecteur),
un booléen (cotation en bourse),
un tableau (nombre de salariés par pays),
une fonction, ou même un modèle statistique.
Exemple simple
entreprise <- list(
nom = "Airbus",
secteur = "Aéronautique",
chiffre_affaires = c(2021 = 52.1, 2022 = 58.7),
cotation = TRUE)
Accéder aux éléments d’une liste
entreprise$nom : Accès direct à un élément nommé
entreprise[["nom"]] : Même chose, mais plus souple pour des noms variables
entreprise["nom"] : Retourne une sous-liste
entreprise$chiffre_affaires["2022"]
entreprise[["secteur"]]
entreprise["cotation"] # retourne une liste à 1 élément
Listes imbriquées
Vous pouvez créer des listes dans des listes (hiérarchies) :
firme <- list(
identite = list(nom = "BNP", secteur = "Banque"),
donnees = list(PIB = c(2020 = 2100, 2021 = 2200), croissance = 4.8))
Accès imbriqué :
firme$donnees$PIB["2021"]
Application avancée : stocker un modèle
Les résultats d’un modèle statistique (comme une régression linéaire) sont renvoyés sous forme de liste.
modele <- lm(mpg ~ hp + wt, data = mtcars)
summary(modele)
class(modele) # "lm"
names(modele) # liste des composants du modèle
Vous pouvez explorer chaque composant :
modele$coefficients
modele$residuals
Comprendre les listes est indispensable pour bien manipuler les objets retournés par des fonctions complexes.
3.5. Data Frames : la structure de données standard en R
3.5. Data Frames : la structure de données standard en R
Le data frame est la structure la plus utilisée en R pour manipuler des données structurées, comme un tableau Excel :
Chaque colonne représente une variable (âge, salaire, pays…).
Chaque ligne représente une observation (un individu, une entreprise, une année…).
Chaque colonne peut être d’un type différent (texte, numérique, logique…).
Création d’un data frame
economie <- data.frame(
pays = c("France", "Allemagne", "Espagne"),
pib = c(2800, 3900, 1600), # en milliards €
inflation = c(5.2, 6.0, 4.7), # en %
chomage = c(7.4, 5.1, 12.6) # en %
)
Accès aux colonnes et lignes
economie$pib : Colonne pib (vecteur)
economie[ , "pib"] : Idem, version par nom
economie[1, ] : 1ère ligne (observation)
economie[ , c("pays", "inflation")] : Sous-table avec deux colonnes
economie[1:2, ] : Les deux premières lignes
Renommer les lignes et colonnes
rownames(economie) <- c("FR", "DE", "ES")
colnames(economie)[2] <- "PIB"
Filtrer avec des conditions logiques
economie[economie$inflation > 5, ]
Résultat : retourne les lignes où l’inflation dépasse 5 %.
3.6. Indiçage et extraction
3.6. Indiçage et extraction
En R, vous utilisez des crochets pour extraire ou modifier des éléments dans des objets comme des vecteurs, matrices, data frames ou listes.
Extraction par position
x <- c("a", "b", "c", "d")
x[1] # "a"
x[2:3] # "b" "c"
x[-1] # tous sauf le 1er: "b" "c" "d"
Extraction dans un tableau de données
economie[1, 2] # valeur à la 1re ligne, 2e colonne
economie[ , "pays"] # toute la colonne pays
Extraction conditionnelle
Utilisez des vecteurs logiques :
economie$chomage > 6
# [1] TRUE FALSE TRUE
economie[economie$chomage > 6, ]
Fonctions utiles pour extraire ou filtrer :
subset() : Filtrer un data frame avec une condition simple
which() : Donne les indices des valeurs TRUE
%in% : Vérifie si un élément appartient à un vecteur (utile pour filtrer)
Exemples :
which(economie$pib > 2000) # Indices des pays avec un PIB > 2000
economie$pays %in% c("France", "Espagne")
# [1] TRUE FALSE TRUE
economie[economie$pays %in% c("France", "Espagne"), ]
4. Exemples
4. Exemples
### UTILISATION DU LANGAGE R
# ---- Calculs simples et opérateurs mathématiques ----
# Ligne de commande : chaque ligne est immédiatement exécutée
7 # une constante
(4 + 2 * 6)/5 # priorité des opérateurs
4^3 # puissance
exp(2) # exponentielle
cos(pi) + sin(pi) # fonctions trigonométriques classiques
gamma(6) # fonction gamma généralisée
# Saisie incomplète : l'invite change de '> ' à '+ '
3 + # R attend une suite
2 * # encore incomplet
4 # complète l'expression
# Affichage d'objets intégrés
pi # constante mathématique
letters # alphabet minuscule
LETTERS # alphabet majuscule
is.numeric # nom d'une fonction
# Affectations en R (évitez '=')
a <- 10 # affectation standard
a # affiche la valeur de 'a'
b <- a # copie la valeur de 'a' dans 'b'
a <- b <- 7 # double affectation
a # 7
b # 7
# Groupement d’instructions
{
x <- 10
y <- 3
x * y
}
# ---- Noms d’objets valides ----
valeur1 <- 100 # valide
valeur_2 <- 200 # valide
.objetCache <- 300 # commence par un point : caché par défaut
.9chiffres <- 1 # invalide
# R est sensible à la casse
compte <- 1
Compte # erreur si non défini
# ---- Types de données et conversion ----
mode(c(1.2, 3.4)) # numérique
mode(c(TRUE, FALSE, TRUE)) # booléen
mode("texte") # caractère
# Mélange de types : conversion automatique
c(3, TRUE, FALSE) # devient numérique
c("R", 2.5) # devient caractère
c(TRUE, "analyse") # devient caractère
# Longueur d’un vecteur
vecteur <- c(2, 4, 6)
length(vecteur) # 3
nchar("chaine") # longueur d'une chaîne de caractères
# Valeurs manquantes et spéciales
notes <- c(15, NA, 12, 18)
mean(notes) # retourne NA
mean(notes, na.rm = TRUE) # ignore les NA
is.na(notes) # détecter les NA
# Infini et indétermination
1/0 # Inf
-1/0 # -Inf
0/0 # NaN
# Attributs d’un objet
sample_data <- sample(1:50, 5)
class(sample_data) # numeric
class(sample_data) <- "ts" # devient série temporelle
plot(sample_data) # graphique temporel
# ---- Création de vecteurs ----
capital <- c(a = 5000, b = 7000, c = 12000)
capital["b"] # extraction par nom
capital[-1] # tout sauf le premier
# Initialisation de vecteurs
numeric(4) # [1] 0 0 0 0
logical(3) # [1] FALSE FALSE FALSE
character(2) # [1] "" ""
# ---- Matrices et tableaux ----
matrice <- matrix(1:6, nrow = 2, byrow = TRUE)
matrice[1, 2] # valeur ligne 1, colonne 2
nrow(matrice) # nombre de lignes
ncol(matrice) # nombre de colonnes
# Ajouter lignes/colonnes
matrice2 <- rbind(matrice, c(7, 8, 9))
matrice3 <- cbind(matrice, c(10, 11))
# Tableaux multidimensionnels
cube <- array(1:24, dim = c(3, 2, 4))
cube[1, 2, 3] # accès par 3 indices
# ---- Listes ----
donnees <- list(
nom = "EntrepriseX",
valeur = c(10, 20, 30),
actif = TRUE,
note = list(a = 5, b = 7)
)
donnees$valeur[1] # accès direct
donnees[["nom"]] # accès par nom
donnees[[4]][["b"]] # liste imbriquée
# ---- Data Frames ----
profil <- data.frame(
nom = c("Alice", "Bob", "Clara"),
age = c(25, 30, 22),
actif = c(TRUE, FALSE, TRUE)
)
profil$nom
profil[1, ]
profil[ , "age"]
# ---- Indiçage ----
valeurs <- sample(1:100, 10, replace = TRUE)
names(valeurs) <- letters[1:10]
valeurs[c("a", "e", "j")]
valeurs[1:5]
valeurs[valeurs > 50]
valeurs[is.na(valeurs)] <- 0
valeurs[5] <- NA
valeurs[is.na(valeurs)] <- mean(valeurs, na.rm = TRUE)
# Extraction en matrices
m <- matrix(1:9, nrow = 3)
m[1, 2] # élément ligne 1, colonne 2
m[, 1] # toute la colonne 1
m[2, ] # toute la ligne 2
m[m[,1] > 1, ] # lignes dont 1ère colonne > 1
Chapitre 4: Transformation des données
Chapitre 4: Transformation des données
1. Prérequis
1. Prérequis
En analyse économique et financière, il est rare que les données soient prêtes à l'emploi dès leur importation. Avant de réaliser une analyse graphique ou statistique, il faut souvent transformer les données : créer de nouvelles variables (par exemple, des ratios financiers), réorganiser les colonnes, filtrer les lignes selon des critères spécifiques (comme les entreprises cotées d'un secteur donné), ou encore regrouper les observations par pays ou par année. Ce chapitre présente les opérations fondamentales de transformation de données avec le package dplyr, l'un des piliers du tidyverse.
Nous allons illustrer les concepts avec un jeu de données extrait de la base gapminder, disponible via le package gapminder. Cette base contient des indicateurs macroéconomiques pour différents pays sur plusieurs années, comme le PIB par habitant, l'espérance de vie et la population. Avant de continuer, installez et chargez les packages nécessaires :
install.packages("gapminder")
install.packages("tidyverse")
library(gapminder)
library(tidyverse)
Nous allons convertir ce jeu de données en un tibble nommé indicateurs pour faciliter la lecture et la manipulation :
indicateurs <- gapminder
L'objectif de ce chapitre est de fournir une vue d'ensemble des fonctions essentielles pour manipuler des tableaux de données (data frames). Nous commencerons par les opérations sur les lignes, puis sur les colonnes, et enfin sur les groupes. Nous conclurons par une étude de cas combinant plusieurs de ces fonctions dans une chaîne logique.
Nous utiliserons les packages dplyr et ggplot2, inclus dans le tidyverse. Pensez à les charger avec :
library(tidyverse)
Soyez attentif aux messages de conflits qui s'affichent lors du chargement : certaines fonctions de dplyr (comme filter() et lag()) masquent celles de base R. Pour éviter toute ambiguïté, vous pouvez utiliser la syntaxe package::fonction().
Jetons un œil au jeu de données :
indicateurs
Cela affiche les premières lignes du jeu de données. Pour obtenir une vue synthétique, utilisez :
glimpse(indicateurs)
La table comprend les variables suivantes :
country : le pays
continent : le continent
year : l’année
lifeExp : espérance de vie
pop : population
gdpPercap : PIB par habitant
Nous utiliserons ce tableau comme base pour toutes les transformations.
2. Principes de base avec dplyr
2. Principes de base avec dplyr
dplyr est le moteur principal de ce chapitre car il fournit les verbes fondamentaux pour manipuler des data frames de manière fluide, lisible et cohérente. Il appartient au tidyverse, une collection de packages conçus pour l’analyse de données structurées
Les fonctions de dplyr (appelées verbes) permettent de manipuler facilement les tableaux de données. Elles ont en commun :
Le premier argument est toujours un tableau de données.
Les autres arguments décrivent les opérations à effectuer.
Le résultat est toujours un nouveau tableau.
2.1. Opérations sur les lignes
2.1. Opérations sur les lignes
Sélectionner certaines observations
La fonction filter() permet de conserver uniquement les lignes (pays ou années) qui vérifient une ou plusieurs conditions.
Exemple 1 — Pays africains en 2007 avec un PIB par habitant inférieur à 1000 $ :
indicateurs |> filter(continent == "Africa", year == 2007, gdpPercap < 1000)
Exemple 2 — Années où l’espérance de vie au Japon dépassait 80 ans :
indicateurs |> filter(country == "Japan", lifeExp > 80)
Astuce logique :
& signifie "et"
| signifie "ou"
%in% est très utile pour tester l’appartenance à un ensemble.
Exemple 3 — Données de 1992 ou 2007 :
indicateurs |> filter(year %in% c(1992, 2007))
Sauvegarder les résultats filtrés :
afrique_pauvre <- indicateurs |> filter(continent == "Africa", gdpPercap < 1000)
arrange() — Trier les données
arrange() permet de réorganiser les lignes selon les valeurs croissantes ou décroissantes d'une ou plusieurs colonnes.
Exemple — Classement des pays en 2007 selon leur PIB par habitant :
indicateurs |> filter(year == 2007) |> arrange(desc(gdpPercap))
Vous pouvez trier selon plusieurs critères :
indicateurs |> filter(year == 2007) |> arrange(continent, desc(lifeExp))
distinct() — Éliminer les doublons
Exemple — Liste des pays disponibles :
indicateurs |> distinct(country)
Exemple — Paires uniques de continent et pays :
indicateurs |> distinct(continent, country)
2.2. Opérations sur les colonnes
2.2. Opérations sur les colonnes
mutate() — Créer de nouvelles variables
mutate() sert à ajouter ou modifier des colonnes à partir de calculs simples.
Exemple — Calcul du PIB total (PIB par habitant × population) :
indicateurs |> mutate(gdp_total = gdpPercap * pop)
Exemple — Créer un indicateur de richesse relative :
indicateurs |> mutate(rich = gdpPercap > 20000)
Exemple — Limiter les colonnes affichées :
indicateurs |> mutate(gdp_total = gdpPercap * pop, .keep = "used")
select() — Choisir les variables utiles
Exemple — Garder uniquement les variables économiques :
indicateurs |> select(country, year, gdpPercap, pop)
Exemple — Exclure la variable lifeExp :
indicateurs |> select(-lifeExp)
Exemple — Renommer une colonne à la volée :
indicateurs |> select(pib_par_hab = gdpPercap)
rename() — Renommer une variable sans toucher aux autres
indicateurs |> rename(pib_par_hab = gdpPercap)
relocate() — Réorganiser l’ordre des colonnes
indicateurs |> relocate(pop, .after = country)
2.3. Le pipe |> — Une lecture fluide
2.3. Le pipe |> — Une lecture fluide
L'opérateur |> permet de chaîner les transformations, facilitant la lecture :
Exemple — Trouver les pays les plus riches d’Afrique en 2007 :
indicateurs |> filter(year == 2007, continent == "Africa") |> mutate(pib_total = gdpPercap * pop) |>
select(country, pib_total) |> arrange(desc(pib_total))
Cela se lit comme une phrase :
Filtrer les pays africains en 2007, puis calculer leur PIB total, puis sélectionner les colonnes utiles, puis trier par PIB décroissant.
2.4. Travailler par groupes (group_by())
2.4. Travailler par groupes (group_by())
group_by() + summarize() — Agréger les données
Exemple — PIB moyen par continent en 2007 :
indicateurs |> filter(year == 2007) |> group_by(continent) |>
summarize(pib_moyen = mean(gdpPercap, na.rm = TRUE))
Ajouter le nombre d’observations :
summarise(n = n(), pib_moyen = mean(gdpPercap, na.rm = TRUE))
slice_*() — Extraire des lignes dans chaque groupe
Exemple — Le pays le plus peuplé en 2007 par continent :
indicateurs |> filter(year == 2007) |> group_by(continent) |>
slice_max(pop, n = 1)
Groupes multiples
indicateurs |> group_by(year, continent) |>
summarize(croissance_moy = mean(gdpPercap, na.rm = TRUE))
ungroup() — Retirer les regroupements
Après avoir groupé les données, on peut revenir à un tableau "plat" :
indicateurs |> group_by(continent) |>
summarize(pib_moyen = mean(gdpPercap)) |> ungroup()
2.5. Étude de cas : moyenne vs. taille de l’échantillon
2.5. Étude de cas : moyenne vs. taille de l’échantillon
Il est dangereux de tirer des conclusions sur des petits échantillons : plus l’échantillon est petit, plus la moyenne peut être instable.
Exemple — Taux de croissance moyen selon les pays avec au moins 100 millions d’habitants :
indicateurs |> mutate(pib_total = gdpPercap * pop) |>
group_by(country) |> summarize(
croissance = (last(gdpPercap) - first(gdpPercap)) / first(gdpPercap),
pop_max = max(pop) ) |> filter(pop_max > 100e6) |> arrange(desc(croissance))
3. Script complet avec dplyr
3. Script complet avec dplyr
#########################################################
# CHAPITRE : Transformation de données avec dplyr
# CONTEXTE : Analyse macroéconomique avec gapminder
# OBJECTIF : Apprendre à manipuler les données économiques
# avec dplyr dans un flux de travail structuré
#########################################################
### 1. PRÉREQUIS — Installation et chargement des packages ----
# Installer les packages s'ils ne sont pas déjà installés
install.packages("tidyverse")
install.packages("gapminder")
# Charger les packages nécessaires
library(tidyverse) # Inclut dplyr et ggplot2
library(gapminder) # Base de données macroéconomique
# Charger le jeu de données et le renommer pour plus de clarté
indicateurs <- gapminder
# Aperçu rapide de la structure
glimpse(indicateurs)
# Variables disponibles :
# - country : nom du pays
# - continent : continent
# - year : année
# - lifeExp : espérance de vie
# - pop : population
# - gdpPercap : PIB par habitant
### 2. TRANSFORMATION DES DONNÉES AVEC dplyr ----
### 2.1. Opérations sur les lignes ----
# Filtrer les pays africains avec un PIB par habitant < 1000 en 2007
indicateurs |>
filter(continent == "Africa", year == 2007, gdpPercap < 1000)
# Filtrer les années où l’espérance de vie au Japon dépasse 80 ans
indicateurs |>
filter(country == "Japan", lifeExp > 80)
# Filtrer les données de 1992 ou 2007
indicateurs |>
filter(year %in% c(1992, 2007))
# Sauvegarder un sous-ensemble de données : pays africains pauvres
afrique_pauvre <- indicateurs |>
filter(continent == "Africa", gdpPercap < 1000)
# Classer les pays en 2007 selon leur PIB par habitant (ordre décroissant)
indicateurs |>
filter(year == 2007) |>
arrange(desc(gdpPercap))
# Classement par continent et espérance de vie décroissante
indicateurs |>
filter(year == 2007) |>
arrange(continent, desc(lifeExp))
# Liste des pays disponibles dans la base
indicateurs |>
distinct(country)
# Liste unique des couples continent-pays
indicateurs |>
distinct(continent, country)
### 2.2. Opérations sur les colonnes ----
# Créer une nouvelle variable : PIB total (PIB/hab × population)
indicateurs |>
mutate(pib_total = gdpPercap * pop)
# Créer une variable logique "rich" selon un seuil de 20000 USD/hab
indicateurs |>
mutate(rich = gdpPercap > 20000)
# Créer pib_total et ne garder que les variables utilisées
indicateurs |>
mutate(pib_total = gdpPercap * pop, .keep = "used")
# Sélectionner uniquement certaines colonnes
indicateurs |>
select(country, year, gdpPercap, pop)
# Exclure une colonne
indicateurs |>
select(-lifeExp)
# Renommer une colonne directement
indicateurs |>
select(pib_par_hab = gdpPercap)
# Renommer sans affecter les autres variables
indicateurs |>
rename(pib_par_hab = gdpPercap)
# Réorganiser les colonnes : placer pop après country
indicateurs |>
relocate(pop, .after = country)
### 2.3. Utiliser le pipe |> pour chaîner les opérations ----
# Exemple complet : pays africains les plus riches en 2007
indicateurs |>
filter(year == 2007, continent == "Africa") |>
mutate(pib_total = gdpPercap * pop) |>
select(country, pib_total) |>
arrange(desc(pib_total))
### 2.4. Regroupement et agrégation ----
# Calculer le PIB moyen par continent en 2007
indicateurs |>
filter(year == 2007) |>
group_by(continent) |>
summarize(pib_moyen = mean(gdpPercap, na.rm = TRUE))
# Ajouter le nombre d'observations
indicateurs |>
filter(year == 2007) |>
group_by(continent) |>
summarize(
pib_moyen = mean(gdpPercap, na.rm = TRUE),
n = n()
)
# Extraire le pays le plus peuplé en 2007 pour chaque continent
indicateurs |>
filter(year == 2007) |>
group_by(continent) |>
slice_max(pop, n = 1)
# Groupement par année et continent : croissance moyenne du PIB/hab
indicateurs |>
group_by(year, continent) |>
summarize(croissance_moy = mean(gdpPercap, na.rm = TRUE))
# Retirer le groupement (flattening)
indicateurs |>
group_by(continent) |>
summarize(pib_moyen = mean(gdpPercap)) |>
ungroup()
### 2.5. Étude de cas : moyenne vs. taille d’échantillon ----
# Identifier les pays ayant au moins 100 millions d’habitants
# et analyser leur taux de croissance du PIB/hab
indicateurs |>
mutate(pib_total = gdpPercap * pop) |>
group_by(country) |>
summarize(
croissance = (last(gdpPercap) - first(gdpPercap)) / first(gdpPercap),
pop_max = max(pop)
) |>
filter(pop_max > 100e6) |>
arrange(desc(croissance))
#########################################################
# FIN DU SCRIPT
# Ce script couvre les transformations essentielles
# utiles pour toute analyse économique avec dplyr.
#########################################################
Chapitre 5: mise en ordre des données
Chapitre 5: mise en ordre des données
« Toutes les familles heureuses se ressemblent, mais chaque famille malheureuse l’est à sa manière. » — Léon Tolstoï
« Toutes les données bien rangées se ressemblent, mais chaque jeu de données désordonné est désordonné à sa façon. » — Hadley Wickham
En analyse de données comme dans la vie, l’ordre repose sur quelques principes simples et universels, alors que le désordre peut prendre mille formes. Les données bien rangées (ou tidy data) obéissent toujours aux mêmes règles : chaque variable a sa propre colonne, chaque observation a sa propre ligne.
À l’inverse, les données désorganisées peuvent se présenter de façons très diverses : des colonnes qui mélangent plusieurs variables, des observations réparties sur plusieurs lignes, ou encore des formats qui varient d’une ligne à l’autre. Chaque cas semble unique, et c’est précisément ce qui les rend difficiles à analyser.
Ce chapitre a pour but de vous aider à transformer le chaos en clarté. Vous y apprendrez à identifier ce qui rend un jeu de données « mal rangé », puis à appliquer une démarche structurée pour le remettre en ordre, à l’aide des outils du package tidyr. Vous découvrirez notamment deux fonctions fondamentales : pivot_longer() pour transformer des données larges en données longues, pivot_wider() pour faire l’opération inverse. Ces deux fonctions sont les couteaux suisses de la structuration de données dans le tidyverse.
Pourquoi structurer ses données dès le départ ?
Lorsque vous travaillez avec des données en R, l’une des premières étapes consiste à mettre les données dans un format cohérent, lisible et exploitable. C’est le principe même des tidy data. Cette démarche demande parfois un peu d’effort au départ, mais elle vous fera gagner un temps considérable par la suite.
Une fois vos données bien rangées, vous pourrez utiliser efficacement tout l’écosystème du tidyverse : dplyr pour manipuler les données, ggplot2 pour les visualiser, modelr pour modéliser, etc. Vous éviterez ainsi les ajustements manuels à chaque étape et pourrez vous concentrer sur l’essentiel : répondre aux bonnes questions avec les bons outils.
Dans ce chapitre, vous allez donc apprendre à :
comprendre ce que signifie « des données bien rangées » ou tidy,
identifier les formes de données non tidy,
utiliser pivot_longer() et pivot_wider() pour structurer vos tableaux,
rendre vos données prêtes pour l’analyse, quelles que soient leur forme d’origine.
1. Qu’est-ce qu’une donnée bien rangée (tidy) ?
1. Qu’est-ce qu’une donnée bien rangée (tidy) ?
En R, le concept de données bien rangées (tidy data) repose sur une idée simple, mais puissante : les données doivent être organisées de façon à ce que chaque élément d'information occupe une place bien définie dans la table.
Hadley Wickham, à l’origine de cette approche, a proposé trois règles fondamentales qui définissent une base de données tidy :
Chaque variable doit avoir sa propre colonne : Une variable correspond à une propriété que l’on mesure (ex. : PIB, population, espérance de vie).
Chaque observation doit avoir sa propre ligne : Une observation correspond à une unité statistique (ex. : un pays à une date donnée).
Chaque type d’observation doit avoir sa propre table : Si vous avez différents types de données (ex. : données macroéconomiques et données de commerce extérieur), il est préférable de les organiser dans des tables séparées.
Prenons un extrait du jeu de données gapminder, qui contient des données macroéconomiques par pays et par année. Ce tableau est déjà au format tidy :
Chaque ligne représente une observation unique : un pays à une année donnée.
Chaque colonne représente une variable unique : population, espérance de vie, etc.
Voici maintenant une version désordonnée des mêmes données :
Ici, la variable year est encodée dans les noms de colonnes, ce qui empêche d’utiliser facilement les outils de visualisation ou d’analyse. Ce format n’est pas tidy, car :
une même variable (espérance de vie) est dispersée sur plusieurs colonnes,
l’information sur l’année est intégrée dans le nom de colonne.
Pour rendre ces données tidy, il faut passer d’un format « large » (wide) à un format « long » (long), où chaque ligne correspond à un pays-année, avec une colonne pour l’année et une colonne pour l’espérance de vie. C’est là qu’intervient la fonction pivot_longer().
2. Transformer des données vers le format tidy avec pivot_longer()
2. Transformer des données vers le format tidy avec pivot_longer()
Lorsque vos données ne sont pas encore tidy, c’est souvent parce qu’elles sont en format large (wide format) : une variable est étalée sur plusieurs colonnes. C’est typiquement le cas lorsqu’une même mesure (comme le PIB ou la population) est reportée année par année dans des colonnes séparées.
La fonction pivot_longer() vous permet de rassembler ces colonnes en une seule, et de faire apparaître la variable d’identification correspondante (par exemple l’année) dans une nouvelle colonne. C’est l’outil idéal pour convertir des données en format long, qui respecte les règles tidy.
Prenons un petit jeu de données fictif dans un format non tidy, représentant l’espérance de vie par pays et par année :
esperance_large <- tibble(
country = c("France", "Germany", "Tunisia"),
lifeExp_2002 = c(79.59, 78.67, 72.42),
lifeExp_2007 = c(80.65, 79.41, 73.92))
Le tableau ressemble à ceci :
On va maintenant convertir ce tableau en format tidy :
esperance_tidy <- esperance_large |>
pivot_longer(
cols = starts_with("lifeExp_"),
names_to = "year",
values_to = "lifeExp" )
Explication des arguments :
cols = starts_with("lifeExp_") : on sélectionne les colonnes à regrouper.
names_to = "year" : les noms des colonnes deviendront une nouvelle variable appelée year.
values_to = "lifeExp" : les valeurs de ces colonnes seront regroupées dans une colonne unique nommée lifeExp.
Le résultat obtenu :
# aperçu du résultat
print(esperance_tidy)
Ici, la variable year contient encore le préfixe « lifeExp_ ». On peut le retirer pour obtenir une variable numérique plus propre :
esperance_tidy <- esperance_tidy |>
mutate(year = str_remove(year, "lifeExp_")) |>
mutate(year = as.integer(year))
La fonction pivot_longer() est donc la clé pour passer d’un tableau en largeur à un tableau en longueur, ce qui est indispensable pour utiliser ggplot2, dplyr, et les fonctions de modélisation.
3. Transformer des données tidy en format large avec pivot_wider()
3. Transformer des données tidy en format large avec pivot_wider()
Dans certains cas, l’analyse ou la présentation des résultats nécessite de transformer des données tidy vers un format plus large (wide format). Cela peut être utile, par exemple, pour générer un tableau croisé, faciliter une lecture humaine des résultats, ou pour satisfaire les exigences d’un logiciel externe (comme Excel ou un outil de reporting).
C’est exactement le rôle de la fonction pivot_wider() : elle permet de répartir les valeurs d’une variable sur plusieurs colonnes, à partir d’une structure en long.
Supposons que vous travaillez pour une organisation qui publie un rapport annuel sur les performances économiques de plusieurs pays. Vous disposez de données tidy comme celles-ci :
library(tidyverse)
pib_tidy <- tibble(
country = c("France", "France", "Germany", "Germany", "Tunisia", "Tunisia"),
year = c(2002, 2007, 2002, 2007, 2002, 2007),
gdpPercap = c(28926.03, 30470.02, 30035.80, 32170.37, 4533.02, 5390.50))
Ce tableau respecte les principes tidy : une variable par colonne (country, year, gdpPercap), une observation par ligne (pays-année).
Pour inclure ces résultats dans un rapport Word ou un tableau Excel, vous voulez que chaque pays apparaisse sur une seule ligne, avec les années comme colonnes. C’est plus lisible pour un décideur non spécialiste.
Solution : pivot_wider()
pib_large <- pib_tidy |>
pivot_wider(
names_from = year,
values_from = gdpPercap,
names_prefix = "gdpPercap_" )
Résultat en format large (large format) :
4. Bonnes pratiques avec pivot_wider()
4. Bonnes pratiques avec pivot_wider()
Problème : doublons non gérés = erreur ou agrégation implicite
Imaginons que vous disposiez de données sur plusieurs régions d’un même pays, avec leur PIB pour chaque année. Si vous utilisez pivot_wider() sans préciser comment gérer les doublons, vous risquez une erreur ou un comportement inattendu.
Exemple avec doublons :
library(tibble)
library(tidyr)
pib_regions <- tibble(
country = c("France", "France", "France", "Germany", "Germany"),
year = c(2007, 2007, 2002, 2002, 2002),
region = c("Île-de-France", "Provence", "Bavière", "Nordrhein", "Bavière"),
gdp = c(40000, 38000, 41000, 39000, 37000))
Mauvais usage : doublons non gérés
pib_regions |>
pivot_wider(
names_from = year,
values_from = gdp )
Problème : plusieurs valeurs de gdp pour la même combinaison country + year. R renverra une erreur ou tentera de fusionner les valeurs (ex. : sous forme de liste).
# A tibble: 5 × 4
country region `2007` `2002`
<chr> <chr> <dbl> <dbl>
1 France Île-de-France 40000 NA
2 France Provence 38000 NA
3 France Bavière NA 41000
4 Germany Nordrhein NA 39000
5 Germany Bavière NA 37000
Solution : gérer les doublons avec values_fn = list(...)
Si vous voulez agréger les valeurs (ex. : faire la moyenne ou prendre la première valeur), vous devez le spécifier.
Exemple correct : utiliser mean() pour agréger
pib_regions |>
pivot_wider(
names_from = year,
values_from = gdp,
values_fn = list(gdp = mean) )
# A tibble: 5 × 4
country year region gdp
<chr> <dbl> <chr> <dbl>
1 France 2007 Île-de-France 40000
2 France 2007 Provence 38000
3 France 2002 Bavière 41000
4 Germany 2002 Nordrhein 39000
5 Germany 2002 Bavière 37000
Autre option : ne garder que la première valeur
pib_regions |>
pivot_wider(
names_from = year,
values_from = gdp,
values_fn = list(gdp = first) )
# A tibble: 5 × 4
country year region gdp
<chr> <dbl> <chr> <dbl>
1 France 2007 Île-de-France 40000
2 France 2007 Provence 38000
3 France 2002 Bavière 41000
4 Germany 2002 Nordrhein 39000
5 Germany 2002 Bavière 37000
Règle à retenir :
Avant d’utiliser pivot_wider(), assurez-vous que la combinaison des variables restantes (ici : country + region) identifie chaque ligne de manière unique pour chaque valeur de names_from. Sinon, utilisez values_fn = list(...) pour définir comment agréger les valeurs en cas de conflit.
5. Résumé : principes des données tidy et fonctions pivot_*
5. Résumé : principes des données tidy et fonctions pivot_*
À ce stade, vous avez vu comment reconnaître, convertir et exploiter des données tidy grâce aux fonctions pivot_longer() et pivot_wider() du package tidyr. Il est utile maintenant de faire un point synthétique pour bien ancrer les idées.
Les principes fondamentaux des données tidy
Selon la grammaire du tidyverse (et plus précisément selon Hadley Wickham), un jeu de données bien rangé (tidy) suit trois règles simples :
Chaque variable forme une colonne.
Chaque observation (individu, année, pays, etc.) forme une ligne.
Chaque type d’unité d’observation forme une table distincte.
Ces règles ne sont pas arbitraires : elles permettent à toutes les fonctions du tidyverse (dplyr, ggplot2, modelr, etc.) de fonctionner de manière cohérente et prédictible.
Le rôle des fonctions pivot_*
Les deux fonctions clés de tidyr pour réorganiser vos colonnes sont :
pivot_longer() : Regrouper plusieurs colonnes en deux colonnes : une pour les noms, une pour les valeurs ; Format large → long
pivot_wider() : Étaler les valeurs d'une variable sur plusieurs colonnes ; Format long → large
Comment choisir ?
Tracer une courbe dans ggplot2 : Tidy (long)
Appliquer group_by() puis summarize() dans dplyr : Tidy (long)
Présenter un tableau lisible dans un rapport Excel ou Word : Large
Créer un tableau croisé de comparaison entre périodes : Large
6. Étude de cas : nettoyage d’un jeu de données mal structuré
6. Étude de cas : nettoyage d’un jeu de données mal structuré
Vous travaillez comme analyste dans un cabinet de conseil économique. On vous transmet un fichier Excel contenant des données de PIB (en milliards USD) sur une sélection de pays, mais sous forme non exploitable directement en R.
Voici à quoi ressemble le fichier original :
Ce format est classique dans les documents Word ou Excel, mais il est impropre à une analyse avec le tidyverse, car les noms des pays sont des colonnes — ce qui viole le principe fondamental « une variable = une colonne ».
Nous voulons donc :
Nettoyer et restructurer les données (format tidy)
Analyser l’évolution du PIB par pays
Créer des graphiques comparatifs clairs et exploitables
Étape 1 — Chargement d’un tableau brut (ici simulé manuellement)
library(tibble)
pib_brut <- tibble(
Annee = c(2000, 2005, 2010, 2015),
France = c(1398, 2131, 2645, 2424),
Allemagne = c(1945, 2815, 3395, 3365),
Italie = c(1176, 1825, 2090, 1843),
Tunisie = c(23, 31, 44, 43))
Étape 2 — Transformation en format tidy avec pivot_longer()
library(tidyr)
pib_tidy <- pib_brut |>
pivot_longer(
cols = -Annee,
names_to = "Pays",
values_to = "PIB_milliards" )
Résultat obtenu :
Ce tableau est désormais tidy :
Une observation par ligne (pays–année),
Une variable par colonne (Annee, Pays, PIB_milliards).
Ce nouveau format permet :
Des agrégations rapides : PIB moyen, croissance, classement…
Des graphiques propres avec ggplot2
Des analyses comparatives dans le temps (avec group_by() + mutate())
Étape 3 — Visualisation de l’évolution du PIB
library(ggplot2)
ggplot(pib_tidy, aes(x = Annee, y = PIB_milliards, color = Pays)) +
geom_line(linewidth = 1.2) +
geom_point(size = 3) +
labs(title = "Évolution du PIB (en milliards USD)",
subtitle = "Comparaison entre pays (2000–2015)",
x = "Année",
y = "PIB en milliards",
color = "Pays") +
theme_minimal()
Ce graphique permet de :
Visualiser les tendances différenciées par pays,
Repérer les phases de stagnation ou de croissance rapide,
Avoir un outil prêt pour un rapport ou une présentation.
Étape 4 — Analyse comparative
library(dplyr)
# Taux de croissance entre 2000 et 2015 par pays
pib_tidy |>
group_by(Pays) |>
summarize(
croissance_absolue = last(PIB_milliards) - first(PIB_milliards),
taux_croissance = (last(PIB_milliards) / first(PIB_milliards) - 1) * 100
) |> arrange(desc(taux_croissance))
On part de notre tableau pib_tidy au format long, contenant trois colonnes : Annee, Pays, PIB_milliards. On regroupe les données par pays. Cela signifie que les opérations suivantes (comme summarize) seront effectuées indépendamment pour chaque pays. On calcule la croissance absolue du PIB entre le début et la fin de la période :
first(PIB_milliards) → la valeur du PIB en 2000,
last(PIB_milliards) → la valeur du PIB en 2015,
leur différence donne l'augmentation en milliards USD.
Puis on calcule le taux de croissance en pourcentage. Enfin, on classe les pays par ordre décroissant de leur taux de croissance. Le pays qui a le plus progressé en % arrive en tête du tableau.
# A tibble: 4 × 3
Pays croissance_absolue taux_croissance
<chr> <dbl> <dbl>
1 Tunisie 20 87.0
2 France 1026 73.4
3 Allemagne 1420 73.0
4 Italie 667 56.7
Chapitre 6: Scripts et projets : une organisation professionnelle du travail en R avec RStudio
Chapitre 6: Scripts et projets : une organisation professionnelle du travail en R avec RStudio
Quand on commence à apprendre R, on utilise souvent la console pour taper et exécuter du code. C’est une bonne façon d’expérimenter rapidement. Mais dès que votre travail devient plus sérieux — que ce soit un graphique complexe, une analyse statistique ou une longue suite de manipulations — la console montre vite ses limites :
On ne peut pas conserver un historique propre.
Corriger une ligne implique parfois de tout retaper.
Et surtout, il devient difficile de retrouver, partager ou rejouer une analyse.
La solution consiste alors à écrire vos analyses dans des scripts R.
1. Scripts R : pour un code clair, reproductible et modifiable
1. Scripts R : pour un code clair, reproductible et modifiable
Lorsque vous travaillez en R, il est essentiel de ne pas tout faire dans la console. Certes pratique pour tester quelques lignes de code, la console devient vite limitée dès que votre travail se complexifie. Pour développer une analyse rigoureuse, construire un graphique élaboré ou créer une suite d'opérations avec dplyr, vous avez besoin d’un environnement plus stable et organisé : le script R.
Un script R, c’est tout simplement un fichier texte dans lequel vous enregistrez votre code. Mais ce n’est pas qu’un simple support : c’est votre carnet de bord. Il vous permet de :
documenter vos choix avec des commentaires (# comme ceci),
tester et corriger des parties du code indépendamment,
modifier facilement ce que vous avez écrit,
réexécuter à tout moment tout ou partie de votre analyse,
et partager votre travail avec d’autres (enseignants, collègues, collaborateurs...).
Pour tirer pleinement parti de vos scripts, le meilleur allié est RStudio, un environnement de développement intégré (IDE) spécialement conçu pour R.
Contrairement à un éditeur de texte classique ou à une console simple, RStudio vous offre une interface complète et conviviale, pensée pour faciliter toutes les étapes de votre travail :
écrire du code dans un éditeur dédié,
exécuter du code ligne par ligne ou en bloc,
visualiser vos résultats graphiquement,
suivre l’état de vos objets dans l’environnement,
repérer et corriger les erreurs grâce à une aide intégrée,
et sauvegarder proprement vos scripts.
RStudio est structuré en plusieurs volets (script, console, environnement, graphiques…) qui vous aident à rester organisé et productif. Que vous soyez étudiant, chercheur ou analyste, c’est un outil incontournable pour mener à bien vos projets de données de manière professionnelle, reproductible et collaborative.
En résumé, un script vous permet de conserver une trace claire et réutilisable de votre travail. RStudio, lui, transforme votre usage de R en une expérience confortable, fluide et puissante.
2. RStudio : Une interface pensée pour apprendre, coder et organiser
2. RStudio : Une interface pensée pour apprendre, coder et organiser
Pourquoi utiliser RStudio ? Une interface pensée pour apprendre, coder et organiser
Un environnement de développement intégré (ou IDE, Integrated Development Environment) est un outil conçu pour faciliter la programmation. Il regroupe généralement trois éléments essentiels :
un éditeur de texte spécialisé pour le langage utilisé (ici, R),
un moteur d'exécution du code (interpréteur ou compilateur),
et divers outils d’aide au développement : gestion de projets, contrôle de versions, navigation dans le code source, etc.
RStudio est justement un IDE complet et convivial, spécifiquement conçu pour le langage R. Offert au public depuis 2011 par RStudio Inc., il est disponible :
en version gratuite ou commerciale,
pour une utilisation locale (version desktop),
ou à distance, via un navigateur (version serveur).
Pourquoi choisir RStudio quand on débute en R ?
RStudio est aujourd’hui l’outil privilégié des étudiants, enseignants, chercheurs, analystes et professionnels de la donnée. Il transforme l’environnement R (initialement en ligne de commande) en un véritable espace de travail graphique, organisé en plusieurs volets.
Grâce à cette organisation :
vous écrivez votre code dans un éditeur clair et ergonomique,
vous exécutez tout ou partie de ce code dans la console,
vous visualisez vos objets créés en mémoire (dans l’onglet "Environment"),
vous générez des graphiques interactifs et suivez l’évolution de votre travail pas à pas,
vous structurez vos projets avec des scripts, des dossiers, et des chemins bien définis.
3. Créer, exécuter et sauvegarder un script R dans RStudio
3. Créer, exécuter et sauvegarder un script R dans RStudio
Dans cette section, nous allons vous guider à travers les tâches fondamentales réalisées dans RStudio :
charger un package et un jeu de données,
créer un graphique avec ggplot2,
estimer un modèle de régression linéaire,
et sauvegarder vos résultats de manière reproductible.
Tout cela sera expliqué progressivement, avec des scripts annotés et des exemples concrets. Que vous soyez débutant ou en phase de consolidation, vous apprendrez à tirer parti de RStudio comme d’un véritable compagnon de route pour vos analyses de données.
1ère étape : Lancer RStudio et repérer les zones clés
La première étape consiste à ouvrir RStudio, votre environnement de travail pour écrire, exécuter et visualiser du code R. Rappelons qu’au lancement de RStudio, par défaut quatre zones principales sont affichées (voir ci-dessus) :
En haut à gauche : la zone de script, où vous pouvez écrire et sauvegarder votre code R.
En haut à droite : l’onglet Environment, qui liste les objets actuellement chargés en mémoire (jeux de données, résultats de modèles, etc.).
En bas à droite : plusieurs onglets utiles, notamment Plots (pour visualiser les graphiques), Packages (pour gérer vos extensions), Files et Help.
En bas à gauche : la console, où le code est exécuté en direct.
2ème étape : Définir le répertoire de travail
Avant de commencer à écrire votre script, il est important de définir le dossier de travail dans lequel tous vos fichiers seront enregistrés (script, graphiques, résultats, etc.).
Deux méthodes s’offrent à vous :
Méthode 1 (graphique) :
Dans RStudio, allez dans le menu Session > Set Working Directory > Choose Directory…, (Ctrl + Maj + H) puis sélectionnez le dossier de votre choix. RStudio appliquera automatiquement la commande setwd("...") en arrière-plan.Méthode 2 (console) :
Vous pouvez définir manuellement le répertoire en tapant dans la console :
setwd("C:/NomDeVotreDossier")
Vous pouvez ensuite vérifier que le bon dossier est bien actif avec : getwd()
3ème étape : Créer un script R
Plutôt que d’écrire du code directement dans la console, il est recommandé d’utiliser un script R, un fichier texte contenant vos instructions. Pour en créer un :
Allez dans le menu File > New File > R Script.
Ensuite, enregistrez ce fichier (par exemple, sous le nom mon_script.R) afin de pouvoir le réutiliser plus tard.
Si vous avez déjà un fichier .R que vous souhaitez réutiliser ou reprendre :
Allez dans le menu File > Open File…
Naviguez jusqu’à l’endroit où le fichier est enregistré sur votre ordinateur.
Sélectionnez le fichier .R souhaité, puis cliquez sur Open.
Le script s’ouvrira dans l’éditeur de code, prêt à être consulté ou modifié.
4ème étape : Écrire et comprendre les premières lignes de code
Voici un exemple de code simple à copier dans votre script. Il vous permet de :
Installer et charger un package,
Explorer un jeu de données intégré,
Réaliser un graphique,
Estimer un modèle de régression linéaire.
install.packages("ggplot2") # À faire une seule fois
library(ggplot2) # À faire à chaque session R
data(mpg) # Charger le jeu de données "mpg"
head(mpg) # Aperçu des premières lignes
# Créer un graphique
ggplot(mpg, aes(x = displ, y = hwy)) +
geom_point() +
labs(title = "Consommation selon la cylindrée",
x = "Cylindrée (L)", y = "MPG autoroute")
# Estimer un modèle de régression
mod <- lm(hwy ~ displ, data = mpg)
summary(mod) #Résumé du modèle
mpg est un jeu de données inclus dans le package ggplot2. Il contient des informations sur la consommation de carburant de différents modèles de voitures.
ggplot() est utilisé pour créer un graphique en nuage de points qui illustre la relation entre la cylindrée (displ) et la consommation autoroutière (hwy).
lm() permet d’estimer une régression linéaire simple, ici pour voir si une plus grande cylindrée réduit la consommation.
5ème étape : Exécuter le code
Pour exécuter une ligne de code depuis votre script, placez le curseur sur la ligne et appuyez sur Ctrl + Enter. Pour exécuter tout le script, vous pouvez faire Ctrl + A pour tout sélectionner, puis Ctrl + Enter.
Les résultats s’affichent dans différents panneaux :
Console : exécution du code.
Environment : objets créés, comme mod ou mpg.
Plots : affichage des graphiques.
6ème étape : Comprendre les résultats de la régression
Le modèle mod estime l’effet de la variable displ (cylindrée) sur hwy (consommation sur autoroute). Le coefficient associé à displ est négatif, ce qui signifie qu’une plus grande cylindrée diminue l’efficacité énergétique. Par exemple, un coefficient de -3.53 signifie qu’une voiture avec un litre de cylindrée supplémentaire consomme en moyenne 3.53 miles par gallon (MPG) de moins sur autoroute.
7ème étape : Sauvegarder votre travail
R propose plusieurs façons de sauvegarder vos objets, vos résultats et vos graphiques.
Sauvegarder des objets R
save(mod, mpg, file = "mes_resultats.RData")
Pour les recharger plus tard :
load("mes_resultats.RData")
Rappelons que pour connaître le répertoire actuel où R enregistre les fichiers : getwd()
Pour le changer de répertoire :
Méthode 1 : en console
setwd("C:/Votre_Dossier/")
Méthode 2 : via le menu
Session > Set Working Directory > Choose Directory
Exporter un tableau en format Excel (.csv)
write.csv(mpg, file = "mpg_export.csv", row.names = FALSE)
Cela crée un fichier lisible par Excel dans le répertoire de travail.
Sauvegarder la sortie d’un résumé dans un fichier texte
sink("resume_modele.txt")
summary(mod)
sink()
Tout ce qui est affiché dans la console entre sink() et sink() est écrit dans un fichier texte.
Sauvegarder un graphique de base en image
En PNG :
png("mon_graphique.png")
plot(mpg$displ, mpg$hwy)
dev.off()
En PDF :
pdf("mon_graphique.pdf")
plot(mpg$displ, mpg$hwy)
dev.off()
Sauvegarder un graphique ggplot2
p <- ggplot(mpg, aes(x = displ, y = hwy)) + geom_point()
ggsave("graphique_ggplot.png", plot = p, width = 6, height = 4)
La première ligne de code utilise le package ggplot2 pour créer un graphique en nuage de points (scatterplot) représentant la relation entre deux variables du jeu de données mpg :
mpg : un jeu de données intégré dans ggplot2, contenant des informations sur la consommation de carburant de différents modèles de voitures.
aes(x = displ, y = hwy) : on définit l’esthétique du graphique (abrégé par aes) en plaçant :
displ (la cylindrée du moteur, en litres) sur l’axe des x,
hwy (la consommation sur autoroute, en miles par gallon) sur l’axe des y.
geom_point() : on ajoute une couche de points au graphique, chaque point représentant une voiture.
Enfin, l’ensemble est stocké dans un objet appelé p à l’aide de <-. Cela permet de réutiliser ce graphique plus tard, par exemple pour l’enregistrer ou le modifier.
La seconde ligne de code utilise la fonction ggsave() pour enregistrer le graphique p sous forme d'image dans un fichier au format PNG :
"graphique_ggplot.png" : nom du fichier image à créer.
plot = p : on précise que c’est le graphique stocké dans l’objet p qu’on souhaite enregistrer.
width = 6, height = 4 : dimensions de l’image en pouces (inches), ce qui permet de contrôler sa taille.
Par défaut, le fichier sera sauvegardé dans le répertoire de travail courant. Vous pouvez vérifier ou modifier ce répertoire avec les fonctions getwd() et setwd() si besoin.
4. Organiser ses analyses avec les projets RStudio
4. Organiser ses analyses avec les projets RStudio
Un projet RStudio est simplement un dossier dédié à une analyse, avec des règles simples qui vous rendent la vie beaucoup plus facile. Travailler avec un projet vous permet de :
Centraliser tous vos fichiers (scripts, données, figures, résultats) au même endroit.
Supprimer les soucis de chemin d’accès (setwd() devient inutile) : RStudio sait automatiquement où se trouvent vos fichiers.
Reprendre facilement là où vous vous êtes arrêté : RStudio garde la mémoire des fichiers ouverts et de votre dernier état de travail.
Partager facilement votre travail avec d’autres (ou avec vous-même plus tard) sans tout casser.
Quand vous commencez une nouvelle analyse, posez-vous systématiquement ces deux questions :
1. Quelle est ma « source de vérité » ?
➤ Ce que vous devez sauvegarder n’est pas l’environnement R (la mémoire) mais bien vos scripts !
Ce sont eux qui documentent vos choix, vos étapes, vos calculs.
2. Où vit votre analyse ?
➤ Il est essentiel de structurer votre travail dans un dossier dédié, et non dans des fichiers éparpillés sur votre ordinateur.
Lorsque vous travaillez dans RStudio, les objets créés (données, modèles…) sont stockés en mémoire. Mais cette mémoire est volatile : elle peut disparaître ou être corrompue, et surtout, elle ne raconte pas comment elle a été construite.
La bonne pratique consiste à sauvegarder tout ce qui compte dans vos scripts R.
Et pour vous y aider, configurez RStudio pour repartir à zéro à chaque ouverture (ce qui vous oblige à relancer votre script, donc à garantir qu’il fonctionne) :
1. Allez dans Tools > Global Options > General
2. Décochez “Restore .RData into workspace at startup”
3. Choisissez “Never” dans “Save workspace to .RData on exit”
Ou lancez directement ce code :
usethis::use_blank_slate()
À chaque redémarrage, vous disposerez d'un environnement vierge, ce qui vous obligera à recharger vos scripts. Cette contrainte favorise une meilleure rigueur dans votre travail et garantit une reproductibilité accrue des résultats.
5. Les bonnes pratiques d’un projet RStudio
5. Les bonnes pratiques d’un projet RStudio
Quand vous débutez une analyse de données en R, il est essentiel d’organiser votre espace de travail dès le départ. Un bon projet ne se limite pas à un script : vous avez souvent des données à importer, des graphiques à sauvegarder, et peut-être des résultats à exporter. Pour éviter que tout se disperse dans votre ordinateur, RStudio vous permet de créer un « projet », c’est-à-dire un dossier bien structuré où tout votre travail est regroupé.
Étape 1 : Créer un nouveau projet RStudio vide
1. Dans RStudio, cliquez sur File > New Project.
2. Dans la fenêtre qui s’ouvre, sélectionnez New Directory.
3. Une fenêtre Project Type s’ouvre, choisissez R New Project (c’est l’option à utiliser pour créer un projet vide). S’ouvre alors cette fenêtre :
4. Donnez un nom clair et descriptif à votre projet (Directory name), par exemple : exploration-diamonds.
5. Choisissez un emplacement logique sur votre ordinateur, comme le dossier Documents de votre espace de travail.
6. Cliquez sur Create Project.
Vous voilà dans un nouveau projet RStudio :
Un dossier a été créé sur votre ordinateur.
Il contient un fichier spécial .Rproj : ce sera votre point d’entrée pour revenir au projet plus tard.
Tous les fichiers que vous créerez (scripts, données, graphiques, etc.) seront enregistrés à l’intérieur de ce dossier.
Étape 2 : Créer un dossier pour les données
Avant d’écrire votre script, prenez l’habitude de structurer votre projet :
Dans l’onglet Files de RStudio (en bas à droite),
Cliquez sur New Folder,
Nommez ce dossier : data.
Ce sera l’endroit où vous stockerez tous vos fichiers de données (comme des .csv), séparés du reste.
Étape 3 : Créer un script R
Menu File > New File > R Script, ou raccourci Ctrl/Cmd + Shift + N
Puis, enregistrer le script : 01-analyse-diamonds.R
Contenu du script 01-analyse-diamonds.R :
# ===============================================
# Script d'exploration du jeu de données 'diamonds'
# Objectif : créer un graphique et sauvegarder les résultats
# Auteur : (votre nom)
# Projet : exploration-diamonds
# Date : (ajouter la date)
# ===============================================
# Étape 1 : Chargement des packages -----------------------------
# tidyverse contient les outils essentiels pour manipuler, visualiser et lire les données
# Assurez-vous qu'ils sont déjà installés avec install.packages("tidyverse")
library(tidyverse)
# Étape 2 : Chargement du jeu de données ------------------------
# diamonds est un jeu intégré dans le package ggplot2 (déjà chargé via tidyverse)
# Il contient plus de 50 000 observations de diamants
data("diamonds")
# Étape 3 : Aperçu des données ----------------------------------
# Afficher les premières lignes
head(diamonds)
# Résumé statistique des variables numériques
summary(diamonds)
# Structure du tableau : types de variables, dimensions
glimpse(diamonds)
# Étape 4 : Visualisation exploratoire --------------------------
# Créer un graphique représentant la relation entre le poids (carat) et le prix
ggplot(diamonds, aes(x = carat, y = price)) +
geom_hex() + # nuage de points agrégé sous forme d’hexagones
labs(title = "Prix en fonction du poids du diamant",
x = "Poids (carat)",
y = "Prix (USD)") +
theme_minimal()
# Étape 5 : Sauvegarde du graphique -----------------------------
# Enregistrer le graphique en PNG dans le dossier principal du projet
ggsave("diamonds.png", width = 8, height = 6)
# Étape 6 : Export des données brutes ---------------------------
# Sauvegarder le jeu complet sous forme CSV dans le dossier /data
write_csv(diamonds, file = "data/diamonds.csv")
# Étape 7 : Fin du script ---------------------------------------
# Conseil : redémarrer la session avec Ctrl + Shift + F10
# puis exécuter à nouveau tout le script avec Ctrl + Shift + S
Bonnes pratiques à suivre :
Toujours commencer par charger les packages avec library().
Ne jamais utiliser install.packages() dans un script partagé.
Commenter chaque bloc pour expliquer ce que fait le code.
Sauvegarder les résultats dans des fichiers .csv, .png ou .rds.
Éviter les chemins absolus (C:/...), préférer les chemins relatifs comme "data/diamonds.csv".
Ce script réalise trois opérations principales :
1. Il charge les packages nécessaires (notamment tidyverse, qui contient ggplot2 et readr).
2. Il produit un graphique à partir du jeu de données diamonds.
3. Il sauvegarde deux fichiers dans le dossier de votre projet : un fichier image et un fichier de données.
Voici le contenu du script :
library(tidyverse) # Charge les packages pour manipuler les données et créer des graphiques
# 1. Créer un graphique : prix en fonction du carat, affiché avec une carte de densité (geom_hex)
ggplot(diamonds, aes(x = carat, y = price)) +
geom_hex()
# 2. Sauvegarder le graphique sous forme d’image PNG
ggsave("diamonds.png")
# 3. Sauvegarder les données sous forme de fichier CSV dans un sous-dossier "data"
write_csv(diamonds, "data/diamonds.csv")
Si vous avez simplement exécuté le script sans afficher explicitement les objets, vous n’obtiendrez pas de sortie texte dans la console. C’est normal.
Pour vérifier que tout a fonctionné :
Regardez dans l’onglet "Files" si les fichiers diamonds.png et diamonds.csv ont bien été créés.
Cliquez sur le fichier CSV dans l’onglet "Files" > "View File" pour le prévisualiser.
Ouvrez le PNG avec un visualiseur d’images.
Tableau des principaux raccourcis clavier dans RStudio
Tableau des principaux raccourcis clavier dans RStudio
Remarques pédagogiques importantes :
Ctrl + A apparaît dans ce tableau car il est aussi indispensable pour sélectionner tout le script ou la console, avant d'exécuter, commenter ou sauvegarder.
Certains raccourcis (Ctrl + Shift + C, Ctrl + Enter) sont spécifiques au développement de scripts.
Cmd sur Mac = Ctrl sur Windows/Linux pour la majorité des commandes.
© 2026 Riadh Ben Jelili — Tous droits réservés.
Ce guide est mis à disposition gratuitement pour un usage éducatif. Vous pouvez citer ou reproduire des extraits à condition de citer explicitement l'auteur et la source (https://sites.google.com/view/riadh-benjelili/teaching-resources/r-guide-initiation), et de ne pas en faire un usage commercial. Pour toute autre utilisation, veuillez contacter l'auteur.
Page updated
Google Sites
Report abuse