Formation R initiation Martin Chevalier (Insee)

 

 

La philosophie de ce deuxième module diffère sensiblement de celle des modules 1 et 3. Son objectif est de vous amener à manipuler les briques élémentaires du langage de R : vecteurs, matrices et listes. À ce titre, il s’agit d’un détour indispensable avant d’aborder les opérations plus complexes portant sur les tables de données (sélection d’observations et de variables, tri, fusion, etc.).

Plus encore que les autres modules, il est pensé pour articuler étroitement apprentissage d’un “vocabulaire” de fonctions et mise en oeuvre autour de cas pratiques.

 

Les vecteurs : création et sélection

Les vecteurs constituent un des types d’objets les plus simples et les plus courants dans R. Ils interviennent dans la manipulation de la plupart des autres types d’objets et méritent à ce titre une attention particulière.

Exemples Les variables d’une table sont des vecteurs, tout comme la plupart des paramètres passés à une fonction.

Créer des vecteurs et connaître leurs caractéristiques

La fonction c() permet de créer des vecteurs :

# Création de vecteurs
c(8, 5)
  ## [1] 8 5
c("z","B","e")
  ## [1] "z" "B" "e"
c(TRUE, FALSE, FALSE, TRUE)
  ## [1]  TRUE FALSE FALSE  TRUE

Pour associer un vecteur à un nom d’objet, il suffit d’utiliser l’opérateur d’assignation <- :

# Assignation de vecteurs à des noms
a1 <- c(8, 5)
a2 <- c("z", "B", "e")
a3 <- c(TRUE, FALSE, FALSE, TRUE)

# Rappel de la valeur des vecteurs définis
a1
  ## [1] 8 5
a2
  ## [1] "z" "B" "e"
a3
  ## [1]  TRUE FALSE FALSE  TRUE

Un vecteur possède plusieurs caractéristiques essentielles (que l’on qualifie d’attributs) :

  • son type : les types les plus courants sont numérique, caractère et logique ;
  • sa longueur : le nombre d’éléments qui le composent.

Il est possible d’afficher ces attributs avec les fonctions str(), mode() et length().

# Attributs de a1
str(a1)
  ##  num [1:2] 8 5
mode(a1)
  ## [1] "numeric"
length(a1)
  ## [1] 2

# Attributs de a2
str(a2)
  ##  chr [1:3] "z" "B" "e"
mode(a2)
  ## [1] "character"
length(a2)
  ## [1] 3

# Attributs de a3
str(a3)
  ##  logi [1:4] TRUE FALSE FALSE TRUE
mode(a3)
  ## [1] "logical"
length(a3)
  ## [1] 4

Les fonctions is.numeric(), is.character() et is.logical() permettent de tester si un vecteur est de type numérique, caractère ou logique respectivement.

# Utilisation de is.numeric()
is.numeric(a1)
  ## [1] TRUE
is.numeric(a2)
  ## [1] FALSE
is.numeric(a3)
  ## [1] FALSE

# Utilisation de is.character()
is.character(a1)
  ## [1] FALSE
is.character(a2)
  ## [1] TRUE
is.character(a3)
  ## [1] FALSE

# Utilisation de is.logical()
is.logical(a1)
  ## [1] FALSE
is.logical(a2)
  ## [1] FALSE
is.logical(a3)
  ## [1] TRUE

 

Remarques :

  • Quand on souhaite créer un vecteur de longueur 1, la fonction c() est inutile. C’est ce qui a été fait pendant tout le module 1 de la formation.
# Création d'un vecteur de longueur 1
a4 <- 2
a5 <- c(2)
identical(a4, a5)
  ## [1] TRUE
  • Les vecteurs de type logique ne peuvent prendre que deux valeurs (en plus des valeurs manquantes NA, cf. infra) : vrai (TRUE) et faux (FALSE). TRUE et FALSE sont des mots-clés spécifiques qui doivent être écrits intégralement en majuscules :
# Création d'un vecteur logique
a6 <- c(TRUE, FALSE, TRUE, TRUE)
a6
  ## [1]  TRUE FALSE  TRUE  TRUE
is.logical(a6)
  ## [1] TRUE

# Quand TRUE et FALSE ne sont pas écrits intégralement 
# en majuscules, des erreurs surviennent
a7 <- c(True, fALSE, true,false)
  ## Error in eval(expr, envir, enclos): objet 'True' introuvable
# R recherche un objet dont le nom est `True` mais n'en 
# trouve aucun.
  • Quand nombres, caractères ou valeurs logiques coexistent dans la définition d’un vecteur, des conversions automatiques sont opérées :
# Création d'un vecteur mélangeant nombres, caractères
# et valeurs logiques
a8 <- c("a", 2, "b", TRUE)
a8
  ## [1] "a"    "2"    "b"    "TRUE"

# Des guillemets apparaissent autour des valeurs numériques
# ou logiques : le vecteur est de type caractère
is.character(a8)
  ## [1] TRUE

 

La fonction c() permet également de créer un vecteur à partir de plusieurs autres.

# Création des vecteurs de type caractère a9 et a10
a9 <- c("a", "b", "c", "d")
a10 <- c("mais", "ou", "et", "donc", "or", "ni", "car")

# Concaténation avec la fonction c()
c(a9, a10)
  ##  [1] "a"    "b"    "c"    "d"    "mais" "ou"   "et"   "donc" "or"   "ni"  
  ## [11] "car"
c(a10, a9)
  ##  [1] "mais" "ou"   "et"   "donc" "or"   "ni"   "car"  "a"    "b"    "c"   
  ## [11] "d"

La fonction rep() permet enfin de créer des vecteurs en répétant une ou plusieurs valeurs un certain nombre de fois.

# Création d'un vecteur avec la fonction rep()
rep(1, times = 5)
  ## [1] 1 1 1 1 1

# Quand le premier argument de rep() est un vecteur, 
# il est répété en entier
rep(c(1, 2), times = 5)
  ##  [1] 1 2 1 2 1 2 1 2 1 2

# Utilisé à la place de times = , l'argument each = 
# permet de répéter chaque élément et non le vecteur
# en entier
rep(c(1, 2), each = 5)
  ##  [1] 1 1 1 1 1 2 2 2 2 2

 

Cas pratique 2.1 Créer des vecteurs et connaître leurs caractéristiques

  1. Devinez le type et la longueur des vecteurs définis par le code suivant, puis vérifiez-les en créant ces vecteurs et en utilisant les fonctions str(), length() et mode().

    b1 <- c(1, 2, 3)
b2 <- rep(c("aaa","bbb"), times = 2)
b3 <- c(TRUE, FALSE, TRUE)
b4 <- c("TRUE", "FALSE", "FALSE")
b5 <- c(b2, b4)
b6 <- c(b1, b3)

     

  2. Utilisez la fonction rep() pour créer la séquence 1, 2, 1, 2. Utilisez de nouveau rep() pour créer la séquence 1, 1, 1, 2, 2, 2. Combinez ces éléments pour créer la séquence 1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2.

     

Extraire les éléments d’un vecteur

L’opérateur d’extraction [ permet de sélectionner des éléments en utilisant leur position dans le vecteur :

# Définition du vecteur c1
c1 <- c("a", "b", "c", "d", "e", "f", "g", "h", "i", "j")
c1
  ##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"

# Sélection de l'élément en position 2
c1[2]
  ## [1] "b"

# Sélection de l'élément en position 5
c1[5]
  ## [1] "e"

Pour extraire plus d’une valeur à la fois, il suffit d’utiliser l’opérateur [ avec le vecteur des positions souhaitées :

# Sélection des éléments en position 3 et 6
c1[c(3, 6)]
  ## [1] "c" "f"

Pour sélectionner toutes les valeurs sauf certaines, il suffit de d’indiquer leur position précédée de - :

# Sélection de tous les éléments SAUF celui en position 3
c1[-3]
  ## [1] "a" "b" "d" "e" "f" "g" "h" "i" "j"

# Sélection de tous les éléments SAUF ceux en position 2 et 7
c1[-c(2,7)]
  ## [1] "a" "c" "d" "e" "f" "h" "i" "j"

 

Il est également possible de définir des vecteurs dont chaque élément est nommé :

# Création du vecteur numérique c2 nommé
c2 <- c("pierre" = 1, "feuille" = 2, "ciseaux" = 3)
c2
  ##  pierre feuille ciseaux 
  ##       1       2       3

Il est alors possible d’utiliser les noms pour sélectionner un ou plusieurs éléments :

# Sélection de l'élément associé au nom "pierre"
c2["pierre"]
  ## pierre 
  ##      1

# Sélection des éléments associés aux noms "ciseaux" et "feuille"
c2[c("ciseaux","feuille")]
  ## ciseaux feuille 
  ##       3       2

Il est possible d’afficher et de modifier les noms associés à un vecteur en utilisant la fonction names() :

# Affichage des noms associés au vecteur c2
names(c2)
  ## [1] "pierre"  "feuille" "ciseaux"

# Modification des noms associés au vecteur c2
names(c2) <- c("rouge", "jaune", "bleu")
c2
  ## rouge jaune  bleu 
  ##     1     2     3

 

Remarque importante Les éléments d’un vecteur sont extraits dans l’ordre dans lequel sont renseignés les positions ou les noms.

# On compare le résultat de c1[c(3, 6)] et de c1[c(6, 3)]
c1
  ##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"

c1[c(3, 6)]
  ## [1] "c" "f"

c1[c(6, 3)]
  ## [1] "f" "c"

# Cela est vrai également quand l'extraction est opérée par les noms
c2
  ## rouge jaune  bleu 
  ##     1     2     3

c2[c("rouge", "jaune")]
  ## rouge jaune 
  ##     1     2

c2[c("jaune", "rouge")]
  ## jaune rouge 
  ##     2     1

En cas de répétition d’une position ou d’un nom, l’élément du vecteur correspondant est répété dans le résultat :

c1[c(3, 3, 6, 6)]
  ## [1] "c" "c" "f" "f"

c2[c("rouge", "jaune", "jaune", "rouge")]
  ## rouge jaune jaune rouge 
  ##     1     2     2     1

Cette propriété est extrêmement importante, dans la mesure où c’est sur elle que repose les opérations de tri de tables de données via la fonction order() (cf. infra et module 3).

 

 

Cas pratique 2.2 Extraire les valeurs d’un vecteur

  1. On définit le vecteur numérique d1 par d1 <- c(2, 7, 5, 8). Sélectionnez l’élément en troisième position, puis les éléments en quatrième et deuxième positions (dans cet ordre). Sélectionnez enfin tous les éléments sauf celui en première position.

     

  2. On définit le vecteur logique d2 nommé par d2 <- c("a" = TRUE, "b" = FALSE, "c" = FALSE, "d" = TRUE, "e" = TRUE). Que signifient les lettres "a", "b", "c", "d" et "e" dans la définition du vecteur ? Proposez deux méthodes pour sélectionner les éléments de d2 situé en troisième et première position (dans cet ordre).

     

  3. Affichez le vecteur de noms associé au vecteur d2 avec la fonction names(). Quel est le type de ce vecteur ? Modifiez le vecteur de noms associé au vecteur d2 et remplacez le par c(2011, 2012, 2013, 2014, 2015).

     

  4. (Optionnel) Que se passe-t-il quand vous saisissez d2[c(2012, 2015)]. Comment le comprenez-vous ? Quel code proposeriez-vous pour sélectionner les éléments dont les noms sont "2012" et "2015" ?

     

     

 

Les vecteurs : types et opérations

Manipuler des vecteurs logiques

Les vecteurs logiques sont particulièrement importants dans la mesure où ils interviennent dans l’évaluation et l’utilisation d’expressions logiques. Comme la plupart des langages, R dispose d’opérateurs logiques lui permettant d’évaluer certaines expressions (cf. tableau). Ces opérateurs ne sont rien d’autres que des fonctions dont le résultat est un vecteur logique.

Code R Résultat
a == 1 Renvoie TRUE si a vaut 1
a != 1 Renvoie TRUE si a est différent de 1
a < 1 Renvoie TRUE si a est strictement inférieur à 1
a <= 1 Renvoie TRUE si a est inférieur ou égal à 1
a > 1 Renvoie TRUE si a est strictement supérieur à 1
a >= 1 Renvoie TRUE si a est supérieur ou égal à 1
a & b Renvoie TRUE si a est TRUE et b est TRUE
a | b Renvoie TRUE si a est TRUE ou b est TRUE
!a Renvoie TRUE si a est FALSE, FALSE si a est TRUE
a %in% c(1,2) Renvoie TRUE si a vaut 1 ou 2 
# Définition du vecteur e1
e1 <- c(1, 2, 3, 4, 5)
e1
  ## [1] 1 2 3 4 5

# Evaluation d'expressions logiques
e1 == 3
  ## [1] FALSE FALSE  TRUE FALSE FALSE

e1 != 3
  ## [1]  TRUE  TRUE FALSE  TRUE  TRUE

e1 < 3
  ## [1]  TRUE  TRUE FALSE FALSE FALSE

e1 <= 3
  ## [1]  TRUE  TRUE  TRUE FALSE FALSE

!(e1 <= 3)
  ## [1] FALSE FALSE FALSE  TRUE  TRUE

e1 >= 1 & e1 < 4
  ## [1]  TRUE  TRUE  TRUE FALSE FALSE

e1 < 2 | e1 > 4
  ## [1]  TRUE FALSE FALSE FALSE  TRUE

e1 %in% c(1, 3)
  ## [1]  TRUE FALSE  TRUE FALSE FALSE

 

Les vecteurs logiques peuvent ainsi être utilisés dans de nombreuses situations :

  • combinés avec la fonction sum(), pour déterminer le nombre d’éléments d’un vecteur qui respectent une certaine condition :

    e1
  ## [1] 1 2 3 4 5
# Nombre d'éléments de e1 strictement inférieurs à 3
sum(e1 < 3)
  ## [1] 2

  • combinés avec la fonction which(), pour récupérer la position des éléments d’un vecteur respectant une certaine condition :

    e1
  ## [1] 1 2 3 4 5
# Position des éléments de e1 strictement supérieurs à 2
which(e1 > 2)
  ## [1] 3 4 5

  • combinés avec l’opérateur d’extraction [, pour sélectionner ou remplacer les éléments respectant une certaine condition :

    e1
  ## [1] 1 2 3 4 5
# Sélection des éléments de e1 dont la valeur 
# est strictement inférieure à 3
e1[e1 < 3]
  ## [1] 1 2

# Remplacement des éléments de e1 dont la valeur 
# est strictement inférieure à 3 par 0
e1[e1 < 3] <- 0
e1
  ## [1] 0 0 3 4 5

 

À retenir Il existe ainsi trois méthodes pour extraire les éléments d’un vecteur via l’opérateur [ :

  • utiliser un vecteur de positions;
  • utiliser un vecteur de noms (quand des noms sont définis);
  • utiliser un vecteur logique de même longueur.
e2 <- c("a" = 1, "b" = 2, "c" = 3, "d" = 4, "e" = 5)
e2
  ## a b c d e 
  ## 1 2 3 4 5
# Objectif : extraire les éléments en 2ème et 5ème position de e2

# Méthode 1 : par les positions
e2[c(2, 5)]
  ## b e 
  ## 2 5

# Méthode 2 : par les noms
e2[c("b", "e")]
  ## b e 
  ## 2 5

# Méthode 3 : avec un vecteur logique de longueur 5
# (car e2 est de longueur 5)
e2[c(FALSE, TRUE, FALSE, FALSE, TRUE)]
  ## b e 
  ## 2 5

Les deux premières méthodes permettent de modifier l’ordre des éléments ou de les répéter, mais pas la troisième :

e2
  ## a b c d e 
  ## 1 2 3 4 5

e2[c(2, 1, 2, 3, 1)]
  ## b a b c a 
  ## 2 1 2 3 1

e2[c("b", "a", "b", "c", "a")]
  ## b a b c a 
  ## 2 1 2 3 1

e2[c(TRUE, TRUE, TRUE, FALSE, FALSE)]
  ## a b c 
  ## 1 2 3
# Note : il est impossible de changer l'ordre dans lequel apparaissent
# les éléments extraits (ni de les répéter) quand on utilise un vecteur
# logique pour mener l'extraction.

L’utilisation de vecteurs logique pour extraire des valeurs est particulièrement importante, dans la mesure où elle intervient dans la plupart des opérations de sélection d’observations ou de variables dans une table de données (cf. infra et module 3).

 

 

Cas pratique 2.3 Manipuler des vecteurs logiques

  1. On définit le vecteur f1 <- c(5, 2, -4, 8). Devinez la valeur que renvoient les expressions logiques suivantes, puis vérifiez-les en créant f1 et en les évaluant.

    f1 == 2
f1 != 7
f1 < 6
f1 != 2
!(f1  == 2)
f1 > 3 & f1 != 5
(f1 < 1 | f1 > 3) & f1 != 8
f1 %in% c(-4, 7)

     

  2. On définit le vecteur f2 <- rep(c("a","b","a"), times = 10). Déterminez automatiquement le nombre d’éléments de f2 égaux à "a" ainsi que leur position. Sélectionnez les éléments égaux à "b" et remplacez leur valeur par "c".

     

Manipuler des vecteurs numériques

Plusieurs fonctions sont spécifiquement utilisées pour générer des vecteurs de type numérique :

  • seq() : seq() produit des séquences de nombres. Dans les cas courants, elle peut être remplacée par : :

    # Création d'un vecteur avec la fonction seq()
seq(1, 20)
  ##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20

# Remplacement par `:`
1:20
  ##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20

# Un cas particulier où seq() ne peut pas directement être remplacé
# par `:`
seq(1, 20, by = 2)
  ##  [1]  1  3  5  7  9 11 13 15 17 19

  • les fonctions rXXXX de tirage dans une variable (pseudo-)aléatoire : R dispose d’un large famille de fonctions tirant de façon pseudo-aléatoire selon une certaine loi (spécifiée par les lettres XXXX). Les plus fréquemment utilisées sont runif() (loi uniforme sur [0;1]) et rnorm() (loi normale centrée réduite) :

    # Création d'un vecteur de taille 20 avec la fonction runif()
runif(20)
  ##  [1] 0.26550866 0.37212390 0.57285336 0.90820779 0.20168193 0.89838968
  ##  [7] 0.94467527 0.66079779 0.62911404 0.06178627 0.20597457 0.17655675
  ## [13] 0.68702285 0.38410372 0.76984142 0.49769924 0.71761851 0.99190609
  ## [19] 0.38003518 0.77744522

# Création d'un vecteur de taille 20 avec la fonction rnorm()
rnorm(20)
  ##  [1]  1.51178117  0.38984324 -0.62124058 -2.21469989  1.12493092
  ##  [6] -0.04493361 -0.01619026  0.94383621  0.82122120  0.59390132
  ## [11]  0.91897737  0.78213630  0.07456498 -1.98935170  0.61982575
  ## [16] -0.05612874 -0.15579551 -1.47075238 -0.47815006  0.41794156

 

Les opérations arithmétiques sont appliquées termes à termes sur des vecteurs :

# Génération de deux vecteurs numériques
g1 <- rep(2, times = 10)
g1
  ##  [1] 2 2 2 2 2 2 2 2 2 2
g2 <- 1:10
g2
  ##  [1]  1  2  3  4  5  6  7  8  9 10

# Application d'opérateurs arithmériques
g1 + g2
  ##  [1]  3  4  5  6  7  8  9 10 11 12
g1 - g2
  ##  [1]  1  0 -1 -2 -3 -4 -5 -6 -7 -8
g1 * g2
  ##  [1]  2  4  6  8 10 12 14 16 18 20
g1 / g2
  ##  [1] 2.0000000 1.0000000 0.6666667 0.5000000 0.4000000 0.3333333 0.2857143
  ##  [8] 0.2500000 0.2222222 0.2000000

Quand les vecteurs ne sont pas de même longueur, les éléments du plus petit des deux sont automatiquement répétés. Un avertissement apparaît quand la longueur du plus grand vecteur n’est pas un multiple de la longueur du plus petit.

g1
  ##  [1] 2 2 2 2 2 2 2 2 2 2

# Répétition automatique des éléments du vecteur g3
g3 <- 1:5
g3
  ## [1] 1 2 3 4 5
g1 + g3
  ##  [1] 3 4 5 6 7 3 4 5 6 7

# Répétition automatique des éléments du vecteur g4
g4 <- 1:3
g4
  ## [1] 1 2 3
g1 + g4
  ## Warning in g1 + g4: la taille d'un objet plus long n'est pas multiple de la
  ## taille d'un objet plus court
  ##  [1] 3 4 5 3 4 5 3 4 5 3

Cette réutilisation des éléments du vecteur permet de très simplement effectuer des opérations entre un vecteur de taille quelconque et un scalaire (i.e. un vecteur de taille 1).

# Opération entre un vecteur et un scalaire
g2 * 3
  ##  [1]  3  6  9 12 15 18 21 24 27 30
# La valeur unique du vecteur c(3) est réutilisée
# pour atteindre la longueur de g2 (10).

 

Enfin, de nombreuses fonctions peuvent être appliquées à l’ensemble d’un vecteur de type numérique (cf. tableau).

Code R Résultat
sum(v) Somme du vecteur v
cumsum(v) Somme cumulée du vecteur v
mean(v) Moyenne du vecteur v
quantile(v) Quantiles du vecteur v
summary(v) Moyenne et quantiles du vecteur v
max(v) Valeur maximum du vecteur v
min(v) Valeur minimum du vecteur v
which.min(v) Position du minimum du vecteur v
which.max(v) Position du maximum du vecteur v
round(v, 2) Arrondi du vecteur v à deux décimales

 

Cas pratique 2.4 Manipuler des vecteurs numériques

  1. Utilisez la fonction seq() pour construire la série de nombres de 0 à 10 de 0.5 en 0.5. Comment pourriez-vous y parvenir en utilisant l’opérateur : ?

     

  2. Générez un vecteur h1 de longueur 20 tiré dans une loi uniforme sur [0;1]. Sélectionnez les éléments de h1 dont la position est paire selon deux méthodes, l’une utilisant la fonction seq() et l’autre la fonction rep().

     

  3. En vous inspirant de la méthode utilisant la fonction seq() de la question précédente, construisez la fonction elementsPairs(x) qui retourne automatiquement les éléments du vecteur x dont la position est paire.