Matrices en R : créer, sélectionner et calculer avec matrix()

Q: Comment créer une matrice en R ?

Utilisez matrix(data, nrow, ncol, byrow), par ex. matrix(1:12, nrow = 3) pour une grille 3×4 remplie colonne par colonne (ajoutez byrow = TRUE pour remplir par lignes). Vous n’avez besoin que de l’un de nrow/ncol — R déduit l’autre. Pour en construire une à partir de vecteurs existants, liez-les avec cbind() (en colonnes) ou rbind() (en lignes).

Q: Comment calculer les sommes ou les moyennes de lignes et de colonnes d’une matrice ?

Utilisez les fonctions dédiées : rowSums(m), colSums(m), rowMeans(m), colMeans(m). Pour toute autre synthèse (max, sd, une fonction personnalisée), utilisez apply(m, 1, FUN) pour les lignes ou apply(m, 2, FUN) pour les colonnes.

Q: Comment faire une multiplication matricielle en R ?

Utilisez l’opérateur %*% : A %*% B. C’est la véritable multiplication matricielle (d’algèbre linéaire), et les dimensions internes doivent correspondre — une matrice a × b multipliée par une matrice b × c donne un résultat a × c. L’opérateur * simple, lui, multiplie élément par élément et constitue une opération différente.

Q: Comment convertir une matrice en data frame (ou l’inverse) en R ?

Utilisez as.data.frame(m) pour transformer une matrice en data frame (les colonnes peuvent alors contenir des types différents), et as.matrix(df) pour faire l’inverse (toutes les colonnes sont coercées vers un unique type commun). Convertissez en data frame chaque fois que vous avez besoin de colonnes de types mélangés.

Construisez une matrice, nommez-la et sélectionnez dedans, agrégez lignes et colonnes, et multipliez — la grille base-R sur laquelle repose chaque jeu de données

Créez et manipulez des matrices en R : construisez-les avec matrix() (byrow, dimnames) et en liant des vecteurs avec cbind()/rbind() ; inspectez la forme avec dim()/nrow()/ ncol() ; nommez lignes et colonnes ; sélectionnez avec m[i, j] (et le piège drop = FALSE) ; agrégez avec rowSums()/colSums()/rowMeans()/colMeans() et apply() ; transposez avec t() ; et distinguez le calcul élément par élément de la multiplication matricielle %*%.

Date de publication

12 juillet 2026

Modifié

12 juillet 2026

Points clés

Une matrice est une grille rectangulaire de valeurs — lignes et colonnes — qui sont toutes du même type (généralement des nombres).
Créez-la avec matrix(data, nrow, ncol, byrow), ou liez des vecteurs avec cbind() (en colonnes) / rbind() (en lignes).
Forme & noms : dim()/nrow()/ncol() renseignent la taille ; rownames()/colnames()/dimnames() étiquettent les axes.
Sélectionnez avec deux index, m[i, j] — mais une tranche d’une seule ligne ou colonne se réduit silencieusement à un vecteur, sauf si vous ajoutez drop = FALSE.
Agrégez sur les lignes et les colonnes avec rowSums()/colSums()/rowMeans()/colMeans(), ou n’importe quoi d’autre via apply(m, MARGIN, FUN).
Calcul : * est élément par élément ; la véritable multiplication matricielle est %*% ; t() transpose.

Introduction

Une matrice est une grille rectangulaire de nombres : une table de corrélation, une table de comptage de réponses à un sondage, les pixels d’une image en niveaux de gris, la matrice de conception derrière une régression. Chaque fois que vos données sont naturellement bidimensionnelles et que chaque cellule contient le même type, une matrice est le bon conteneur.

C’est l’étape au-dessus du vecteur : un vecteur est une simple ligne de valeurs du même type ; une matrice arrange ces valeurs en lignes et en colonnes. Comme un vecteur, une matrice ne contient qu’un seul type — mélangez des nombres et du texte et R coerce l’ensemble en character. Quand vous avez besoin de colonnes de types différents (un âge numeric à côté d’un nom character), vous voulez plutôt un data frame ; une matrice, c’est pour la grille tout-numérique.

Cette leçon couvre la boîte à outils pratique : comment construire une matrice, l’inspecter et la nommer, en extraire lignes et colonnes, les agréger, transposer et multiplier. Chaque exemple s’exécute dans votre navigateur.

Créer une matrice

La voie directe est matrix() : donnez-lui un vecteur de données et une forme. R remplit la grille colonne par colonne par défaut ; passez byrow = TRUE pour remplir ligne par ligne à la place. Vous n’avez besoin de préciser que l’un de nrow/ncol — R déduit l’autre de la longueur des données (?matrix).

# 12 values arranged as 3 rows x 4 columns, filled DOWN each column (default)
m <- matrix(1:12, nrow = 3)
m

     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

Les mêmes données, remplies par lignes cette fois — remarquez comme les nombres se placent dans un ordre différent :

matrix(1:12, nrow = 3, byrow = TRUE)

     [,1] [,2] [,3] [,4]
[1,]    1    2    3    4
[2,]    5    6    7    8
[3,]    9   10   11   12

L’autre voie consiste à lier des vecteurs existants ensemble. cbind() les empile en colonnes ; rbind() les empile en lignes. C’est ainsi que vous assemblez une matrice à partir de données que vous avez déjà — trois mesures, chacune un vecteur, réunies en une seule table :

col1 <- c(5, 6, 7, 8, 9)
col2 <- c(2, 4, 5, 9, 8)
col3 <- c(7, 3, 4, 8, 7)

# Combine as columns
by_col <- cbind(col1, col2, col3)
by_col

     col1 col2 col3
[1,]    5    2    7
[2,]    6    4    3
[3,]    7    5    4
[4,]    8    9    8
[5,]    9    8    7

# Combine as rows instead
rbind(col1, col2, col3)

     [,1] [,2] [,3] [,4] [,5]
col1    5    6    7    8    9
col2    2    4    5    9    8
col3    7    3    4    8    7

Remarquez que cbind() a repris les noms des vecteurs (col1, col2, col3) comme noms de colonnes automatiquement — une petite commodité bonne à connaître.

Inspecter et nommer une matrice

Trois fonctions renseignent la forme d’une matrice : nrow() et ncol() donnent les décomptes, et dim() renvoie les deux sous la forme c(rows, cols).

m <- matrix(1:12, nrow = 3)
nrow(m)   # number of rows

[1] 3

ncol(m)   # number of columns

[1] 4

dim(m)    # both: rows, then columns

[1] 3 4

Une matrix() fraîchement créée n’a ni noms de lignes ni noms de colonnes — les emplacements s’affichent comme [1,], [,2]. Attachez des étiquettes avec rownames() et colnames(), ou définissez les deux d’un coup dans matrix() via dimnames (une liste de deux vecteurs : les noms de lignes, puis les noms de colonnes).

m <- matrix(1:12, nrow = 3)

# Name after the fact
rownames(m) <- c("r1", "r2", "r3")
colnames(m) <- c("a", "b", "c", "d")
m

   a b c  d
r1 1 4 7 10
r2 2 5 8 11
r3 3 6 9 12

# Or name at creation with dimnames = list(rows, cols)
matrix(
  1:6, nrow = 2,
  dimnames = list(c("row1", "row2"), c("A", "B", "C"))
)

     A B C
row1 1 3 5
row2 2 4 6

Pour confirmer qu’un objet est réellement une matrice, utilisez is.matrix() ; pour transformer une structure bidimensionnelle (comme un data frame entièrement numérique) en matrice, utilisez as.matrix().

m <- matrix(1:12, nrow = 3)      # a matrix to test

is.matrix(m)                # TRUE

[1] TRUE

is.matrix(1:12)             # FALSE — a plain vector has no dimensions

[1] FALSE

class(as.matrix(mtcars)[, 1:3])   # coerce a data frame to a matrix

[1] "matrix" "array"

Sélectionner dans une matrice : `m[i, j]`

Une matrice prend deux index entre les crochets — m[rows, columns]. Laissez un emplacement vide pour prendre toute cette dimension. C’est la compétence la plus utile sur les matrices.

m <- matrix(1:12, nrow = 3,
            dimnames = list(c("r1", "r2", "r3"), c("a", "b", "c", "d")))

m[2, ]        # row 2, all columns

 a  b  c  d 
 2  5  8 11

m[, "c"]      # column "c" (by name), all rows

r1 r2 r3 
 7  8  9

m[2, 3]       # the single value at row 2, column 3

[1] 8

m[1:2, c("a", "b")]   # a 2x2 block: first two rows, columns a and b

   a b
r1 1 4
r2 2 5

Le piège `drop = FALSE`

Quand vous sélectionnez une seule ligne ou colonne, R « vous rend service » en simplifiant le résultat d’une matrice vers un simple vecteur — ce qui casse discrètement tout code ultérieur qui attendait de récupérer une matrice (avec ses dimensions et ses noms).

m <- matrix(1:12, nrow = 3)

class(m[2, ])                 # "integer" — the row collapsed to a vector!

[1] "integer"

class(m[2, , drop = FALSE])   # "matrix" "array" — dimensions kept

[1] "matrix" "array"

Ajoutez drop = FALSE chaque fois qu’une tranche d’une ligne ou d’une colonne doit rester une matrice. C’est la source d’innombrables surprises du type « pourquoi ma matrice s’est-elle transformée en vecteur ? ».

Pour toute la mécanique de l’indexation — index négatifs, conditions logiques, which(), et comment [ diffère de [[ et $ — voir Indexation et sous-ensembles. Les bases de [i, j] ci-dessus suffisent pour suivre le reste de cette leçon.

Agréger lignes et colonnes

La raison la plus courante de recourir à une matrice est de la résumer par ligne ou par colonne. Quatre fonctions dédiées couvrent les cas habituels ; elles sont rapides et se lisent clairement. Nous utiliserons VADeaths, une matrice intégrée des taux de mortalité (pour 1000) en Virginie en 1940, ventilés par tranche d’âge (lignes) et groupe démographique (colonnes).

VADeaths          # a real 5 x 4 numeric matrix

      Rural Male Rural Female Urban Male Urban Female
50-54       11.7          8.7       15.4          8.4
55-59       18.1         11.7       24.3         13.6
60-64       26.9         20.3       37.0         19.3
65-69       41.0         30.9       54.6         35.1
70-74       66.0         54.3       71.1         50.0

rowSums() / colSums() totalisent chaque ligne / colonne ; rowMeans() / colMeans() en font la moyenne. Ici, les moyennes de lignes donnent le taux de mortalité moyen pour chaque tranche d’âge à travers les quatre groupes, et les moyennes de colonnes donnent le taux moyen pour chaque groupe à travers les tranches d’âge :

rowMeans(VADeaths)   # average rate per age band (across the 4 groups)

 50-54  55-59  60-64  65-69  70-74 
11.050 16.925 25.875 40.400 60.350

colMeans(VADeaths)   # average rate per group  (across the 5 age bands)

  Rural Male Rural Female   Urban Male Urban Female 
       32.74        25.18        40.48        25.28

colSums(VADeaths)    # column totals

  Rural Male Rural Female   Urban Male Urban Female 
       163.7        125.9        202.4        126.4

Au-delà des sommes et des moyennes : `apply()`

rowSums() et ses semblables sont des raccourcis pour les quatre synthèses les plus courantes. Pour toute autre fonction — le max, l’écart-type, un calcul personnalisé — utilisez apply(m, MARGIN, FUN) : MARGIN = 1 parcourt les lignes, MARGIN = 2 parcourt les colonnes (?apply).

apply(VADeaths, 2, max)   # the highest rate in each column (group)

  Rural Male Rural Female   Urban Male Urban Female 
        66.0         54.3         71.1         50.0

apply(VADeaths, 1, sd)    # the spread of rates within each age band

    50-54     55-59     60-64     65-69     70-74 
 3.260368  5.601414  8.147137 10.333441  9.852411

apply(VADeaths, 2, range) # min and max per column -> a 2-row matrix

     Rural Male Rural Female Urban Male Urban Female
[1,]       11.7          8.7       15.4          8.4
[2,]       66.0         54.3       71.1         50.0

Lisez la marge comme « quelle dimension est-ce que je conserve ? » — MARGIN = 2 renvoie une valeur par colonne, MARGIN = 1 une par ligne. apply() se généralise à n’importe quelle fonction, donc rowMeans(m) et apply(m, 1, mean) donnent la même réponse (rowMeans est simplement plus rapide et plus clair). Pour la famille apply élargie — lapply(), sapply(), tapply() — voir La famille apply.

Calcul élément par élément, transposition et multiplication matricielle

L’arithmétique ordinaire sur une matrice fonctionne élément par élément, exactement comme sur un vecteur — chaque cellule est transformée indépendamment. Multipliez par un scalaire, ou prenez un log, et la forme reste inchangée :

m <- matrix(1:6, nrow = 2)
m * 10       # each element x 10

     [,1] [,2] [,3]
[1,]   10   30   50
[2,]   20   40   60

m + 100      # add 100 to every cell

     [,1] [,2] [,3]
[1,]  101  103  105
[2,]  102  104  106

log2(m + 1)  # log2 applied cell by cell

         [,1]     [,2]     [,3]
[1,] 1.000000 2.000000 2.584963
[2,] 1.584963 2.321928 2.807355

t() transpose — elle bascule les lignes en colonnes, transformant une matrice r × c en une matrice c × r :

m <- matrix(1:6, nrow = 2)
dim(m)     # 2 x 3

[1] 2 3

t(m)       # now 3 x 2

     [,1] [,2]
[1,]    1    2
[2,]    3    4
[3,]    5    6

La seule opération qui n’est pas élément par élément est la véritable multiplication matricielle, notée %*%. C’est le produit d’algèbre linéaire (lignes par colonnes) au cœur de la régression et de nombreux algorithmes — à ne pas confondre avec *. Les dimensions internes doivent correspondre : une matrice a × b multipliée par une matrice b × c donne un résultat a × c.

A <- matrix(1:6, nrow = 2)   # 2 x 3
B <- matrix(1:6, nrow = 3)   # 3 x 2

A %*% B      # (2 x 3) %*% (3 x 2) -> 2 x 2

     [,1] [,2]
[1,]   22   49
[2,]   28   64

dim(A %*% B)

[1] 2 2

Utilisez * quand vous voulez mettre à l’échelle ou combiner les cellules position par position ; utilisez %*% quand vous entendez le produit algébrique. Les confondre est un bug classique — la section Problèmes courants y revient.

Essayez en direct

Les blocs ci-dessus ont été exécutés au moment de la construction. Éditez celui-ci et appuyez sur Run pour construire une matrice, la nommer, y sélectionner et agréger — il s’exécute dans votre navigateur via webR (aucune installation).

🟢 Avec un agent IA

Collez une opération sur matrice qui se comporte mal et demandez à Prova « pourquoi une seule ligne de ma matrice est-elle devenue un vecteur, et comment la garder en matrice ? » — elle repère le drop = FALSE manquant (ou la confusion entre * et %*%) et réécrit la ligne, et comme le runtime est juste là, vous l’exécutez pour confirmer la forme sur vos données. Demandez à Prova →

Problèmes fréquents

Une seule ligne (ou colonne) de ma matrice s’est transformée en vecteur. Sélectionner une seule ligne ou colonne amène R à supprimer la dimension et à simplifier en vecteur, si bien que dim(), nrow() et les noms de colonnes disparaissent. Passez drop = FALSE pour conserver la structure de matrice : m[2, , drop = FALSE].

Mes nombres se sont transformés en texte après l’ajout d’une colonne. Une matrice ne contient qu’un seul type. Liez un vecteur character à une matrice numeric (ou glissez une seule chaîne dans les données) et R coerce chaque cellule en character, si bien que l’arithmétique cesse de fonctionner. Vérifiez avec is.character(m[1, 1]) ; si vous avez réellement besoin de colonnes de types mélangés, utilisez un data frame, pas une matrice.

* m’a donné le mauvais produit. A * B multiplie cellule par cellule (et exige des formes identiques) ; ce n’est pas le produit d’algèbre linéaire. Pour une véritable multiplication matricielle, utilisez A %*% B, où les dimensions internes doivent être compatibles (a × b fois b × c). Une erreur non-conformable arguments signifie presque toujours que vous avez utilisé %*% avec des dimensions incompatibles — vérifiez dim(A) et dim(B).

Questions fréquentes

Comment créer une matrice en R ?

Utilisez matrix(data, nrow, ncol, byrow), par ex. matrix(1:12, nrow = 3) pour une grille 3×4 remplie colonne par colonne (ajoutez byrow = TRUE pour remplir par lignes). Vous n’avez besoin que de l’un de nrow/ncol — R déduit l’autre. Pour en construire une à partir de vecteurs existants, liez-les avec cbind() (en colonnes) ou rbind() (en lignes).

Comment calculer les sommes ou les moyennes de lignes et de colonnes d’une matrice ?

Utilisez les fonctions dédiées : rowSums(m), colSums(m), rowMeans(m), colMeans(m). Pour toute autre synthèse (max, sd, une fonction personnalisée), utilisez apply(m, 1, FUN) pour les lignes ou apply(m, 2, FUN) pour les colonnes.

Comment faire une multiplication matricielle en R ?

Utilisez l’opérateur %*% : A %*% B. C’est la véritable multiplication matricielle (d’algèbre linéaire), et les dimensions internes doivent correspondre — une matrice a × b multipliée par une matrice b × c donne un résultat a × c. L’opérateur * simple, lui, multiplie élément par élément et constitue une opération différente.

Pourquoi une seule ligne de ma matrice est-elle devenue un vecteur ?

Quand vous sélectionnez une seule ligne ou colonne, R supprime la dimension supplémentaire et simplifie le résultat en vecteur par défaut. Ajoutez drop = FALSE pour la garder en matrice : m[2, , drop = FALSE]. Voir Indexation et sous-ensembles pour toutes les règles.

Comment convertir une matrice en data frame (ou l’inverse) en R ?

Utilisez as.data.frame(m) pour transformer une matrice en data frame (les colonnes peuvent alors contenir des types différents), et as.matrix(df) pour faire l’inverse (toutes les colonnes sont coercées vers un unique type commun). Convertissez en data frame chaque fois que vous avez besoin de colonnes de types mélangés.

Testez vos connaissances

Exercice : construire, nommer, sélectionner et agréger une matrice

Créez une matrice m à partir de 1:12 avec 3 lignes, remplie par ligne. Nommez ses colonnes "a", "b", "c", "d". Puis (1) extrayez la colonne "b" en la gardant en matrice, (2) calculez la somme de chaque ligne, et (3) calculez la moyenne de chaque colonne.

# nrow is 3; byrow = TRUE fills across rows.
# Column names are a character vector: c("a", "b", "c", "d").
# Keep a single column as a matrix with drop = FALSE.
# Row sums -> rowSums(); column means -> colMeans().

m <- matrix(1:12, nrow = 3, byrow = TRUE)
colnames(m) <- c("a", "b", "c", "d")

# 1. Column "b", kept as a matrix
m[, "b", drop = FALSE]

# 2. Sum of each row
rowSums(m)

# 3. Mean of each column
colMeans(m)

Vérification rapide : que fait A %*% B ?

Si A est 2×3 et B est 3×2, que vaut A %*% B ?

A. Multiplication élément par élément des deux matrices B. Une matrice 2×2 (véritable multiplication matricielle) C. Une erreur, parce que les formes diffèrent

Afficher la réponse

B. %*% est la véritable multiplication matricielle : les dimensions internes (3 et 3) correspondent, et le résultat a les dimensions externes — 2×2. La multiplication élément par élément est l’opérateur * simple, qui exigerait au contraire que les deux matrices aient la même forme.

Conclusion

Une matrice est la grille rectangulaire à type unique de R — le conteneur des tables de corrélation, des tables de comptage et des données numériques derrière la plupart des modèles. Construisez-la avec matrix() ou cbind()/rbind(), vérifiez sa forme avec dim(), étiquetez-la avec rownames()/colnames(), et extrayez lignes et colonnes avec m[i, j] — sans oublier drop = FALSE quand une tranche unique doit rester une matrice. Résumez avec rowSums()/colMeans() ou le apply() général, et gardez * (élément par élément) distinct de %*% (multiplication matricielle). Avec ces gestes, la moitié bidimensionnelle de R est à vous.

Leçons connexes

Vecteurs et types de données en R — le conteneur unidimensionnel à partir duquel une matrice est construite, et les règles de coercition qui rendent une matrice à type unique. · Indexation et sous-ensembles — toute la mécanique de [, [[, $, y compris m[i, j] avec index négatifs et logiques. · La famille apply — apply() sur les marges plus lapply()/sapply()/tapply() pour les listes, les vecteurs et les groupes. · Jeux de données intégrés à R — des matrices d’entraînement comme VADeaths et state.x77.
Aller plus loin : Fondations R — la série complète. · Science computationnelle et IA — le pilier.

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

Prouvez que vous savez le faire. Maîtrisez toute la série Les bases de R — 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.

Note

Cette leçon est reproductible : chaque résultat de cette page a été produit par le code affiché — modifiez n’importe quel bloc et appuyez sur Run pour le reproduire dans votre navigateur. The runtime is the judge.

Réutilisation

CC BY-NC-SA 4.0

Citation

BibTeX

@online{2026,
  author = {},
  title = {Matrices en R : créer, sélectionner et calculer avec
    matrix()},
  date = {2026-07-12},
  url = {https://www.datanovia.com/learn/programming/r-foundations/matrices-in-r},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

“Matrices en R : créer, sélectionner et calculer avec matrix().” 2026. July 12. https://www.datanovia.com/learn/programming/r-foundations/matrices-in-r.