Les vecteurs en R : c(), seq(), indexation et calcul vectorisé

Tout en R est un vecteur

La plupart des langages ont des scalaires - des valeurs uniques - puis un type conteneur pour en stocker plusieurs. R saute le scalaire. Un vecteur est une collection ordonnée de valeurs partageant toutes un même type, et c'est l'unité sur laquelle tout le reste est construit. Même ce qui ressemble à un nombre isolé est un vecteur de longueur 1 :

scores <- c(70, 85, 92)
print(scores)
print(length(scores))

print(is.vector(5))
print(length(5))

c() - abréviation de combine - est la façon de construire un vecteur à la main. length() te dit combien d'éléments il contient. Et 5 tout seul rapporte is.vector à TRUE avec une longueur de 1 : R ne cesse jamais de travailler avec des vecteurs, il en manipule juste parfois de très courts.

C'est ce choix de conception qui fait que le code R ne ressemble pas à du Python ou du JavaScript : des opérations pour lesquelles tu écrirais une boucle ailleurs s'appliquent ici à des vecteurs entiers en une seule expression. On y vient plus bas.

Une règle à intégrer dès maintenant : tous les éléments d'un vecteur ont le même type. Si tu donnes un mélange à c(), il ne proteste pas - il convertit silencieusement tout vers le type le plus souple présent :

mixed <- c(1, "two", TRUE)
print(mixed)
print(class(mixed))

numish <- c(1, TRUE, FALSE)
print(numish)
print(class(numish))

Une chaîne dans le mélange transforme tout en chaînes ("1", "TRUE"). Des logiques parmi des nombres deviennent 1 et 0. Cette coercition suit un ordre de priorité fixe - logical → integer → double → character - et se produit sans avertissement, c'est pourquoi un "7" égaré dans une colonne de nombres peut transformer discrètement tout ton jeu de données en texte. La hiérarchie complète est traitée dans les types de données ; si tu dois stocker des valeurs réellement hétérogènes, c'est à ça que servent les listes.

Générer des séquences : :, seq() et rep()

Taper chaque élément dans c() devient vite pénible. R a trois raccourcis pour les motifs réguliers :

print(1:10)
print(seq(0, 1, by = 0.25))
print(seq(2, 20, length.out = 4))
print(seq_len(5))

print(rep("ha", 3))
print(rep(c(1, 2), times = 3))
print(rep(c(1, 2), each = 3))

• 1:10 est le raccourci du quotidien : les entiers d'une borne à l'autre, par pas de 1.
• seq() le généralise : choisis le pas avec by =, ou dis combien d'éléments tu veux avec length.out = et laisse R calculer l'espacement.
• seq_len(n) produit 1 à n et c'est la façon sûre de construire des indices de boucle - contrairement à 1:n, il donne correctement un vecteur vide quand n vaut 0 au lieu de compter 1 0 à rebours.
• rep() répète : times = répète le vecteur entier bout à bout (1 2 1 2 1 2), each = répète chaque élément sur place (1 1 1 2 2 2). Les deux sont faciles à confondre ; lance l'extrait et compare.

Indexation : R compte à partir de 1

Les crochets extraient des éléments. Le premier élément est [1] - pas [0]. Si tu arrives de Python ou de JavaScript, c'est le faux pas le plus courant du début :

fruits <- c("apple", "banana", "cherry", "date")

print(fruits[1])
print(fruits[c(2, 4)])
print(fruits[-1])
print(fruits[-c(1, 2)])

Trois choses ici méritent une pause :

• Tu peux indexer avec un vecteur de positions - fruits[c(2, 4)] attrape le deuxième et le quatrième d'un coup.
• Les indices négatifs signifient « tout sauf ». fruits[-1] est le vecteur sans son premier élément. C'est complètement différent de Python, où -1 désigne le dernier élément. Tu ne peux pas mélanger indices positifs et négatifs dans le même appel.
• fruits[0] n'est pas une erreur - il renvoie un character(0) vide. Un décalage d'un cran en R produit souvent des résultats vides silencieux plutôt qu'un plantage, donc ça vaut le coup de vérifier length() quand quelque chose plus loin semble mystérieusement vide.

Les éléments peuvent aussi porter des noms, ce qui te donne une troisième façon d'indexer - par étiquette :

prices <- c(coffee = 3.5, tea = 2.8, juice = 4.2)
print(prices["tea"])
print(prices[c("coffee", "juice")])
print(names(prices))

Les vecteurs nommés fonctionnent comme une petite table de correspondance et gardent le code lisible : prices["tea"] dit ce qu'il veut dire, prices[2] non.

Masques logiques et which()

La façon la plus puissante d'indexer, c'est avec un vecteur logique - un masque de valeurs TRUE/FALSE de la même longueur que les données. Chaque comparaison sur un vecteur produit exactement ça :

temps <- c(18, 25, 31, 22, 35)

hot <- temps > 24
print(hot)
print(temps[hot])

print(temps[temps > 24 & temps < 33])
print(which(temps > 24))

temps > 24 ne donne pas une réponse - il en donne cinq, une par élément. Mettre ce masque dans [ ] garde les éléments là où le masque vaut TRUE. Combine les conditions avec & (et) et | (ou), traités avec le reste des opérateurs.

which() traduit un masque en positions : ici 2 3 5, les indices des relevés chauds. Sors-le quand tu as besoin de savoir où sont les correspondances - pour les rapporter, ou pour indexer un autre vecteur aux mêmes endroits. Pour un simple filtrage, temps[temps > 24] est plus direct que temps[which(temps > 24)].

Ce motif « filtrer avec un masque » est la colonne vertébrale de pratiquement tout le travail de données en R - il revient directement quand tu filtres les lignes d'un data frame.

Calcul vectorisé et règle de recyclage

L'arithmétique en R s'applique élément par élément sur des vecteurs entiers - sans boucle :

prices <- c(10, 20, 30)

print(prices * 2)
print(prices + c(1, 2, 3))
print(c(1, 2, 3, 4) + c(10, 20))

La première ligne est la fonctionnalité phare : prices * 2 double chaque élément. Là où d'autres langages ont besoin d'une boucle for, R a besoin d'un opérateur - et la forme vectorisée est à la fois plus courte et plus rapide, parce que la boucle a lieu en C optimisé en dessous. Écris une boucle for quand chaque étape dépend de la précédente ; pour du calcul élément par élément, vectorise.

La troisième ligne montre la règle de recyclage : quand les vecteurs ont des longueurs différentes, R répète le plus court pour correspondre. c(10, 20) est recyclé en 10 20 10 20, donnant 11 22 13 24. Recycler 2 sur un vecteur de longueur 3, c'est exactement ce qui a fait marcher prices * 2 - un scalaire n'est qu'un vecteur de longueur 1 qu'on recycle.

Le recyclage est propre quand la longueur la plus grande est un multiple exact de la plus petite. Quand ce n'est pas le cas, R calcule quand même une réponse - et émet un avertissement :

print(c(1, 2, 3) + c(10, 20))

Tu obtiens 11 22 13 plus un avertissement disant que la longueur de l'objet le plus long n'est pas un multiple de celle du plus court. Traite cet avertissement comme un rapport de bug : le recyclage partiel n'est presque jamais ce que tu voulais, et il signifie généralement que deux vecteurs qui auraient dû avoir la même longueur ne l'ont pas.

Trier, inverser, dédupliquer

Trois petits utilitaires que tu utiliseras constamment :

x <- c(3, 1, 4, 1, 5)

print(sort(x))
print(sort(x, decreasing = TRUE))
print(rev(x))
print(unique(x))

sort() ordonne les valeurs, rev() retourne l'ordre existant sans trier, et unique() supprime les doublons en gardant les premières apparitions. Aucun d'eux ne modifie x - comme presque tout en R, ils renvoient un nouveau vecteur et laissent l'original tranquille.

Ce que tu retiens

• Un vecteur est l'unité fondamentale de R : ordonné, d'un seul type de bout en bout, et même les valeurs uniques sont des vecteurs de longueur 1.
• Construis avec c(), génère des motifs avec :, seq() et rep() - et souviens-toi que c() force silencieusement les types mélangés.
• L'indexation commence à 1 ; les indices négatifs retirent des éléments ; les noms permettent d'indexer par étiquette.
• Les masques logiques (x[x > 5]) sont l'idiome de filtrage de tout le langage ; which() transforme un masque en positions.
• Le calcul est vectorisé, les vecteurs plus courts sont recyclés, et un avertissement de recyclage partiel signifie que tu as un bug.

Prochaine étape : les listes - le conteneur pour quand tes valeurs ne partagent pas toutes un même type.