Tracer toutes les variables en R avec ggplot2 et ggpubr

Voir chaque colonne d’un data frame d’un seul coup — passez en format long, puis facet_wrap par variable dans un seul appel ggplot, plus les one-liners ggpubr soignés

Tracez toutes les variables d’un data frame d’un coup en R — la distribution de chaque colonne numérique, ou chaque variable répartie par groupe, sans écrire un graphique par colonne. Passez du format large au format long avec tidyr::pivot_longer(), puis facet_wrap(~ variable, scales = “free”) pour dessiner un panneau par variable dans un seul appel ggplot2. Plus les one-liners ggpubr prêts à publier. R prêt à copier, résultats expliqués.

AstuceCe que vous trouverez ici

• Tracer chaque colonne d’un data frame d’un coup — un panneau par variable dans un seul appel ggplot(), au lieu d’écrire un graphique par colonne à la main.
• La recette qui passe à l’échelle : passez du format large au format long avec tidyr::pivot_longer(), puis ggplot2::facet_wrap(~ variable, scales = "free") pour donner à chaque variable son propre panneau et son propre axe.
• Comparez chaque variable selon un facteur de regroupement d’un coup d’œil en ajoutant la couleur/le remplissage et une palette de revue adaptée au daltonisme.
• Les one-liners ggpubr prêts à publier (ggboxplot, gghistogram, ggdensity) qui tracent plusieurs variables à la fois.
• Chaque figure est rendue à partir de vrai code R prêt à copier, à l’aide des données intégrées iris.

Vous venez de charger un data frame et vous voulez le voir — la distribution de chaque colonne numérique, ou chaque mesure comparée entre les groupes. L’approche naïve consiste à écrire un ggplot() par colonne : acceptable pour deux variables, insupportable pour vingt, et impossible à garder propre. Il existe une bien meilleure façon de faire, et c’est le même geste que vous ayez 4 colonnes ou 400.

L’astuce : ne bouclez pas sur les colonnes — remodelez les données. Transformez la table large (une colonne par variable) en une table longue (une ligne par valeur, avec une étiquette variable), puis laissez ggplot2 dessiner un panneau par variable avec facet_wrap(). Un seul appel, quel que soit le nombre de variables. Ce billet présente cette recette de bout en bout, puis les raccourcis soignés de ggpubr pour le même travail. Nous utilisons les données intégrées iris (150 fleurs, quatre mesures numériques, un facteur de regroupement Species), donc chaque bloc s’exécute tel quel.

Mise en place

Installez les deux packages une fois, puis chargez-les. tidyr fournit pivot_longer() (le remodelage) et ggplot2 dessine les graphiques. iris est fourni avec R.

install.packages(c("tidyr", "ggplot2"))

library(tidyr)     # pivot_longer(): reshape wide -> long
library(ggplot2)   # the plots

data(iris)         # 150 flowers, 4 numeric measurements, 3 species
head(iris, 3)

  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa

Toutes les distributions numériques en un seul appel

La recette complète tient en deux étapes. D’abord, remodeler : pivot_longer() empile les colonnes sélectionnées dans deux nouvelles colonnes — variable (l’ancien nom de colonne) et value (le nombre). Nous choisissons les colonnes à empiler avec cols = where(is.numeric), qui saisit toutes les colonnes numériques automatiquement (cela fonctionne donc sans changement sur n’importe quel data frame, quels que soient les noms de ses colonnes). Les 4 colonnes numériques × 150 lignes du data frame iris se réduisent à 600 lignes longues :

iris_long <- pivot_longer(
  iris,
  cols = where(is.numeric),   # every numeric column, whatever it's named
  names_to = "variable",      # old column name -> this column
  values_to = "value"         # the number -> this column
)
dim(iris_long)          # 600 rows, one per value

[1] 600   3

head(iris_long, 3)

# A tibble: 3 × 3
  Species variable     value
  <fct>   <chr>        <dbl>
1 setosa  Sepal.Length   5.1
2 setosa  Sepal.Width    3.5
3 setosa  Petal.Length   1.4

Ensuite, facetter : tracez value une seule fois, puis répartissez en panneaux avec facet_wrap(~ variable). L’argument clé est scales = "free", qui donne à chaque panneau ses propres axes x et y — essentiel ici car la largeur de pétale (≈ 0.1–2.5 cm) et la longueur de sépale (≈ 4–8 cm) occupent des plages très différentes et seraient illisibles si on les forçait sur un axe commun :

ggplot(iris_long, aes(x = value)) +
  geom_histogram(bins = 20, fill = "#3a86d4", colour = "white") +
  facet_wrap(~ variable, scales = "free") +
  labs(x = NULL, y = "Count") +
  theme_minimal(base_size = 12)

Voilà la distribution de chaque variable en une seule figure. Lisez-la panneau par panneau : la longueur de sépale et la largeur de sépale forment des bosses uniques, à peu près en cloche (moyennes de 5.84 cm et 3.06 cm), tandis que les deux mesures de pétale sont clairement bimodales — un petit amas près de zéro et un étalement plus large au-dessus. Cet écart est la signature des trois espèces, que nous allons révéler ensuite.

La version densité est la compagne lissée — remplacez geom_histogram() par geom_density(). Elle est plus facile à lire quand les barres semblent bruitées ou que vous voulez superposer des groupes :

ggplot(iris_long, aes(x = value)) +
  geom_density(fill = "#3a86d4", alpha = 0.5, colour = "#3a86d4") +
  facet_wrap(~ variable, scales = "free") +
  labs(x = NULL, y = "Density") +
  theme_minimal(base_size = 12)

Les courbes lissées rendent la forme à deux pics de Petal.Length et Petal.Width indéniable, et confirment les bosses uniques des mesures de sépale.

Chaque variable, répartie par groupe

Le geste exploratoire le plus utile consiste à comparer chaque variable selon un facteur de regroupement. Comme pivot_longer() n’a empilé que les colonnes numériques, le facteur Species reste attaché à chaque ligne longue — nous pouvons donc l’associer à fill et obtenir, par panneau, une distribution par groupe :

ggplot(iris_long, aes(x = value, fill = Species, colour = Species)) +
  geom_density(alpha = 0.4) +
  facet_wrap(~ variable, scales = "free") +
  scale_fill_manual(values = c("#0073C2", "#EFC000", "#868686")) +   # jco, colourblind-safe
  scale_colour_manual(values = c("#0073C2", "#EFC000", "#868686")) +
  labs(x = NULL, y = "Density") +
  theme_minimal(base_size = 12) +
  theme(legend.position = "top")

Le mystère précédent se résout maintenant : les deux bosses des panneaux de pétale étaient setosa (fortement regroupée sur de petites valeurs) à l’écart de versicolor et virginica. La longueur et la largeur de pétale séparent les trois espèces presque parfaitement, tandis que les mesures de sépale se chevauchent bien plus — exactement le type d’éclairage « quelle variable discrimine les groupes ? » que vous recherchez avant toute modélisation.

Vous préférez des boîtes à moustaches pour la vue par groupe ? Placez les panneaux variable sur la facette x et les groupes sur l’axe. Les boîtes à moustaches se lisent bien quand vous vous intéressez aux médianes et aux valeurs aberrantes plutôt qu’à la forme complète :

ggplot(iris_long, aes(x = Species, y = value, fill = Species)) +
  geom_boxplot(alpha = 0.8, outlier.size = 0.8) +
  facet_wrap(~ variable, scales = "free_y") +
  scale_fill_manual(values = c("#0073C2", "#EFC000", "#868686")) +
  labs(x = NULL, y = NULL) +
  theme_minimal(base_size = 12) +
  theme(legend.position = "none",
        axis.text.x = element_text(angle = 15, hjust = 1))

Ici, scales = "free_y" ne libère que l’axe y (les groupes sur x sont partagés), de sorte que chaque mesure conserve sa plage naturelle tandis que les espèces s’alignent d’un panneau à l’autre.

Prêt à publier en une ligne avec ggpubr

La recette de facettage ci-dessus est la réponse générale et flexible. Quand vous voulez une figure au style prêt à publier avec moins de code, ggpubr — une surcouche de ggplot2 — trace plusieurs variables à la fois à partir d’un seul appel. Installez-le et chargez-le :

install.packages("ggpubr")

library(ggpubr)

Passez à ggboxplot() un vecteur de colonnes y et combine = TRUE, et il dispose un panneau par variable — coloré par groupe, avec les points bruts et la moyenne du groupe par-dessus, le tout dans une palette de revue adaptée au daltonisme ("jco"). Pas de remodelage manuel, pas de réglage de thème :

ggboxplot(
  iris, x = "Species",
  y = c("Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width"),
  combine = TRUE,
  color = "Species", palette = "jco",
  ylab = "Measurement (cm)",
  add = c("mean", "jitter"),
  add.params = list(size = 0.5, jitter = 0.2)
)

combine = TRUE crée la disposition multi-panneaux ; color = "Species" divise chaque panneau par groupe et palette = "jco" le colore. Les points dispersés et les marqueurs de moyenne suivent le style maison — une boîte nue cache la taille d’échantillon et la forme. C’est la même histoire que les boîtes à moustaches facettées, en un seul appel de fonction soigné.

Pour les distributions, gghistogram() et ggdensity() prennent un seul x, alors remodelez d’abord en format long (comme ci-dessus) et utilisez facet.by = "variable" pour créer un panneau par variable — l’équivalent ggpubr de facet_wrap(), avec le style de publication intégré :

iris_long <- pivot_longer(iris, cols = where(is.numeric),
                          names_to = "variable", values_to = "value")

ggdensity(
  iris_long, x = "value",
  color = "Species", fill = "Species", palette = "jco",
  rug = TRUE, alpha = 0.4,
  facet.by = "variable", scales = "free"
)

facet.by = "variable" répartit les données longues en panneaux, scales = "free" libère chaque axe, et rug = TRUE ajoute un tapis marginal des valeurs brutes. Remplacez ggdensity() par gghistogram() (ajoutez bins = 20) pour la version en barres. Dans les deux cas, vous obtenez la même vue « toutes les variables, par groupe » que la recette ggplot2 brute — avec les réglages par défaut de ggpubr au lieu d’un thème construit à la main.

Toutes les relations deux à deux et corrélations

Une demande est souvent confondue avec « tracer toutes les variables » : voir comment les variables sont liées entre elles — chaque nuage de points deux à deux, ou une matrice de corrélation. C’est une autre question. « Tracer toutes les variables » (ce billet) montre la distribution de chaque colonne dans son propre panneau ; « toutes les relations deux à deux » montre chaque paire de colonnes ensemble, c’est-à-dire une matrice de nuages de points ou une heatmap de corrélation.

Pour une matrice de corrélation visualisée en heatmap, le bon outil est ggcorrplot — calculez les corrélations avec la fonction cor() de R de base, puis tracez :

library(ggcorrplot)

corr <- cor(iris[, 1:4])          # 4x4 correlation matrix
ggcorrplot(
  corr, type = "lower", lab = TRUE,
  colors = c("#0073C2", "white", "#CD534C")
)

Chaque cellule est la corrélation de Pearson entre deux mesures : la longueur et la largeur de pétale sont presque parfaitement corrélées (0.96), et toutes deux suivent fortement la longueur de sépale, tandis que la largeur de sépale fait figure d’exception. Pour le traitement complet — réordonnancement, significativité, regroupement de la matrice — voyez les leçons liées ci-dessous.

Quelle recette pour quelle question ?

Vous voulez voir…	Utilisez
La distribution de chaque colonne d’un coup	pivot_longer() → geom_histogram()/geom_density() + facet_wrap(~ variable, scales = "free")
Chaque variable comparée entre les groupes	la même chose, plus fill = group (densité) ou des boîtes à moustaches par panneau
La même chose, au style publication, en un appel	ggpubr::ggboxplot(y = c(...), combine = TRUE) ou ggdensity(..., facet.by = "variable")
Chaque corrélation deux à deux	cor() → ggcorrplot::ggcorrplot()

Le schéma à retenir : remodelez en long, puis facettez. Il transforme « un graphique par colonne » en un seul graphique, point final — et s’adapte à n’importe quel nombre de variables sans toucher au code.

Questions fréquentes

NoteComment tracer toutes les colonnes d’un data frame en R d’un seul coup ?

Remodelez le data frame du format large au format long avec tidyr::pivot_longer(cols = where(is.numeric), names_to = "variable", values_to = "value"), puis dessinez un seul ggplot() et répartissez-le en un panneau par colonne avec facet_wrap(~ variable, scales = "free"). Comme pivot_longer() sélectionne les colonnes par programme, les deux mêmes lignes tracent 4 colonnes ou 400 — vous n’écrivez jamais un graphique par colonne à la main.

NoteComment facetter par toutes les variables dans ggplot2 ?

facet_wrap() facette par une colonne, pas par « toutes les variables » directement — empilez donc d’abord vos variables dans une seule colonne variable avec pivot_longer(), puis facet_wrap(~ variable). Ajoutez scales = "free" pour que chaque panneau obtienne sa propre plage d’axe (utilisez "free_x" ou "free_y" pour ne libérer qu’un seul axe), ce que vous voulez presque toujours quand les variables sont sur des échelles différentes.

NoteComment tracer toutes les variables numériques d’un data frame ?

Sélectionnez les colonnes numériques avec where(is.numeric) à l’intérieur de pivot_longer(cols = where(is.numeric), ...) — cela saisit chaque colonne numérique et ignore automatiquement les facteurs, les caractères et les dates. Facettez ensuite par la colonne variable obtenue. Pour un raccourci prêt à publier, ggpubr::ggboxplot() et gghistogram() acceptent un vecteur de noms de colonnes numériques avec combine = TRUE.

NoteÀ quoi sert scales = “free” dans facet_wrap ?

Par défaut, chaque panneau de facette partage les mêmes axes x et y, si bien que les panneaux sont directement comparables. scales = "free" laisse chaque panneau fixer sa propre plage d’axe indépendamment — essentiel quand vous facettez par variable, car des variables différentes vivent sur des échelles différentes (par exemple la largeur de pétale en dixièmes de centimètre contre la longueur de sépale proche de 6 cm) et seraient écrasées ou tronquées sur un axe commun. Utilisez "free_x" ou "free_y" pour ne libérer qu’un seul axe.

NoteComment tracer chaque variable répartie par un facteur de regroupement ?

Gardez la colonne de regroupement hors du remodelage (pivot_longer() n’empile que les colonnes numériques, le facteur reste donc attaché à chaque ligne), puis associez-la à fill/colour et facettez par variable : ggplot(long, aes(value, fill = group)) + geom_density(alpha = 0.4) + facet_wrap(~ variable, scales = "free"). Utilisez une palette adaptée au daltonisme comme jco ou npg. Cette vue « chaque mesure, par groupe » est le moyen le plus rapide de repérer quelles variables séparent vos groupes.

Pour aller plus loin

• Les facettes ggplot2 en R — facet_wrap() et facet_grid() en profondeur. · Série ggplot2 · Série ggpubr · Histogramme et densité avec ggpubr · ggcorrplot en R · Matrice de corrélation en R · Visualisation de données.

🟢 Avec un agent IA

Demandez à Prova « trace la distribution de chaque colonne numérique de mon data frame, répartie par ma colonne de groupe, dans une seule figure facettée » — elle répond avec du code que vous pouvez exécuter sur vos propres données. The runtime is the judge. Demander à Prova →

Cette page vous a-t-elle été utile ?

Recevez les nouvelles leçons R & Python par e-mail

Pratique, reproductible, sans spam. Désinscription à tout moment.

Double opt-in. Nous ne partageons jamais votre e-mail.

Partager cette pageXLinkedInRedditHN