Diagramme en barres en R (ggpubr) : trié, lollipop & points

Des diagrammes en barres prêts à publier en un seul appel — plus les alternatives modernes : graphique lollipop et graphique de Cleveland

Créez des diagrammes en barres prêts à publier en R avec ggbarplot() de ggpubr — colorés par groupe, empilés ou juxtaposés, triés par valeur, et sous forme de graphiques de déviation — puis passez aux alternatives modernes avec ggdotchart() : graphiques lollipop triés et graphiques de points de Cleveland avec segments, groupes et étiquettes de valeurs. Chaque exemple est rendu pour vous et s’exécute en direct dans votre navigateur.

AstucePoints clés

• ggbarplot() trace un diagramme en barres prêt pour la revue en un seul appel : colorez ou remplissez par groupe avec color =/fill = + une palette nommée ("jco", "npg", …), et passez à l’horizontale avec rotate = TRUE.
• Comparez une seconde variable en la mappant à fill : empilez les barres (label = TRUE, lab.pos = "in") ou juxtaposez-les côte à côte avec position = position_dodge().
• Triez les barres par valeur avec sort.val = "desc" (ou "asc") ; sort.by.groups = FALSE trie globalement, TRUE trie au sein de chaque groupe. x.text.angle = 90 fait pivoter les étiquettes longues.
• Un graphique de déviation est un diagramme en barres trié d’un score z, rempli selon le signe — montrant instantanément quels éléments sont au-dessus ou en dessous de la référence.
• Pour de nombreuses catégories, passez aux alternatives modernes avec ggdotchart() : un graphique lollipop (add = "segments") ou un graphique de points de Cleveland (rotate = TRUE, y.text.col = TRUE, + theme_cleveland()) — bien moins d’encre qu’un mur de barres.
• ggpubr applique theme_pubr() automatiquement, si bien que tout semble prêt à publier d’emblée — vous n’ajoutez pas de thème.

LivreObtenez le livre — R Graphics Essentials (PDF)→

Introduction

Un diagramme en barres est l’option par défaut pour comparer des valeurs entre catégories, et ggpubr en trace un prêt à publier en un seul appel. Mais quand vous avez de nombreuses catégories — chaque voiture d’un parc, chaque gène d’un panel — un mur de barres gaspille de l’encre et est difficile à parcourir. Cette leçon couvre les deux : le flux de travail canonique ggbarplot() (coloré, empilé, juxtaposé, trié, graphiques de déviation) et les alternatives modernes — graphiques lollipop et graphiques de points de Cleveland — tracés avec ggdotchart().

Deux fonctions portent toute la leçon :

• ggbarplot() — un diagramme en barres prêt à publier. Colorez ou remplissez par groupe, empilez ou juxtaposez une seconde variable, triez les barres par valeur, étiquetez-les, passez à l’horizontale.
• ggdotchart() — le graphique lollipop / de points de Cleveland. Même interface par noms de colonnes, avec sorting, des segments allant de la ligne de base au point, un ordre par groupe, et des étiquettes de valeurs.

Les deux appliquent automatiquement le theme_pubr() épuré de ggpubr, vous n’ajoutez donc pas de thème. Nous utilisons les données intégrées mtcars — ses noms de lignes sont de vraies étiquettes de voitures, idéales pour les barres triées et les lollipops — et ToothGrowth où un petit exemple catégoriel groupé se lit plus clairement. Chaque figure est rendue ici même, et vous pouvez réexécuter ou modifier chacune d’elles en direct.

Vous voulez la grammaire sous-jacente — geom_bar() / geom_col() couche par couche ? Voir les leçons ggplot2 diagramme en barres et graphique de points. ggpubr est le raccourci de publication par-dessus les mêmes geoms.

Le graphique lollipop (le graphique que la plupart des gens recherchent)

Voici l’image phare : un graphique lollipop du score z d’efficacité énergétique (mpg) de chaque voiture, trié par ordre décroissant, groupé et coloré par nombre de cylindres, avec des segments vers la ligne de base et la valeur imprimée sur chaque point. Un lollipop est un diagramme en barres dont la barre est réduite à un fin segment — bien moins d’encre quand vous avez de nombreuses catégories. x/y sont des noms de colonnes sous forme de chaînes ; add = "segments" trace le bâtonnet ; group ordonne au sein des groupes de couleur ; label imprime la valeur. Tout le reste de la leçon converge vers ceci.

library(ggpubr)
dfm <- mtcars
dfm$cyl <- factor(dfm$cyl)
dfm$name <- rownames(dfm)
dfm$mpg_z <- (dfm$mpg - mean(dfm$mpg)) / sd(dfm$mpg)

ggdotchart(dfm, x = "name", y = "mpg_z",
           color = "cyl", palette = "jco",                # colour by cylinders
           sorting = "descending",                        # sort by value
           add = "segments",                              # stick from baseline to dot
           add.params = list(color = "lightgray", size = 2),
           group = "cyl",                                 # order within groups
           dot.size = 6,
           label = round(dfm$mpg_z, 1),                   # value on the dot
           font.label = list(color = "white", size = 9, vjust = 0.5),
           ggtheme = theme_pubr()) +
  geom_hline(yintercept = 0, linetype = 2, color = "lightgray")

Nous y arriverons progressivement. D’abord, les fondamentaux du diagramme en barres.

Diagrammes en barres de base

Le cas le plus simple : une valeur par catégorie. ggbarplot() prend le data frame et les noms de colonnes x/y. Définissez un fill plein et un contour color ; passez à une disposition horizontale avec rotate = TRUE (pratique quand les étiquettes de catégories sont longues).

library(ggpubr)
df <- data.frame(dose = c("D0.5", "D1", "D2"),
                 len  = c(4.2, 10, 29.5))

ggbarplot(df, x = "dose", y = "len",
          color = "black", fill = "lightgray")

Colorez les barres par groupe en mappant une variable à fill (et/ou color) et en passant une palette nommée — les jeux de revue ("jco", "npg", "lancet"), un nom Brewer, ou votre propre vecteur.

library(ggpubr)
df <- data.frame(dose = c("D0.5", "D1", "D2"),
                 len  = c(4.2, 10, 29.5))

ggbarplot(df, x = "dose", y = "len",
          fill = "dose", color = "dose", palette = "jco")

Plusieurs variables de groupement : empiler ou juxtaposer

Avec une seconde variable catégorielle, mappez-la à fill. Par défaut, les barres s’empilent ; ajoutez label = TRUE avec lab.pos = "in" pour imprimer la valeur de chaque segment à l’intérieur de la barre.

library(ggpubr)
df2 <- data.frame(supp = rep(c("VC", "OJ"), each = 3),
                  dose = rep(c("D0.5", "D1", "D2"), 2),
                  len  = c(6.8, 15, 33, 4.2, 10, 29.5))

ggbarplot(df2, x = "dose", y = "len",
          fill = "supp", color = "supp", palette = "jco",
          label = TRUE, lab.col = "white", lab.pos = "in")

Pour comparer directement les deux sous-groupes, juxtaposez-les côte à côte avec position = position_dodge().

library(ggpubr)
df2 <- data.frame(supp = rep(c("VC", "OJ"), each = 3),
                  dose = rep(c("D0.5", "D1", "D2"), 2),
                  len  = c(6.8, 15, 33, 4.2, 10, 29.5))

ggbarplot(df2, x = "dose", y = "len",
          fill = "supp", color = "supp", palette = "jco",
          position = position_dodge(0.9))

Diagrammes en barres triés

Un diagramme en barres est bien plus facile à lire quand les barres sont triées par valeur plutôt que laissées dans l’ordre des catégories. Utilisez sort.val = "desc" (ou "asc") et faites pivoter les étiquettes x encombrées avec x.text.angle = 90. Nous passons à mtcars, dont les noms de lignes donnent une barre par voiture.

library(ggpubr)
dfm <- mtcars
dfm$cyl <- factor(dfm$cyl)
dfm$name <- rownames(dfm)

ggbarplot(dfm, x = "name", y = "mpg",
          fill = "cyl", color = "white", palette = "jco",
          sort.val = "desc",          # sort by value
          sort.by.groups = FALSE,     # globally, not within each group
          x.text.angle = 90)

Mettez sort.by.groups = TRUE pour trier au sein de chaque groupe de couleur — les voitures se regroupent par nombre de cylindres, triées par mpg à l’intérieur de chaque grappe.

library(ggpubr)
dfm <- mtcars
dfm$cyl <- factor(dfm$cyl)
dfm$name <- rownames(dfm)

ggbarplot(dfm, x = "name", y = "mpg",
          fill = "cyl", color = "white", palette = "jco",
          sort.val = "asc",
          sort.by.groups = TRUE,      # sort within each group
          x.text.angle = 90)

Graphiques de déviation

Un graphique de déviation est un diagramme en barres trié de l’écart de chaque valeur par rapport à une référence — typiquement un score z (distance standardisée à la moyenne). Remplir selon le signe du score (high contre low) rend la séparation au-dessus/en dessous immédiatement lisible. Calculez le score z en R de base, puis triez et colorez par le groupe.

library(ggpubr)
dfm <- mtcars
dfm$name <- rownames(dfm)
dfm$mpg_z <- (dfm$mpg - mean(dfm$mpg)) / sd(dfm$mpg)
dfm$mpg_grp <- factor(ifelse(dfm$mpg_z < 0, "low", "high"),
                      levels = c("low", "high"))

ggbarplot(dfm, x = "name", y = "mpg_z",
          fill = "mpg_grp", color = "white", palette = "jco",
          sort.val = "asc",
          sort.by.groups = FALSE,
          x.text.angle = 90,
          ylab = "MPG z-score", xlab = FALSE,
          legend.title = "MPG group")

Passez-le à l’horizontale avec rotate = TRUE (et sort.val = "desc" pour que le plus grand soit en haut) — les longs noms de voitures sont bien plus lisibles le long de l’axe y.

library(ggpubr)
dfm <- mtcars
dfm$name <- rownames(dfm)
dfm$mpg_z <- (dfm$mpg - mean(dfm$mpg)) / sd(dfm$mpg)
dfm$mpg_grp <- factor(ifelse(dfm$mpg_z < 0, "low", "high"),
                      levels = c("low", "high"))

ggbarplot(dfm, x = "name", y = "mpg_z",
          fill = "mpg_grp", color = "white", palette = "jco",
          sort.val = "desc",
          sort.by.groups = FALSE,
          x.text.angle = 90,
          ylab = "MPG z-score", legend.title = "MPG group",
          rotate = TRUE)

Graphiques lollipop

Quand le nombre de catégories augmente, un graphique lollipop est la meilleure alternative : il porte la même information qu’un diagramme en barres trié avec une fraction de l’encre. Tracez-le avec ggdotchart() et add = "segments" — le segment va de la ligne de base au point, comme une fine barre.

library(ggpubr)
dfm <- mtcars
dfm$cyl <- factor(dfm$cyl)
dfm$name <- rownames(dfm)

ggdotchart(dfm, x = "name", y = "mpg",
           color = "cyl", palette = "jco",
           sorting = "ascending",     # sort by value
           add = "segments",          # stick from baseline to dot
           ggtheme = theme_pubr())

Enrichissez-le : triez en descending, ordonnez au sein de chaque groupe avec group = "cyl", agrandissez les points et imprimez la valeur dessus, et passez à la verticale avec rotate = TRUE pour que les étiquettes se lisent proprement.

library(ggpubr)
dfm <- mtcars
dfm$cyl <- factor(dfm$cyl)
dfm$name <- rownames(dfm)

ggdotchart(dfm, x = "name", y = "mpg",
           color = "cyl", palette = "jco",
           sorting = "descending",
           add = "segments",
           rotate = TRUE,                 # vertical layout
           group = "cyl",                 # order within groups
           dot.size = 6,
           label = round(dfm$mpg),        # value on the dot
           font.label = list(color = "white", size = 9, vjust = 0.5),
           ggtheme = theme_pubr())

Un lollipop fait aussi un graphique de déviation propre : tracez le score z, colorez les segments en gris, et ajoutez une ligne en tirets à zéro pour la référence.

library(ggpubr)
dfm <- mtcars
dfm$cyl <- factor(dfm$cyl)
dfm$name <- rownames(dfm)
dfm$mpg_z <- (dfm$mpg - mean(dfm$mpg)) / sd(dfm$mpg)

ggdotchart(dfm, x = "name", y = "mpg_z",
           color = "cyl", palette = "jco",
           sorting = "descending",
           add = "segments",
           add.params = list(color = "lightgray", size = 2),
           group = "cyl",
           dot.size = 6,
           label = round(dfm$mpg_z, 1),
           font.label = list(color = "white", size = 9, vjust = 0.5),
           ggtheme = theme_pubr()) +
  geom_hline(yintercept = 0, linetype = 2, color = "lightgray")

Graphiques de points de Cleveland

Un graphique de points de Cleveland est le cousin plus discret du lollipop : de petits points, sans segments, pivotés en une liste verticale, avec les étiquettes d’axe colorées par groupe et de légers quadrillages en tirets ajoutés par theme_cleveland(). C’est la façon la plus dense en données de comparer de nombreuses catégories. Utilisez y.text.col = TRUE pour colorer les étiquettes de catégories par groupe.

library(ggpubr)
dfm <- mtcars
dfm$cyl <- factor(dfm$cyl)
dfm$name <- rownames(dfm)

ggdotchart(dfm, x = "name", y = "mpg",
           color = "cyl", palette = "jco",
           sorting = "descending",
           rotate = TRUE,
           dot.size = 2,
           y.text.col = TRUE,             # colour the labels by group
           ggtheme = theme_pubr()) +
  theme_cleveland()                       # add the dashed gridlines

Essayez en direct

Les graphiques ci-dessus ont été rendus au moment de la construction. Vous voulez expérimenter ? Modifiez le code et appuyez sur Run — il s’exécute dans votre navigateur via webR (pas de serveur, pas d’installation). Essayez de remplacer sorting par "ascending", de retirer add = "segments" pour un graphique de points simple, de changer la palette en "npg", ou de retourner rotate.

Vous travaillez en Python ? Un guide seaborn des barres/lollipops arrive dans la série Python.

🟢 Avec un agent IA

Demandez à Prova « j’ai 40 catégories à comparer — devrais-je utiliser un diagramme en barres, un graphique lollipop ou un graphique de points de Cleveland, et comment les trier ? » — elle répond avec du code que vous pouvez exécuter sur votre propre data frame, ce qui rend le choix reproductible. The runtime is the judge. Ask Prova →

Problèmes courants

• Les barres ne sont pas triées. Le tri est désactivé par défaut — mettez sort.val = "desc" (ou "asc") sur ggbarplot(), ou sorting = "descending" sur ggdotchart(). Les deux fonctions utilisent des noms d’arguments différents pour la même idée.
• Les étiquettes de l’axe x se chevauchent en une bouillie illisible. Avec de nombreuses catégories, faites-les pivoter avec x.text.angle = 90, ou retournez tout le graphique à l’horizontale/verticale avec rotate = TRUE pour que les étiquettes courent le long de l’axe.
• La palette est ignorée. Une palette nommée comme "jco" ne colore que lorsque vous mappez aussi une variable à fill ou color (par ex. fill = "cyl"). Sans attribut esthétique de groupement, il n’y a rien à colorer.
• Ma colonne x est les noms de lignes et rien ne se trace. mtcars garde les noms de voitures comme noms de lignes, pas une colonne — ajoutez d’abord df$name <- rownames(df), puis passez x = "name".
• ggdotchart() ne trie pas au sein des groupes. Passez group = (la colonne de groupement) pour qu’il ordonne les valeurs à l’intérieur de chaque groupe ; sans cela, sorting ordonne globalement.

Questions fréquentes

NoteComment créer un diagramme en barres en R avec ggpubr ?

Utilisez ggbarplot() : ggbarplot(df, x = "dose", y = "len") dessine un diagramme en barres prêt à publier en un seul appel — aucun réglage de theme() nécessaire (il applique theme_pubr() automatiquement). Mappez une variable de groupement à fill (par ex. fill = "dose") et ajoutez une palette nommée (palette = "jco") pour colorer les barres par groupe.

NoteComment ordonner ou trier les barres par valeur dans ggpubr ?

Passez sort.val = "desc" (ou "asc") à ggbarplot(). Par défaut, il trie globalement ; ajoutez sort.by.groups = TRUE pour trier au sein de chaque groupe de couleur à la place. Pour un graphique lollipop ou de points avec ggdotchart(), l’argument équivalent est sorting = "descending" / "ascending".

NoteQu’est-ce qu’un graphique lollipop et quand l’utiliser plutôt qu’un diagramme en barres ?

Un graphique lollipop est un diagramme en barres dont la barre est réduite à un fin segment se terminant par un point — tracé dans ggpubr avec ggdotchart(..., add = "segments"). Il porte la même information qu’un diagramme en barres trié mais avec bien moins d’encre, c’est donc le meilleur choix quand vous avez de nombreuses catégories (des dizaines de lignes) où un mur de barres devient difficile à parcourir.

NoteQuelle est la différence entre un graphique lollipop et un graphique de points de Cleveland ?

Les deux utilisent ggdotchart(). Un lollipop garde add = "segments" (le bâtonnet depuis la ligne de base souligne la magnitude). Un graphique de points de Cleveland supprime le segment, utilise de petits points, pivote en une liste verticale, et ajoute theme_cleveland() pour des quadrillages en tirets — la façon la plus dense en données de comparer de nombreuses catégories. Utilisez le lollipop pour insister sur la taille, le graphique de points pour empaqueter le plus de lignes proprement.

NoteComment créer un graphique de déviation (au-dessus/en dessous d’une référence) en R ?

Calculez un score z — df$z <- (df$value - mean(df$value)) / sd(df$value) — puis tracez-le comme un diagramme en barres trié ou un lollipop rempli selon le signe du score : ggbarplot(df, x = "name", y = "z", fill = "z_grp", sort.val = "asc"). La séparation en deux couleurs montre instantanément quels éléments sont au-dessus ou en dessous de la moyenne ; ajoutez geom_hline(yintercept = 0) sur un lollipop pour la ligne de référence.

Testez vos connaissances

ImportantExercice : un graphique lollipop trié et groupé

Complétez le code pour que le mpg de chaque voiture soit dessiné comme un lollipop (ggdotchart avec segments), trié par ordre décroissant, coloré par nombre de cylindres avec la palette "jco", et ordonné au sein de chaque groupe.

# sorting = "descending" sorts by value.
# add = "segments" turns the dots into lollipops.
# group = "cyl" orders the values within each cylinder group.

library(ggpubr) dfm <- mtcars dfm$cyl <- factor(dfm$cyl) dfm$name <- rownames(dfm) ggdotchart(dfm, x = "name", y = "mpg", color = "cyl", palette = "jco", sorting = "descending", add = "segments", group = "cyl", ggtheme = theme_pubr())

library(ggpubr)
dfm <- mtcars
dfm$cyl <- factor(dfm$cyl)
dfm$name <- rownames(dfm)

ggdotchart(dfm, x = "name", y = "mpg",
           color = "cyl", palette = "jco",
           sorting = "descending",
           add = "segments",
           group = "cyl",
           ggtheme = theme_pubr())

Vérification rapide. Vous avez 40 gènes à comparer sur une seule valeur d’expression et le diagramme en barres est un mur de barres illisible. Quelle est la meilleure solution ?

• A. Rendre les barres plus fines.
• B. Passer à un graphique lollipop ou un graphique de points de Cleveland (ggdotchart), trié par valeur.
• C. Supprimer la moitié des gènes.

Réponse : B — ggdotchart() utilise bien moins d’encre que les barres et reste lisible pour de nombreuses catégories ; triez-le (sorting = "descending") pour que le classement se lise d’un coup d’œil.

Conclusion

Vous avez construit des diagrammes en barres prêts à publier à la manière de ggpubr — ggbarplot() coloré ou rempli par groupe, empilé ou juxtaposé avec une seconde variable, trié par valeur (sort.val, sort.by.groups), passé à l’horizontale, et sous forme de graphique de déviation de scores z. Puis vous êtes passé aux alternatives modernes avec ggdotchart() : le graphique lollipop (add = "segments", groupé, étiqueté) et le graphique de points de Cleveland (y.text.col = TRUE, theme_cleveland()) — les bons outils quand un diagramme en barres a trop de catégories. Parce que ggpubr applique theme_pubr() automatiquement, chaque graphique est prêt pour la figure dès un seul appel.

Pour la grammaire sous-jacente, voir les leçons ggplot2 diagramme en barres et graphique de points. Pour mettre des moyennes avec barres d’erreur sur les barres au lieu de valeurs brutes, lisez ensuite la leçon moyennes & barres d’erreur.

Leçons connexes

• Moyennes & barres d’erreur — transformez ces barres en barres de moyennes de groupe ± SE/SD/CI. · Boîtes & violons — la vue de distribution de la même comparaison de groupes. · Diagramme en barres en R (ggplot2) — la version grammaire avec geom_bar()/geom_col(). · Graphique de points en R (ggplot2) — le graphique de points en pur ggplot2.
• Pour aller plus loin : ggpubr — la série complète prête à publier. · Visualisation de données — le pilier.

DatanoviaR Graphics EssentialsPDF

Vous préférez un livre ? R Graphics Essentials est disponible en PDF téléchargeable — toutes les leçons de cette série, hors ligne et à vous.

Obtenir le livre (PDF) →Les leçons restent gratuites en ligne.

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

Prouvez que vous savez le faire. Maîtrisez toute la série ggpubr — suivez votre parcours, construisez des projets et obtenez un certificat.

Commencer gratuitement →

Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.

dès 15 $/mois facturé annuellement

Passer à Pro →

✓ Vous êtes Pro — continuez. The runtime is the judge.

Prêt à passer à la vitesse supérieure ?

Prouvez-le — obtenez le certificat Graphiques prêts à publier avec statistiques.Passer l'évaluation →Essayez sur vos propres données avec Prova — the runtime is the judge.Ouvrir Prova →

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

Note

Cette leçon est reproductible : les figures sont exécutées au moment de la construction (si elles s’affichent, le code fonctionne), et le bac à sable et le quiz se réexécutent en direct dans votre navigateur. The runtime is the judge.