La fonction plot() en R : types, couleurs, pch et légendes

plot() est la fonction graphique à tout faire de R

Pour tracer en R, appelle plot(x, y) avec deux vecteurs numériques de même longueur. R dessine un point pour chaque paire - le premier vecteur en abscisse, le second en ordonnée - et étiquette les axes avec les noms des variables automatiquement :

x <- 1:12
y <- c(2, 5, 4, 8, 9, 12, 11, 15, 14, 18, 17, 21)

plot(x, y)

Le résultat est un nuage de douze cercles creux qui montent régulièrement à mesure que x grandit. C'est tout le droit d'entrée : aucun package à installer, aucune configuration. plot() est livré avec R de base et c'est la fonction derrière la plupart des graphiques rapides et exploratoires.

Comme l'exécuteur de code de cette page n'affiche que du texte, les appels graphiques de cet article sont des extraits statiques - colle-les dans RStudio ou dans une session R locale pour voir les images. Ce que tu peux exécuter ici, c'est la préparation des données. C'est une bonne habitude de toute façon : regarde les nombres avant de les tracer.

x <- 1:12
y <- c(2, 5, 4, 8, 9, 12, 11, 15, 14, 18, 17, 21)

print(data.frame(x, y))
print(summary(y))

Si tu ne passes qu'un vecteur, plot(y) utilise les positions d'indice 1, 2, 3, ... comme axe horizontal - pratique pour jeter un œil rapide à une suite de mesures.

Choisir le type de graphique

L'argument type décide comment les paires sont dessinées :

plot(x, y, type = "p")   # points (the default)
plot(x, y, type = "l")   # a connected line
plot(x, y, type = "b")   # both: points joined by line segments
plot(x, y, type = "h")   # vertical bars from zero, like a spike chart
plot(x, y, type = "s")   # a step function

type = "l" transforme le nuage en courbe, ce que tu veux pour tout ce qui est mesuré dans le temps. type = "b" garde les observations individuelles visibles tout en montrant la tendance. type = "h" dessine un fin segment vertical de zéro jusqu'à chaque valeur, et type = "s" dessine un escalier qui maintient chaque valeur jusqu'à la suivante - utile pour des quantités qui changent par sauts, comme un prix ou un état de stock.

Titres, étiquettes et couleurs

Un graphique sans étiquettes est une note privée que tu t'adresses. Trois arguments corrigent ça : main pour le titre, xlab et ylab pour les étiquettes d'axes. col définit la couleur :

plot(x, y,
     type = "b",
     main = "Monthly signups",
     xlab = "Month",
     ylab = "Signups (thousands)",
     col  = "steelblue")

col accepte trois sortes de valeurs :

• Des couleurs nommées - "red", "steelblue", "tomato", "darkgreen". R en connaît 657 ; lance colors() pour lister tous les noms.
• Des codes hexadécimaux - col = "#2C7FB8", exactement comme en CSS.
• Un vecteur de couleurs - une par point, c'est ainsi qu'on colore les points par groupe : col = c("tomato", "steelblue")[group] où group est un facteur.

Symboles de points avec pch, tailles avec cex et lwd

Le cercle creux par défaut convient à l'exploration mais devient brouillon dans tout ce que tu montres aux autres. pch (plotting character) choisit le symbole, numéroté de 0 à 25 :

plot(x, y, pch = 19)                     # solid circle - the usual choice
plot(x, y, pch = 17)                     # solid triangle
plot(x, y, pch = 21, col = "black",
     bg = "gold")                        # fillable circle: border + fill

Deux numéros valent la peine d'être mémorisés. pch = 19 est le cercle plein qu'utilisent la plupart des graphiques finalisés. pch = 21 à 25 sont les symboles remplissables : col colore la bordure et bg colore l'intérieur, ce qui te donne des points bicolores.

La taille et le style de ligne ont leurs propres boutons :

• cex met les points à l'échelle : cex = 1.5 les agrandit de moitié.
• lwd définit l'épaisseur de ligne pour type = "l" ou "b" : lwd = 2 donne une ligne pleine et lisible.
• lty définit le motif de ligne : lty = 1 pleine, 2 tiretée, 3 pointillée.

Superposer : points(), lines() et abline()

plot() démarre un nouveau graphique. Pour dessiner par-dessus un graphique existant, utilise ses compagnons - ils ajoutent au graphique courant au lieu de le remplacer :

plot(x, y, type = "l", lwd = 2, col = "steelblue",
     main = "Actual vs. target")

points(x, y, pch = 19, col = "steelblue")   # add the observations
lines(x, x * 1.5, lty = 2, col = "gray40")  # add a second series, dashed
abline(h = 10, col = "tomato")              # horizontal reference line at y = 10

abline() est l'outil des lignes de référence et il a trois modes :

• abline(h = 10) - une ligne horizontale à une valeur donnée de l'axe vertical.
• abline(v = 6) - une ligne verticale à une valeur donnée de l'axe horizontal.
• abline(a = 0, b = 1.5) - une droite par son ordonnée à l'origine a et sa pente b.

Son meilleur tour : passe-lui un modèle ajusté et il trace la droite de régression pour toi - abline(lm(y ~ x)). Cette seule ligne transforme un nuage en argument ; le guide du nuage de points s'appuie dessus.

Une règle à respecter : les limites des axes sont fixées par le premier appel à plot(). Si une série superposée dépasse, elle est rognée - définis xlim = et ylim = dans le plot() d'origine assez largement pour tout ce que tu comptes ajouter.

Ajouter une légende

Dès qu'un graphique a plus d'une série, il lui faut une légende. legend() prend un mot-clé de position en premier argument - "topright", "topleft", "bottomright", "bottomleft", "top", "bottom" ou "center" (ce sont des chaînes R littérales, elles restent donc en anglais dans ton code) - puis les étiquettes et les styles correspondants :

legend("topright",
       legend = c("Actual", "Target"),
       col    = c("steelblue", "gray40"),
       lty    = c(1, 2),
       pch    = c(19, NA),
       lwd    = 2)

Les vecteurs col, lty et pch doivent s'aligner avec legend entrée par entrée - la première étiquette reçoit la première couleur, et ainsi de suite. Utilise NA pour un style qui ne s'applique pas à une série (ici, la ligne de cible n'a pas de points). Le mot-clé épingle le cadre à un coin de la zone de tracé ; choisis le coin que tes données laissent vide.

Plusieurs panneaux et sauvegarde en fichier

Pour montrer plusieurs graphiques dans une même figure, règle la grille de tracé avant de dessiner : par(mfrow = c(1, 2)) découpe le périphérique en une ligne et deux colonnes, et les deux plot() suivants remplissent les panneaux dans l'ordre. Réinitialise avec par(mfrow = c(1, 1)) quand tu as fini, sinon les graphiques suivants restent minuscules.

Enregistrer dans un fichier consiste à rediriger le dessin vers un périphérique fichier plutôt que vers l'écran :

png("signups.png", width = 800, height = 600)

plot(x, y, type = "b", pch = 19, col = "steelblue",
     main = "Monthly signups", xlab = "Month", ylab = "Signups")

dev.off()

Tout ce qui se trouve entre png() et dev.off() atterrit dans le fichier ; rien n'apparaît à l'écran. Oublier dev.off() est le bug classique - le fichier reste verrouillé et vide tant que tu ne fermes pas le périphérique. pdf(), jpeg() et svg() fonctionnent pareil.

Ce que tu retiens

• plot(x, y) dessine immédiatement ; type = bascule entre points ("p"), lignes ("l") et les deux ("b").
• main, xlab, ylab étiquettent le graphique ; col accepte des noms de couleurs (657 dans colors()) ou des codes hexadécimaux.
• pch = 19 est le cercle plein ; pch = 21–25 séparent la bordure (col) du remplissage (bg) ; cex, lwd, lty contrôlent la taille et le style de ligne.
• points(), lines() et abline() se superposent au graphique existant - abline(lm(y ~ x)) ajoute une droite de régression en un appel.
• legend("topright", ...) étiquette les séries ; png(...) + dev.off() enregistre dans un fichier.

Prochaine étape : l'histogramme - le graphique à une variable vers lequel tu te tourneras en premier face à un nouveau jeu de données.