Tracer moyennes et barres d’erreur en R (ggpubr)

Tracez les moyennes de groupes avec des barres d’erreur SE, SD ou IC en un seul appel — en direct dans votre navigateur

Tracez moyennes et barres d’erreur en R avec ggpubr. Utilisez ggline(), ggbarplot() et ggerrorplot() avec add = “mean_se” (ou mean_sd, mean_ci, median_iqr) pour dessiner des statistiques résumées avec barres d’erreur, colorez par un second groupe avec position_dodge(), superposez les points bruts dispersés, et ajoutez les p-values avec stat_compare_means(). Modifiez et exécutez chaque exemple en direct.

AstucePoints clés

• Un seul argument fait le résumé : passez add = "mean_se" (ou "mean_sd", "mean_ci", "median_iqr") à ggline(), ggbarplot() ou ggerrorplot() et ggpubr calcule la statistique et dessine la barre d’erreur pour vous.
• ggline() = une ligne/un point de moyennes · ggbarplot() = des barres de moyennes · ggerrorplot() = la barre d’erreur seule — mêmes données, trois vues ; choisissez avec desc_stat / add.
• Choisissez le type d’erreur en changeant le suffixe : mean_se (erreur standard), mean_sd (dispersion), mean_ci (intervalle de confiance à 95 %). La fonction de résumé et la borne d’erreur sont un seul et même choix.
• Une ligne reliée de moyennes de groupes avec un IC à 95 % — ggline(add = "mean_ci") — est la réponse moderne au gplots::plotmeans() de R de base ; étiquetez la valeur moyenne et l’effectif n du groupe avec desc_statby().
• Groupez par une seconde variable avec color = "supp" et position = position_dodge() pour que les groupes se placent côte à côte au lieu de se chevaucher.
• Montrez les données brutes en empilant des géométries — add = c("mean_se", "jitter") superpose les points individuels sur le résumé.
• Ajoutez la significativité par-dessus avec stat_compare_means() — voir Ajouter des p-values.
• Chaque graphique ci-dessous est rendu pour vous — puis modifiez n’importe quel exemple en direct dans le bac à sable.

LivreObtenez le livre — R Graphics Essentials (PDF)→

Introduction

Vous avez une mesure groupée — la longueur des dents par dose, l’expression par condition — et vous voulez le résumé : la moyenne de chaque groupe avec une barre d’erreur, pas le nuage brut. En ggplot2 de base, cela passe par un appel à stat_summary() (ou par une pré-agrégation manuelle des données). Le package ggpubr ramène cela à un seul argument : indiquez à la fonction de tracé add = "mean_se" et elle calcule la moyenne et l’erreur standard puis dessine la barre d’erreur — sans aggregate() manuel, sans coordonnées geom_errorbar().

Il existe trois fonctions de tracé, une par vue du même résumé :

• ggline() — les moyennes sous forme de graphique en ligne/points (idéal pour un axe x ordonné, comme la dose ou le temps).
• ggbarplot() — les moyennes sous forme de barres avec barres d’erreur au sommet.
• ggerrorplot() — seulement le point + la barre d’erreur, sans barre ni ligne — le plus épuré des « moyenne ± erreur ».

Et un choix qui les traverse toutes — quelle statistique : erreur standard (mean_se), écart-type (mean_sd), un intervalle de confiance à 95 % (mean_ci), ou un résumé robuste par la médiane (median_iqr). Cette leçon parcourt les trois fonctions sur les données intégrées ToothGrowth, montre comment colorer par un second groupe, superposer les points bruts, et enfin ajouter les p-values.

ggpubr applique automatiquement son propre thème de publication (theme_pubr()) à l’intérieur de ggline() et de ses semblables, de sorte que les graphiques sont prêts pour publication dès le départ — vous n’ajoutez pas de thème.

Le graphique canonique : moyennes groupées avec barres d’erreur

Voici l’image que la plupart des gens viennent chercher : la longueur moyenne des dents à chaque dose, séparée selon les deux suppléments (OJ contre VC), chaque point portant sa barre d’erreur standard. add = "mean_se" fait les statistiques ; color = "supp" sépare et colore les groupes ; les lignes relient les moyennes au sein de chaque groupe. Tout le reste de la leçon est une variation de cet unique appel.

library(ggpubr)

ggline(ToothGrowth, x = "dose", y = "len",
       add = "mean_se",                 # mean ± standard error
       color = "supp", palette = "jco") # split & colour by supplement

Nous y arriverons par étapes. D’abord, le cas le plus simple : un seul graphique d’erreur.

Le graphique d’erreur : moyenne ± erreur en un seul appel

ggerrorplot() est le plus direct : un point à la moyenne du groupe avec la barre d’erreur, rien d’autre. L’argument desc_stat nomme la statistique — ici "mean_sd" (moyenne ± écart-type).

library(ggpubr)

ggerrorplot(ToothGrowth, x = "dose", y = "len",
            desc_stat = "mean_sd")

Les valeurs autorisées de desc_stat associent un centre à une dispersion : "mean", "mean_se", "mean_sd", "mean_ci", "mean_range", "median", "median_iqr", "median_mad", "median_range". Changez le suffixe pour modifier ce que signifie la barre d’erreur — ce simple jeton est le choix entre erreur standard, écart-type et intervalle de confiance.

Changez le style de barre avec error.plot et superposez le point de moyenne avec add = "mean" :

library(ggpubr)

ggerrorplot(ToothGrowth, x = "dose", y = "len",
            desc_stat = "mean_sd",
            error.plot = "errorbar",   # plain error-bar style
            add = "mean")              # add the mean point

Montrer les données brutes derrière la moyenne

Un résumé masque la dispersion des observations individuelles. Empilez des géométries avec add = c(...) pour dessiner les points bruts par-dessus la barre d’erreur — jitter, un graphique en points, ou un violon. La statistique d’erreur reste dans desc_stat ; la géométrie supplémentaire va dans add.

library(ggpubr)

ggerrorplot(ToothGrowth, x = "dose", y = "len",
            desc_stat = "mean_sd", color = "black",
            add = "jitter", add.params = list(color = "darkgray"))

add accepte aussi "dotplot" ou "violin" à la place de "jitter" — même appel, une vue différente des observations brutes. Utilisez add.params pour colorer ou dimensionner la superposition.

Graphiques en courbes des moyennes

ggline() dessine les moyennes sous forme de ligne reliée — le choix naturel quand x est ordonné (dose, temps, concentration). add = "mean_se" place une barre d’erreur standard à chaque point ; enchaîner "jitter" superpose les observations brutes.

library(ggpubr)

ggline(ToothGrowth, x = "dose", y = "len",
       add = c("mean_se", "jitter"))   # mean ± SE line, with raw points

Colorez par une seconde variable de groupement pour comparer deux séries à la fois — color = "supp" dessine une ligne par supplément, chacune avec ses propres barres d’erreur.

library(ggpubr)

ggline(ToothGrowth, x = "dose", y = "len",
       add = "mean_se",
       color = "supp", palette = "jco")  # one line per supplement

Moyennes de groupes avec intervalles de confiance

C’est le graphique pour lequel l’ancienne recette de R de base recourait à gplots::plotmeans() : la moyenne du groupe à chaque dose, reliée par une ligne, avec un intervalle de confiance à 95 % à chaque point. En ggpubr, cela tient en un seul appel à ggline() — définissez add = "mean_ci" et vous obtenez la ligne de liaison, le point de moyenne et la barre d’IC ensemble, sur le canevas ggplot2.

library(ggpubr)

ggline(ToothGrowth, x = "dose", y = "len",
       add = "mean_ci",                          # mean + 95% confidence interval
       xlab = "Dose (mg/day)", ylab = "Tooth length")

plotmeans() affichait aussi la valeur moyenne et la taille du groupe (n) sur le graphique. Reproduisez les deux en extrayant les chiffres avec desc_statby() — qui renvoie la moyenne, l’IC et length (le n par groupe) — puis en les ajoutant sous forme de texte. desc_statby() fournit la dose discrète sous forme de facteur, ce qui correspond à l’axe x de ggline() :

library(ggpubr)

# group summary: mean, CI and n (length) per dose
stats <- desc_statby(ToothGrowth, measure.var = "len", grps = "dose")
stats$dose <- factor(stats$dose)                 # match ggline's discrete x-axis

ggline(ToothGrowth, x = "dose", y = "len", add = "mean_ci",
       xlab = "Dose (mg/day)", ylab = "Tooth length") +
  geom_text(data = stats, aes(x = dose, y = mean, label = round(mean, 1)),
            hjust = -0.45, size = 3.5, fontface = "bold", color = "#3a86d4") +   # mean value
  geom_text(data = stats, aes(x = dose, y = min(ToothGrowth$len) - 2,
                              label = paste0("n = ", length)),
            size = 3, color = "grey45")                                          # group size

L’ancien gplots::plotmeans(len ~ dose, data = ToothGrowth) dessine toujours ceci (ses valeurs par défaut p = 0.95 et n.label = TRUE placent un IC à 95 % et n sur le graphique), mais ggline(add = "mean_ci") vous donne le même graphique de moyennes reliées avec IC sur le canevas ggplot2 — thématisable, groupable par une seconde variable (color = "supp") et prêt pour stat_compare_means().

Diagrammes en barres des moyennes

ggbarplot() suit la même idée qu’un diagramme en barres : la hauteur est la moyenne du groupe, avec la barre d’erreur dessinée au sommet. Même argument add = "mean_se" ; même superposition optionnelle "jitter".

library(ggpubr)

ggbarplot(ToothGrowth, x = "dose", y = "len",
          add = c("mean_se", "jitter"))  # bars of means ± SE, with raw points

Pour un diagramme en barres groupé, colorez par la seconde variable et décalez les barres pour que les groupes se placent côte à côte au lieu de s’empiler — position = position_dodge() contrôle l’écart.

library(ggpubr)

ggbarplot(ToothGrowth, x = "dose", y = "len",
          add = "mean_se",
          color = "supp", palette = "jco",
          position = position_dodge(0.8))  # dodge the two supplements apart

Choisir le type d’erreur : SE, SD ou IC

La fonction de résumé et la borne d’erreur sont une seule décision, prise par le suffixe sur mean_*. L’erreur standard (mean_se) diminue avec la taille d’échantillon et décrit la précision de la moyenne ; l’écart-type (mean_sd) décrit la dispersion des données et ne diminue pas ; mean_ci dessine un intervalle de confiance à 95 %. Même graphique, trois barres d’erreur — choisissez celle qui correspond à l’affirmation que vous faites.

library(ggpubr)

# Standard error of the mean
ggerrorplot(ToothGrowth, x = "dose", y = "len", desc_stat = "mean_se")

# Standard deviation (spread of the data)
ggerrorplot(ToothGrowth, x = "dose", y = "len", desc_stat = "mean_sd")

# 95% confidence interval
ggerrorplot(ToothGrowth, x = "dose", y = "len", desc_stat = "mean_ci")

Besoin des chiffres derrière le graphique ? desc_statby() renvoie un data frame ordonné des moyennes de groupe, SD, SE et IC — les mêmes statistiques que ggpubr dessine.

library(ggpubr)

# group summary statistics: mean, sd, se, ci by dose
desc_statby(ToothGrowth, measure.var = "len", grps = "dose")[, c("dose", "length", "mean", "sd", "se", "ci")]

  dose length   mean       sd        se       ci
1  0.5     20 10.605 4.499763 1.0061776 2.105954
2  1.0     20 19.735 4.415436 0.9873216 2.066488
3  2.0     20 26.100 3.774150 0.8439257 1.766357

Ajouter des p-values aux moyennes

Comme ce sont des ggplots ordinaires, vous pouvez ajouter stat_compare_means() directement par-dessus pour annoter les comparaisons — des crochets par paires plus un test global, exactement comme sur une boîte à moustaches.

library(ggpubr)
df <- ToothGrowth
df$dose <- factor(df$dose)
my_comparisons <- list(c("0.5", "1"), c("1", "2"), c("0.5", "2"))

ggerrorplot(df, x = "dose", y = "len",
            desc_stat = "mean_sd", color = "black",
            add = "violin", add.params = list(color = "darkgray")) +
  stat_compare_means(comparisons = my_comparisons) +  # pairwise brackets
  stat_compare_means(label.y = 50)                     # global p-value

Les mécanismes de stat_compare_means() — le choix du test, les étoiles de significativité, les groupes de référence — font l’objet de la leçon Ajouter des p-values de cette série.

Essayez en direct

Les graphiques ci-dessus ont été rendus au moment du build. Envie d’expérimenter ? Modifiez le code et appuyez sur Run — il s’exécute dans votre navigateur via webR (sans serveur, sans installation). Essayez de remplacer add = "mean_se" par "mean_sd" ou "mean_ci", de passer de ggline() à ggbarplot(), ou de grouper par color = "supp".

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

🟢 Avec un agent IA

Demandez à Prova « mes barres d’erreur devraient-elles être l’erreur standard, l’écart-type, ou un intervalle de confiance à 95 % ? » — elle répond avec du code que vous pouvez exécuter sur votre propre data frame et calcule chaque statistique avec desc_statby(), de sorte que le choix est reproductible. The runtime is the judge. Demander à Prova →

Problèmes courants

• Les barres d’erreur paraissent minuscules. C’est mean_se (erreur standard) — elle diminue à mesure que l’échantillon grandit. Si vous voulez la dispersion des données, utilisez desc_stat = "mean_sd" (ou add = "mean_sd") ; elles répondent à des questions différentes.
• Les barres groupées se chevauchent au lieu de se placer côte à côte. Ajoutez position = position_dodge(0.8) (et faites correspondre la valeur sur toute superposition add) pour que les groupes se décalent.
• stat_compare_means(comparisons = ...) échoue sur un x numérique. Les entrées de paires sont des chaînes de caractères qui doivent correspondre aux niveaux du facteur — factor(dose) d’abord, puis c("0.5", "1").
• Je veux les points bruts derrière le résumé. Empilez des géométries : add = c("mean_se", "jitter") (ou "dotplot" / "violin") ; stylisez la superposition avec add.params = list(color = "darkgray").
• La moyenne est fausse / inattendue. ggpubr résume la colonne y telle quelle — supprimez les NA ou filtrez le data frame avant de tracer, et confirmez le groupement avec desc_statby().

Questions fréquentes

NoteComment tracer les moyennes de groupes avec des barres d’erreur en R ?

Utilisez l’argument add de ggpubr : ggline(ToothGrowth, x = "dose", y = "len", add = "mean_se") dessine les moyennes de groupes reliées par une ligne avec des barres représentant l’erreur standard, et ggbarplot(..., add = "mean_se") fait de même sous forme de barres. ggpubr calcule le résumé pour vous — vous fournissez les données brutes, pas un tableau pré-agrégé.

NoteDois-je afficher l’erreur standard, l’écart-type ou un intervalle de confiance ?

Ils répondent à des questions différentes. L’écart-type (mean_sd) montre la dispersion des données. L’erreur standard (mean_se) montre avec quelle précision la moyenne est estimée — elle diminue quand n augmente. Un IC à 95 % (mean_ci) est une plage plausible pour la vraie moyenne. Utilisez l’écart-type pour décrire la variabilité, l’erreur standard ou l’IC pour comparer les moyennes. Réglez-le via add = "mean_sd" (etc.) ou desc_stat =.

NotePourquoi mes barres d’erreur semblent-elles si petites ?

Vous tracez presque certainement mean_se (l’erreur standard), qui diminue avec la taille de l’échantillon — un grand n donne de petites barres. C’est correct, ce n’est pas un bug : l’erreur standard mesure la précision de la moyenne. Si vous vouliez la dispersion des valeurs brutes, passez à add = "mean_sd" ; les barres seront bien plus grandes et représenteront la variabilité.

NoteComment faire en sorte que des barres groupées soient côte à côte plutôt que superposées ?

Décalez-les : ajoutez position = position_dodge(0.8) au graphique, et transmettez la même valeur de décalage à tout calque superposé (add.params = list(...)) pour que les barres d’erreur s’alignent sur leurs barres. Associez la seconde variable à fill ou color (par exemple fill = "supp") pour que chaque sous-groupe soit une barre distincte et décalée.

NoteComment ajouter les points de données brutes derrière les moyennes ?

Empilez les géométries dans add : add = c("mean_se", "jitter") superpose des points dispersés derrière le résumé (utilisez "dotplot" ou "violin" pour d’autres styles). Stylisez le calque superposé séparément avec add.params = list(color = "darkgray") pour que les points restent discrets derrière les moyennes au lieu de leur faire concurrence.

NoteComment tracer les moyennes de groupes et les intervalles de confiance (comme gplots plotmeans) ?

Utilisez ggline(ToothGrowth, x = "dose", y = "len", add = "mean_ci") — elle relie les moyennes de groupes par une ligne et dessine un intervalle de confiance à 95 % à chaque point, le graphique que produisait le gplots::plotmeans() de R de base, mais sur le canevas ggplot2 : vous pouvez ainsi le thématiser, le colorer par un second groupe et ajouter des p-values. Pour étiqueter la valeur moyenne et la taille du groupe, extrayez-les avec desc_statby() (sa colonne length est le n par groupe) et ajoutez geom_text().

Testez vos connaissances

ImportantExercice : un diagramme en barres groupé de moyennes ± SE

Complétez le code pour que chaque dose affiche une barre de longueur moyenne des dents avec une barre d’erreur standard, séparée par supplément (supp) avec les deux groupes décalés côte à côte.

# add = "mean_se" computes the mean and standard-error bar.
# position = position_dodge(0.8) separates the two supplements.

library(ggpubr) ggbarplot(ToothGrowth, x = "dose", y = "len", add = "mean_se", color = "supp", palette = "jco", position = position_dodge(0.8))

library(ggpubr)

ggbarplot(ToothGrowth, x = "dose", y = "len",
          add = "mean_se",
          color = "supp", palette = "jco",
          position = position_dodge(0.8))

Conclusion

Vous avez tracé les moyennes de groupes avec barres d’erreur à la manière de ggpubr : ggline() pour une ligne de moyennes, ggbarplot() pour des barres, et ggerrorplot() pour le simple point ± erreur — chacun piloté par un seul argument, add = "mean_se" (ou mean_sd / mean_ci / median_iqr). Vous avez coloré par un second groupe et décalé les séries avec position_dodge(), superposé les observations brutes avec add = c("mean_se", "jitter"), choisi le type d’erreur par son suffixe, extrait les chiffres sous-jacents avec desc_statby(), et ajouté la significativité avec stat_compare_means(). Ce seul argument add transforme toute mesure groupée en un résumé prêt à publier.

Pour les mécanismes ggplot2 sous-jacents — construire des barres d’erreur à partir de stat_summary() à la main, ou styliser une ligne de moyennes vous-même — voir les leçons barres d’erreur et graphique en courbes. Pour annoter ces moyennes avec des tests, continuez avec Ajouter des p-values.

Leçons connexes

• Ajouter des p-values — annotez ces moyennes avec stat_compare_means(). · Barres d’erreur en ggplot2 — la même statistique construite à la main avec stat_summary(). · Graphique en courbes en R — styliser une ligne de moyennes en ggplot2 de base. · Diagramme en barres en R — le diagramme en barres sur lequel ggbarplot() est construit.
• 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.