RStudio : un endroit commun pour R et Python
Découvrez comment utiliser R et Python dans un même environnement de travail.
EDA, nettoyage, visualisation : découvrez les forces et faiblesses de chaque langage à travers des exemples concrets de code et des cas d'usage.
L'analyse exploratoire des données (EDA) et le nettoyage des données sont des étapes clés en data science. R et Python sont les deux langages les plus populaires pour ces tâches, mais leurs syntaxes et approches diffèrent, ce qui peut prêter à confusion pour les nouveaux utilisateurs.
R est un langage statistique né pour l'analyse de données. Python est un langage généraliste qui a développé d'excellentes bibliothèques pour la data science.
Infographie comparant les écosystèmes R et Python
L'importation des données est la première étape de toute analyse.
# Chargement d'un fichier CSV en R (fonction de base)
data <- read.csv("fichier_donnees.csv")
# Avec readr (plus rapide pour les gros fichiers)
library(readr)
data <- read_csv("fichier_donnees.csv")import pandas as pd
# Chargement d'un fichier CSV
data = pd.read_csv("fichier_donnees.csv")En R, read.csv() fait partie des fonctions de base. En Python, il faut importer Pandas et utiliser pd.read_csv(). Pandas est la bibliothèque incontournable pour la manipulation de données en Python.
schéma d'importation de fichiers CSV
Après l'importation, il faut examiner rapidement les données pour comprendre leur structure.
# Afficher les premières lignes
head(data)
# Afficher les dernières lignes
tail(data)
# Structure des données
str(data)
# Résumé statistique complet
summary(data)# Afficher les premières lignes
data.head()
# Afficher les dernières lignes
data.tail()
# Informations sur les colonnes (type, non-null)
data.info()
# Résumé statistique (uniquement numérique)
data.describe()
# Pour les variables catégorielles
data['colonne'].value_counts()summary() en R fonctionne sur toutes les colonnes (numériques, facteurs, caractères). describe() en Python ne donne des stats que pour les colonnes numériques. Pour les variables catégorielles, utilisez value_counts().
# Avec le symbole $
data$colonne
# Avec dplyr
library(dplyr)
data %>% select(colonne)# Syntaxe simple
data["colonne"]
# Alternative
data.colonne # (si pas d'espace dans le nom)library(dplyr)
filtered_data <- data %>% filter(colonne == "valeur")# Filtrage direct
filtered_data = data[data["colonne"] == "valeur"]
# Avec query() pour plus de lisibilité
filtered_data = data.query("colonne == 'valeur'")R avec dplyr propose une syntaxe pipe-friendly (%>%) très lisible. Python utilise une notation entre crochets qui peut devenir complexe avec des conditions multiples, mais la méthode query() améliore la lisibilité.
# Vérifier les valeurs manquantes
is.na(data)
colSums(is.na(data))
# Supprimer les lignes avec des NA
clean_data <- na.omit(data)
# Imputation par la moyenne
data$colonne[is.na(data$colonne)] <- mean(data$colonne, na.rm = TRUE)# Vérifier les valeurs manquantes
data.isna()
data.isna().sum()
# Supprimer les lignes avec des NA
clean_data = data.dropna()
# Imputation par la moyenne
data['colonne'] = data['colonne'].fillna(data['colonne'].mean())na.omit() en R est simple mais sans finesse. Pandas offre plus de contrôle avec dropna(how='all', subset=['col1','col2']) et fillna() pour l'imputation.
library(ggplot2)
# Nuage de points
ggplot(data, aes(x = colonne_x, y = colonne_y)) +
geom_point() +
geom_smooth(method = "lm") +
labs(title = "Relation entre X et Y")
# Histogramme
ggplot(data, aes(x = colonne)) +
geom_histogram(bins = 30, fill = "steelblue")import seaborn as sns
import matplotlib.pyplot as plt
# Nuage de points
sns.scatterplot(x='colonne_x', y='colonne_y', data=data)
plt.title("Relation entre X et Y")
# Histogramme
sns.histplot(data['colonne'], bins=30, color='steelblue')
plt.title("Distribution de la colonne")ggplot2 est basé sur la "grammaire des graphiques" – plus conceptuel mais très puissant une fois maîtrisé. Seaborn est plus simple à prendre en main, avec des defaults esthétiques, mais moins flexible pour les graphiques très complexes.
exemple des mêmes graphiques avec les deux bibliothèques
library(dplyr)
data <- data %>%
mutate(nouvelle_colonne = colonne1 + colonne2,
categorie = case_when(
score > 80 ~ "A",
score > 60 ~ "B",
TRUE ~ "C"
))# Création simple
data['nouvelle_colonne'] = data['colonne1'] + data['colonne2']
# Création avec conditions (np.where)
import numpy as np
data['categorie'] = np.where(data['score'] > 80, 'A',
np.where(data['score'] > 60, 'B', 'C'))library(dplyr)
summary_data <- data %>%
group_by(categorie) %>%
summarise(
moyenne = mean(valeur, na.rm = TRUE),
count = n(),
somme = sum(valeur, na.rm = TRUE)
)summary_data = data.groupby('categorie').agg(
moyenne=('valeur', 'mean'),
count=('valeur', 'count'),
somme=('valeur', 'sum')
).reset_index()La syntaxe dplyr est très lisible et naturelle pour les personnes venant du SQL. La syntaxe Pandas avec groupby() et agg() est plus compacte mais peut être moins intuitive au début.
| Aspect | R | Python |
|---|---|---|
| Courbe d'apprentissage | Plus raide pour les débutants hors stats | Plus douce, langage généraliste |
| Statistiques avancées | ✅ Exceptionnel (modèles intégrés) | ⚠️ Nécessite des bibliothèques (statsmodels) |
| Manipulation de données | ✅ dplyr très intuitif | ✅ Pandas très puissant |
| Visualisation | ✅ ggplot2 (puissant mais complexe) | ✅ Seaborn (simple), Plotly (interactif) |
| Machine Learning / IA | ⚠️ Possible mais moins mature | ✅ Leader (scikit-learn, TensorFlow) |
| Intégration en production | ⚠️ Possible (Plumber, Shiny Server) | ✅ Leader (APIs, microservices) |
| Communauté académique | ✅ Très forte (statistiques, éco) | ⚠️ Forte mais plus orientée industrie |
→ R est votre allié. Les bibliothèques statistiques sont nombreuses, la visualisation avec ggplot2 est puissante, et la communauté académique est très active.
→ Python est plus polyvalent. Il s'intègre mieux dans des chaînes de production, des APIs, et domine le machine learning et l'IA.
→ Pourquoi choisir ? Utilisez RStudio qui supporte nativement Python (via reticulate) ou passez par des formats d'échange comme Parquet pour collaborer.
Pour l'exploration interactive, R avec RStudio offre une expérience très fluide. Pour le traitement de très gros volumes (milliards de lignes), Python avec Pandas peut être limité ; on passe alors à Polars, Dask ou Spark (disponibles en Python). R a des alternatives comme data.table pour les gros volumes.
Oui ! Dans RStudio, le package reticulate permet d'exécuter du code Python. Vous pouvez aussi passer par des fichiers intermédiaires (CSV, Parquet) ou utiliser des notebooks Jupyter qui supportent les deux langages (avec des kernels différents).
ggplot2 (R) est plus puissant pour les visualisations statistiques complexes et les personnalisations fines. Python a l'avantage des graphiques interactifs (Plotly, Bokeh) et de l'intégration avec le web. Les deux sont excellents, le choix dépend de vos besoins.
Python domine le marché de l'emploi en data science et en IA (environ 60-70% des offres). R reste très présent dans les secteurs très réglementés (banque, pharma, assurance) et en recherche académique. Connaître les deux est un atout majeur.
Côté R : data.table est plus rapide que dplyr pour les très gros volumes. Côté Python : Polars (plus rapide que Pandas), Dask (pour le parallélisme) et DuckDB (SQL in-process) gagnent en popularité.
R et Python sont tous deux excellents pour l'analyse exploratoire et le nettoyage des données. Le choix dépend davantage de votre profil et de votre contexte que de la supériorité technique d'un langage sur l'autre.