Zoomer, fixer min/max, transformer en log et inverser un axe — en direct dans votre navigateur
Maîtrisez les axes ggplot2 en R — zoomez avec coord_cartesian(), fixez les limites avec xlim()/ylim() et scale_*_continuous(), forcez l’origine avec expand_limits(), appliquez des échelles log10, sqrt ou inversées, et ajoutez des graduations logarithmiques avec annotation_logticks(). Modifiez et exécutez le code en direct, sans installation.
coord_cartesian(xlim = ..., ylim = ...) recadre la vue — les points en dehors continuent de façonner l’ajustement. C’est la méthode à privilégier pour fixer des limites.xlim(), ylim() et scale_*_continuous(limits = ...) écartent les points hors plage (ils deviennent NA), ce qui modifie tout lissage ou résumé.expand_limits(x = 0, y = 0) étend la plage pour qu’un axe démarre à zéro.scale_y_log10() (ou transform = "log10") est la transformation la plus demandée ; scale_*_sqrt() en est la cousine plus douce.annotation_logticks(sides = "bl") ajoute les graduations mineures de décades (supplantée par guide_axis_logticks()).scale_y_reverse() retourne un axe du haut vers le bas sans retourner tout le graphique.coord_trans() déforme le système de coordonnées après le calcul du geom — aucun point écarté.scales (label_log(), label_dollar(), label_percent()).Une fois un graphique ggplot2 tracé, la question suivante porte presque toujours sur les axes : comment zoomer, fixer un minimum et un maximum, faire démarrer l’axe y à zéro, ou passer à une échelle logarithmique ? En R, ggplot2 vous offre deux leviers distincts — les limites (la plage visible) et les échelles/coordonnées (la façon dont les valeurs sont projetées sur la position) — et la différence entre les deux est la source de confusion la plus fréquente. Cette leçon les explore tous les deux, avec des figures rendues ici même que vous pouvez réexécuter ou modifier en direct.
La distinction clé à retenir : certaines fonctions coupent (écartent les données hors plage, ce qui peut modifier une courbe de tendance ou un résumé) tandis que d’autres se contentent de zoomer (recadrer la vue, en gardant chaque point dans le calcul). Nous signalons laquelle est laquelle à chaque étape.
Nous utilisons le jeu de données intégré mtcars — consommation et conception de 32 voitures issues d’un magazine de 1974 : wt (poids en milliers de livres), mpg (miles par gallon), hp (puissance brute) et disp (cylindrée). Ses larges plages numériques en font un cas idéal pour illustrer les limites et transformations d’axe.
coord_cartesian(xlim = ..., ylim = ...) est la fonction à privilégier en premier. Elle fixe la fenêtre visible sans supprimer aucune donnée : chaque point contribue toujours aux lissages, régressions et résumés — vous ne faites que recadrer ce qui est dessiné. Ici, nous zoomons sur les voitures de gamme intermédiaire tandis que la courbe de tendance reste ajustée sur les 32.
library(ggplot2)
ggplot(mtcars, aes(x = wt, y = mpg)) +
geom_point(color = "#3a86d4", size = 2) +
geom_smooth(method = "lm", se = FALSE, color = "grey30") +
coord_cartesian(xlim = c(2.5, 5), ylim = c(10, 25)) +
labs(x = "Weight (1000 lbs)", y = "Miles per gallon") +
theme_minimal()
xlim() et ylim() sont le raccourci pour fixer une plage, mais ils coupent : tout point hors plage est mis à NA et écarté (ggplot2 avertit des lignes supprimées). C’est acceptable pour un simple nuage de points, mais cela signifie aussi qu’une courbe ajustée n’est calculée que sur les points survivants — alors réservez-les aux cas où vous voulez réellement exclure des données, et pas seulement zoomer.
library(ggplot2)
ggplot(mtcars, aes(x = wt, y = mpg)) +
geom_point(color = "#3a86d4", size = 2) +
xlim(2, 5) +
ylim(10, 30) +
labs(x = "Weight (1000 lbs)", y = "Miles per gallon") +
theme_minimal()
scale_x_continuous(limits = ...) et scale_y_continuous(limits = ...) fixent les mêmes limites de coupure que xlim()/ylim(), mais dans la couche d’échelle — vous pouvez ainsi épingler la plage et renommer l’axe ou définir des graduations personnalisées au même endroit. Comme xlim(), cela coupe les données hors plage.
library(ggplot2)
ggplot(mtcars, aes(x = wt, y = mpg)) +
geom_point(color = "#3a86d4", size = 2) +
scale_y_continuous(name = "Miles per gallon", limits = c(10, 35),
breaks = seq(10, 35, by = 5)) +
labs(x = "Weight (1000 lbs)") +
theme_minimal()
Les deux approches ci-dessus se ressemblent mais se comportent différemment — et cela compte dès qu’une couche est calculée à partir des données (un lissage, une boîte à moustaches, une densité). ylim()/scale_y_continuous() écartent les points hors plage avant le calcul du geom ; coord_cartesian() les conserve et ne fait que recadrer la vue. La même droite de régression, ajustée selon chaque règle, peut différer de façon visible :
library(ggplot2)
ggplot(mtcars, aes(x = hp, y = mpg)) +
geom_point(color = "#3a86d4", size = 2) +
geom_smooth(method = "lm", se = FALSE, color = "grey30") +
# coord_cartesian zooms: the line is still fitted on every car
coord_cartesian(ylim = c(10, 25)) +
labs(x = "Horsepower", y = "Miles per gallon",
title = "coord_cartesian keeps all points in the fit") +
theme_minimal()
Remplacez la ligne coord_cartesian(ylim = ...) par ylim(10, 25) dans le bac à sable ci-dessous et observez la pente changer — c’est la coupure en action.
Par défaut, ggplot2 ajuste les axes au plus près de vos données. Pour qu’un axe inclue zéro (une demande fréquente pour des diagrammes en barres et en aires honnêtes) ou toute autre valeur de référence, ajoutez expand_limits(). Il étend la plage pour couvrir la valeur sans rien couper.
library(ggplot2)
ggplot(mtcars, aes(x = wt, y = mpg)) +
geom_point(color = "#3a86d4", size = 2) +
expand_limits(x = 0, y = 0) +
labs(x = "Weight (1000 lbs)", y = "Miles per gallon") +
theme_minimal()
Une échelle logarithmique étale les petites valeurs et compresse les grandes — indispensable lorsqu’une variable couvre plusieurs ordres de grandeur. La méthode propre en ggplot2 est scale_y_log10() (ou, de façon équivalente, scale_y_continuous(transform = "log10")). Ici, la cylindrée des voitures est transformée en log sur l’axe x.
library(ggplot2)
ggplot(mtcars, aes(x = disp, y = mpg)) +
geom_point(color = "#3a86d4", size = 2) +
scale_x_log10() +
labs(x = "Displacement (log10, cubic inches)", y = "Miles per gallon") +
theme_minimal()
L’argument transform = de toute échelle continue accepte les mêmes transformations par nom ("log10", "log2", "sqrt", "reverse", …), si bien que scale_x_continuous(transform = "log10") fait exactement ce que fait scale_x_log10() — pratique lorsque vous voulez aussi des graduations personnalisées ou un nom sur la même échelle.
Entre les décades étiquetées d’un axe logarithmique, les graduations logarithmiques mineures — resserrées près de chaque puissance de dix, puis s’espaçant vers la suivante — aident l’œil à lire les valeurs intermédiaires (20, 30, 50…) sur une échelle dont le quadrillage ne marque que 10, 100, 1000. Ajoutez-les avec annotation_logticks(). Elle doit s’associer à une échelle log10, car les graduations sont placées dans l’espace logarithmique — sur un axe linéaire ordinaire, elles tomberaient au mauvais endroit.
library(ggplot2)
ggplot(mtcars, aes(x = disp, y = mpg)) +
geom_point(color = "#3a86d4", size = 2) +
scale_x_log10() +
annotation_logticks(sides = "b") +
labs(x = "Displacement (log10, cubic inches)", y = "Miles per gallon") +
theme_minimal()
L’argument sides = choisit quels axes reçoivent des graduations : une chaîne composée de "t" (haut), "r" (droite), "b" (bas) et "l" (gauche) — ainsi "b" désigne le bas seul, "bl" le bas et la gauche, et "trbl" les quatre côtés. Ne placez des graduations que sur un côté dont l’axe est réellement à échelle logarithmique : sides = "bl" requiert à la fois scale_x_log10() et scale_y_log10(), sinon les graduations de l’axe non transformé se retrouvent à des positions dénuées de sens.
Dans les versions actuelles de ggplot2, annotation_logticks() est supplantée par guide_axis_logticks() — un guide d’axe qui dessine les mêmes graduations logarithmiques via l’échelle elle-même plutôt que comme une couche d’annotation distincte. Vous le passez à l’argument guide = de l’échelle. C’est l’approche recommandée pour le code neuf ; annotation_logticks() fonctionne toujours et reste la forme que montrent la plupart des résultats de recherche (et des scripts existants).
library(ggplot2)
ggplot(mtcars, aes(x = disp, y = mpg)) +
geom_point(color = "#3a86d4", size = 2) +
scale_x_log10(guide = guide_axis_logticks()) +
labs(x = "Displacement (log10, cubic inches)", y = "Miles per gallon") +
theme_minimal()
scale_x_sqrt() / scale_y_sqrt() appliquent une compression plus douce, par racine carrée — utile pour des comptages asymétriques à droite où un log complet paraît trop agressif.
library(ggplot2)
ggplot(mtcars, aes(x = hp, y = mpg)) +
geom_point(color = "#3a86d4", size = 2) +
scale_x_sqrt() +
labs(x = "Horsepower (sqrt)", y = "Miles per gallon") +
theme_minimal()
Pour faire courir un axe du haut vers le bas — décompter un rang, ou placer la plus grande valeur à l’origine — utilisez scale_x_reverse() / scale_y_reverse(). Cela inverse la direction d’une seule échelle ; cela n’échange pas les rôles de x et y (c’est coord_flip(), un idiome distinct — voir les leçons connexes).
library(ggplot2)
ggplot(mtcars, aes(x = wt, y = mpg)) +
geom_point(color = "#3a86d4", size = 2) +
scale_x_reverse() +
labs(x = "Weight (1000 lbs, reversed)", y = "Miles per gallon") +
theme_minimal()
coord_trans(x = ..., y = ...) transforme le système de coordonnées après le calcul des geoms, plutôt que de transformer les données d’abord. La différence pratique avec un scale_*_log10() : les points et toute courbe ajustée sont calculés sur l’échelle linéaire d’origine, puis l’espace est déformé — les droites se courbent donc, et aucune donnée n’est écartée. Utile lorsque vous voulez un affichage transformé mais un modèle ajusté sur les valeurs brutes.
library(ggplot2)
ggplot(mtcars, aes(x = disp, y = mpg)) +
geom_point(color = "#3a86d4", size = 2) +
coord_trans(x = "log10") +
labs(x = "Displacement (log10 space)", y = "Miles per gallon") +
theme_minimal()
Lorsque vous passez un axe en log ou le transformez autrement, les nombres bruts des graduations peuvent devenir peu lisibles. Le package scales fournit des formateurs prêts à l’emploi que vous passez à l’argument labels = d’une échelle — label_log() pour des exposants logarithmiques propres, label_dollar(), label_percent(), et label_comma() pour les séparateurs de milliers. Ici, nous passons l’axe x en log et l’étiquetons avec des exposants nets.
library(ggplot2)
ggplot(mtcars, aes(x = disp, y = mpg)) +
geom_point(color = "#3a86d4", size = 2) +
scale_x_log10(labels = scales::label_log()) +
labs(x = "Displacement (cubic inches, log10)", y = "Miles per gallon") +
theme_minimal()
Pour un axe logarithmique en base 2 — courant pour les log2 fold-changes en génomique — passez transform = "log2" et mettez en forme les graduations avec scales::label_log(base = 2) ; tout le reste est identique à l’exemple log10 ci-dessus.
Les graphiques ci-dessus ont été rendus au moment de la compilation. 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 coord_cartesian(ylim = c(10, 25)) par ylim(10, 25) pour voir comment la coupure et le zoom modifient différemment la courbe.
Vous travaillez en Python ? Un guide matplotlib sur les limites d’axe et l’échelle logarithmique (set_xlim, set_yscale) arrive dans la série Python.
Demandez à Prova « devrais-je utiliser coord_cartesian() ou ylim() pour zoomer cette régression — laquelle préserve l’honnêteté de la pente ? » — elle répond avec du code que vous pouvez exécuter, donc l’explication est reproductible. The runtime is the judge. Demander à Prova →
coord_cartesian(xlim = ..., ylim = ...) se contente de zoomer — elle recadre la vue tandis que chaque point continue de contribuer aux lissages et résumés. xlim()/ylim() (et scale_*_continuous(limits = ...)) coupent — ils mettent les points hors plage à NA et les écartent avant le calcul d’une couche, ce qui peut modifier une courbe ajustée. Utilisez coord_cartesian() pour zoomer, et xlim()/ylim() uniquement lorsque vous voulez réellement exclure des données.
Parce que ylim() et scale_y_continuous(limits = ...) coupent les données : les points hors plage sont écartés avant l’ajustement de geom_smooth(), si bien que la droite est calculée sur moins de points et que sa pente se décale. Pour garder tous les points dans l’ajustement et ne recadrer que la vue, utilisez plutôt coord_cartesian(ylim = ...).
Ajoutez scale_x_log10() ou scale_y_log10() pour un axe logarithmique en base 10. De façon équivalente, passez transform = "log10" à scale_x_continuous()/scale_y_continuous() — pratique lorsque vous voulez aussi des graduations personnalisées ou un nom sur la même échelle ("log2" et "sqrt" fonctionnent de la même manière).
Ajoutez annotation_logticks() à un graphique qui utilise déjà une échelle log10, et choisissez les axes avec sides = — par exemple scale_x_log10() + annotation_logticks(sides = "b") pour des graduations en bas, "bl" pour le bas et la gauche, "trbl" pour les quatre côtés. Les graduations sont placées dans l’espace logarithmique, elles n’ont donc de sens que sur un axe à échelle logarithmique. Dans les versions actuelles de ggplot2, l’équivalent moderne est scale_x_log10(guide = guide_axis_logticks()), qui a supplanté annotation_logticks().
Ajoutez expand_limits(x = 0, y = 0) (ou seulement l’axe dont vous avez besoin, par exemple expand_limits(y = 0)). Il étend la plage pour inclure zéro sans couper aucune donnée — utile pour des diagrammes en barres et en aires honnêtes.
Utilisez scale_x_reverse() ou scale_y_reverse() pour faire courir cet axe du haut vers le bas. Cela inverse uniquement la direction de l’échelle ; cela n’échange pas les rôles de x et y — c’est coord_flip(), un idiome distinct.
Complétez le code pour que la cylindrée du moteur (disp) soit tracée sur un axe x logarithmique en base 10.
# Use scale_x_log10() — or equivalently scale_x_continuous(transform = "log10")library(ggplot2)
ggplot(mtcars, aes(x = disp, y = mpg)) +
geom_point(color = "#3a86d4", size = 2) +
scale_x_log10() +
labs(x = "Displacement (log10)", y = "Miles per gallon") +
theme_minimal()
library(ggplot2)
ggplot(mtcars, aes(x = disp, y = mpg)) +
geom_point(color = "#3a86d4", size = 2) +
scale_x_log10() +
labs(x = "Displacement (log10)", y = "Miles per gallon") +
theme_minimal()Vous avez appris à maîtriser les axes ggplot2 de deux façons — les limites et les échelles — et, surtout, quand chacune coupe les données plutôt que de simplement zoomer la vue. Vous avez zoomé avec coord_cartesian(), fixé des plages avec xlim()/ylim() et scale_*_continuous(limits = ), forcé l’origine avec expand_limits(), appliqué des échelles log10, sqrt et inversées, ajouté des graduations logarithmiques mineures avec annotation_logticks(), déformé l’espace avec coord_trans(), et soigné les étiquettes de graduations avec le package scales. Ensuite, fixez les graduations et faites pivoter le texte des graduations dans la leçon sur les graduations d’axe, ou explorez le nuage de points sur lequel ces exemples se construisent.
Vous préférez un livre ? GGPlot2 Essentials est disponible en PDF téléchargeable — toutes les leçons de cette série, hors ligne et à vous.
Prouvez que vous savez le faire. Maîtrisez toute la série ggplot2 — suivez votre parcours, construisez des projets et obtenez un certificat.
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
✓ Vous êtes Pro — continuez. The runtime is the judge.
Prêt à passer à la vitesse supérieure ?
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.
@online{2026,
author = {},
title = {Limites et échelles d’axe ggplot2 en R},
date = {2026-06-20},
url = {https://www.datanovia.com/learn/data-visualization/ggplot2/axis-limits-scales},
langid = {fr}
}