Graphique en ligne en R : plot() et lines() en R de base

Tracez une ou plusieurs courbes, définissez le type, le style et la couleur, et ajoutez une légende

Créez un graphique en ligne en R de base avec plot() et lines(). Choisissez le type de tracé (l, b, o, s), tracez une seule courbe ou plusieurs, contrôlez le type, l’épaisseur et la couleur de la ligne avec lty/lwd/col, posez des points sur la ligne avec pch, et étiquetez plusieurs séries avec une légende.

AstucePoints clés

• Tracez un graphique en ligne en R de base avec plot(x, y, type = "l") — aucun package requis.
• type choisit la forme : "l" lignes, "b" à la fois points et lignes, "o" superposé, "s" marches d’escalier, "p" points seuls.
• Stylisez la ligne avec lty (type), lwd (épaisseur) et col (couleur) ; posez-y des marqueurs avec pch.
• plot() ouvre la figure ; lines() y ajoute d’autres séries — lines() ne peut pas tracer seule.
• Plusieurs séries nécessitent une legend() dont col/lty/pch correspondent aux lignes, dans le même ordre.

Introduction

Vous avez un x et un y — un temps et une mesure, une dose et une réponse — et vous voulez relier les points pour montrer une tendance. En R de base, c’est un seul appel : plot(x, y, type = "l"). Pour poser une deuxième série sur les mêmes axes, vous ajoutez lines().

Les deux fonctions se partagent le travail. plot() ouvre la figure et dessine les axes ; lines() ajoute seulement à une figure qui existe déjà — appelez-la seule et vous obtenez une erreur. Cette leçon couvre les formes de type, le style de la ligne (lty/lwd/col), les points sur la ligne (pch), plusieurs séries avec lines(), et une légende pour les distinguer.

Vous préférez la grammaire des graphiques ? ggplot2 construit des graphiques en ligne avec geom_line() — voir graphique en ligne dans la série ggplot2.

Les fonctions plot() et lines()

Un graphique en ligne nécessite deux vecteurs de coordonnées et un type :

plot(x, y, type = "l", lty = 1, lwd = 1, col = "black")
lines(x, y, type = "l", lty = 1)

Argument	Ce qu’il fait
x, y	Les coordonnées des points à relier, dans l’ordre du tracé.
type	Forme : "p" points, "l" lignes, "b" les deux, "o" superposé, "h" pics de type histogramme, "s"/"S" marches d’escalier, "n" rien.
lty	Type de ligne : 1 solide, 2 tirets, 3 pointillés, 4 point-tiret, 5 tirets longs, 6 double tiret (ou les noms).
lwd	Épaisseur de la ligne, un multiplicateur positif (2 est le double du défaut).
col	Couleur de la ligne.
pch	Symbole de point, utilisé quand type dessine des points ("b", "o", "p").

lines() prend les mêmes arguments de style. La seule règle : plot() d’abord, lines() ensuite.

Une seule ligne

Le graphique en ligne le plus simple passe type = "l". Voici une mesure qui croît sur dix étapes, tracée comme une seule ligne azur.

x <- 1:10
y <- x^2

plot(x, y, type = "l", col = "#3a86d4", lwd = 2,
     xlab = "x", ylab = "y")

type = "l" relie les points dans l’ordre où ils apparaissent dans x. lwd = 2 épaissit la ligne et col en définit la couleur. Les données doivent être triées par x d’abord, sinon la ligne fait des zigzags sur elle-même.

Le type de tracé : p, l, b, o, h, s

Les mêmes x/y se présentent très différemment selon chaque type. Les plus courants : "p" dessine des points seuls (un nuage de points), "l" une ligne, "b" les deux avec un espace là où se trouvent les marqueurs, "o" superpose pour que la ligne passe à travers les marqueurs, "h" laisse tomber un pic vertical jusqu’à chaque point, et "s" fait des marches entre eux.

x <- 1:10
y <- x^1.5

op <- par(mfrow = c(2, 3), mar = c(3, 3, 2, 1))
for (t in c("p", "l", "b", "o", "h", "s")) {
  plot(x, y, type = t, col = "#3a86d4", lwd = 2, pch = 19,
       main = paste0('type = "', t, '"'), xlab = "x", ylab = "y")
}

par(op)

Optez pour "l" pour une tendance épurée, "b" ou "o" quand chaque observation compte et que vous voulez un marqueur, "s" pour des changements par paliers (effectifs, niveaux qui se maintiennent puis sautent), et "h" pour un graphique en pics.

Type, épaisseur et couleur de la ligne

lty, lwd et col stylisent la ligne elle-même. lty prend un entier ou un nom — 1 solide, 2 tirets, 3 pointillés, jusqu’à 6. Le graphique ci-dessous dessine les six types de ligne pour que vous puissiez en choisir un.

plot(NA, xlim = c(0, 10), ylim = c(0.5, 6.5),
     xlab = "x", ylab = "lty", yaxt = "n")
axis(2, at = 1:6, las = 1)
for (i in 1:6) {
  lines(c(0, 10), c(i, i), lty = i, lwd = 2, col = "#3a86d4")
}

Combinez-les dans un seul appel. Ici une ligne orange épaisse en tirets montre le style réuni :

x <- 1:10
y <- x^1.5

plot(x, y, type = "l", lty = 2, lwd = 3, col = "#e07b39",
     xlab = "x", ylab = "y")

Des points sur la ligne

Pour marquer chaque observation, utilisez un type qui dessine des points ("b" ou "o") et définissez pch, le symbole de point. "b" laisse un petit espace autour de chaque marqueur ; "o" fait passer la ligne droit à travers.

x <- 1:10
y <- x^1.5

op <- par(mfrow = c(1, 2), mar = c(4, 4, 2, 1))
plot(x, y, type = "b", pch = 19, col = "#3a86d4", lwd = 2,
     main = 'type = "b"', xlab = "x", ylab = "y")
plot(x, y, type = "o", pch = 19, col = "#3a86d4", lwd = 2,
     main = 'type = "o"', xlab = "x", ylab = "y")

par(op)

pch = 19 est un cercle plein ; 17 un triangle plein, 15 un carré plein. Le marqueur est le repère quand plusieurs séries se croisent — donnez à chacune son propre pch.

Plusieurs lignes

Pour tracer plusieurs séries, dessinez la première avec plot(), puis ajoutez chaque série supplémentaire avec lines(). Comme plot() fixe les axes à ses propres données, réglez ylim assez large pour contenir chaque série, sinon les lignes ultérieures débordent par le haut.

x  <- 1:10
y1 <- x^1.5
y2 <- 2 * y1

# First line sets the axes — give ylim room for both series
plot(x, y1, type = "b", pch = 19, lty = 1, col = "#3a86d4", lwd = 2,
     ylim = range(y1, y2), xlab = "x", ylab = "y")

# Add the second series onto the same figure
lines(x, y2, type = "b", pch = 17, lty = 2, col = "#e07b39", lwd = 2)

legend("topleft",
       legend = c("Line 1", "Line 2"),
       col = c("#3a86d4", "#e07b39"),
       pch = c(19, 17), lty = c(1, 2))

C’est la recette multi-séries du quotidien : plot() pour la première ligne, un lines() par série supplémentaire, puis une legend() dont col/pch/lty répètent ce que vous avez dessiné, dans le même ordre, pour que la clé corresponde. Les couleurs forment une paire azur/orange adaptée au daltonisme.

Beaucoup de séries à la fois ? matplot() trace chaque colonne d’une matrice en un seul appel — pratique quand les séries se trouvent côte à côte :

x   <- 1:10
mat <- cbind(A = x, B = x^1.3, C = x^1.6)
cols <- c("#3a86d4", "#e07b39", "#5fad56")  # colourblind-safe set

matplot(x, mat, type = "l", lty = 1, lwd = 2, col = cols,
        xlab = "x", ylab = "y")
legend("topleft", legend = colnames(mat), col = cols, lty = 1, lwd = 2)

matplot(x, mat, type = "l") dessine une ligne par colonne de mat, en faisant cycler col/lty à travers elles — pas de boucle lines() manuelle.

Relier les points dans l’ordre

Un graphique en ligne n’a de sens que si les points sont reliés dans un ordre sensé. plot() les relie dans l’ordre où ils apparaissent dans x, donc triez par x d’abord. Des données non triées produisent une ligne emmêlée.

set.seed(1)
x <- sample(1:10)        # shuffled
y <- x^1.5

op <- par(mfrow = c(1, 2), mar = c(4, 4, 2, 1))
plot(x, y, type = "o", pch = 19, col = "#e07b39", lwd = 2,
     main = "Unsorted x", xlab = "x", ylab = "y")

ord <- order(x)          # sort by x before joining
plot(x[ord], y[ord], type = "o", pch = 19, col = "#3a86d4", lwd = 2,
     main = "Sorted x", xlab = "x", ylab = "y")

par(op)

order(x) renvoie les indices qui trient x ; indexez les deux vecteurs avec lui pour que chaque y reste apparié à son x. Le panneau de droite est la ligne que vous vouliez dessiner.

Essayez en direct

Changez le type, le lty, le col ou ajoutez un autre appel à lines() et appuyez sur Run — cela s’exécute dans votre navigateur via webR, sans installation.

🟢 Avec un agent IA

Demandez à Prova « pourquoi mon graphique en ligne en R de base est-il un fouillis emmêlé ? » — elle répond avec du code que vous pouvez exécuter, donc la correction est reproductible. The runtime is the judge. Demander à Prova →

Problèmes courants

lines() donne « plot.new has not been called yet ». lines() ajoute seulement à une figure qui existe déjà — elle ne peut pas en démarrer une. Appelez plot() d’abord pour dessiner la première série et les axes, puis lines() pour chaque série supplémentaire.

La deuxième ligne est coupée en haut. plot() dimensionne les axes sur sa première série seulement, donc une série ultérieure plus haute déborde de la figure. Définissez ylim = range(y1, y2, ...) dans l’appel à plot() pour couvrir chaque série avant de les ajouter.

La ligne est un zigzag emmêlé. plot() relie les points dans l’ordre de x, pas par valeur. Triez d’abord : ord <- order(x); plot(x[ord], y[ord], type = "l").

Questions fréquentes

NoteComment créer un graphique en ligne en R ?

Utilisez le plot() de R de base avec type = "l" : plot(x, y, type = "l"). Ajoutez du style avec col, lwd (épaisseur) et lty (type de ligne). Pour des marqueurs sur la ligne, utilisez type = "b" ou "o" avec pch.

NoteQue signifie type = “l” dans plot() ?

type définit ce que plot() dessine. "l" dessine une ligne reliant les points, "p" dessine des points seuls, "b" dessine les deux avec un espace à chaque marqueur, "o" superpose la ligne à travers les marqueurs, et "s" dessine des marches d’escalier.

NoteComment tracer plusieurs lignes sur un même graphique en R ?

Dessinez la première série avec plot(), puis ajoutez chaque série supplémentaire avec lines(). Donnez à plot() un ylim large (par ex. range(y1, y2)) pour que les lignes ultérieures tiennent, et ajoutez une legend() avec col/lty correspondants.

NoteQuelle est la différence entre plot() et lines() en R ?

plot() démarre une nouvelle figure et dessine les axes ; lines() ajoute seulement une série sur une figure qui existe déjà. Appelez plot() une fois pour la première ligne, puis lines() pour chaque ligne supplémentaire.

NoteComment changer le type ou l’épaisseur de la ligne en R ?

Définissez lty pour le type — 1 solide, 2 tirets, 3 pointillés, jusqu’à 6 — et lwd pour l’épaisseur (2 est le double du défaut). Les deux fonctionnent dans plot() et lines() : plot(x, y, type = "l", lty = 2, lwd = 3).

Testez vos connaissances

ImportantExercice : tracez deux séries en tirets avec une légende

Le graphique ci-dessous dessine une seule ligne. Ajoutez une deuxième série y2 <- 12 - x avec lines() en ligne orange en tirets, réglez ylim pour que les deux tiennent, et ajoutez une légende en haut à droite les étiquetant "Up" et "Down".

AstuceIndice

Définissez ylim = range(y1, y2) dans l’appel à plot(). Ajoutez lines(x, y2, lty = 2, lwd = 2, col = "#e07b39"), puis legend("topright", ...) avec col et lty dans le même ordre que les étiquettes.

AstuceSolution

plot(x, y1, type = "l", lty = 1, lwd = 2, col = "#3a86d4",
     ylim = range(y1, y2), xlab = "x", ylab = "y")
lines(x, y2, lty = 2, lwd = 2, col = "#e07b39")

legend("topright",
       legend = c("Up", "Down"),
       col = c("#3a86d4", "#e07b39"),
       lty = c(1, 2))

ylim = range(y1, y2) fait de la place pour les deux séries, et les vecteurs col/lty correspondent à l’ordre des étiquettes.

Vérification rapide. Vous voulez une ligne qui passe à travers chaque marqueur de point, sans espace aux marqueurs. Quel type utilisez-vous ?

AstuceAfficher la réponse

type = "o" (superposé). "b" dessine aussi à la fois les points et les lignes mais laisse un petit espace autour de chaque marqueur ; "o" fait passer la ligne droit à travers.

Conclusion

Un graphique en ligne en R de base est plot(x, y, type = "l"), stylisé avec lty, lwd, col et pch. Utilisez "b" ou "o" pour marquer chaque point, dessinez des séries supplémentaires avec lines() (donnez d’abord à plot() un ylim assez large), ou matplot() pour plusieurs colonnes à la fois — et triez toujours par x pour que la ligne se lise clairement.

Leçons connexes

• Ajouter une légende — étiquetez les séries sur un graphique multi-lignes · Nuage de points — type = "p" pour des points sans les relier · Couleurs en R — construisez des palettes adaptées au daltonisme pour plusieurs lignes.
• Pour aller plus loin : Graphiques R de base — la série complète. · Visualisation de données — le pilier.

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

Prouvez que vous savez le faire. Maîtrisez toute la série R Base Graphics — 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 : chaque figure a été produite par le code affiché, exécuté lors de la génération du site (si elles s’affichent, le code fonctionne), et le bac à sable se réexécute en direct dans votre navigateur. Modifiez n’importe quel bloc et appuyez sur Run. The runtime is the judge.