1.1.1 Exemple de vecteur

Le vecteur est l’objet le plus simple. Voici un exemple de vecteur :

vec

## [1] 3.5 7.8 9.9 5.7

str(vec)

##  num [1:4] 3.5 7.8 9.9 5.7

Il pourrait être représenté comme suit : ou encore à la verticale :

Il n’a qu’une dimension et ses éléments (représentés par les cercles bleus) sont des données toutes du même type.

1.1.2 Exemple de matrice

La matrice est une généralisation à 2 dimensions du vecteur. Voici un exemple de matrice :

mat

##       [,1]  [,2]  [,3]
## [1,]  TRUE FALSE FALSE
## [2,]  TRUE  TRUE FALSE
## [3,] FALSE  TRUE  TRUE
## [4,]  TRUE  TRUE  TRUE

str(mat)

##  logi [1:4, 1:3] TRUE TRUE FALSE TRUE FALSE TRUE ...

Elle pourrait être représentée comme suit :

Comme pour un vecteur, tous ses éléments doivent être du même type.

1.1.3 Exemple d’array

Le dernier objet atomique est l’array, qui généralise le vecteur et la matrice à un nombre quelconque de dimensions. Voici un exemple d’array à 3 dimensions :

arr

## , , 1
## 
##      [,1] [,2] [,3]
## [1,]    2    3    6
## [2,]    4    1    3
## 
## , , 2
## 
##      [,1] [,2] [,3]
## [1,]    9    6    8
## [2,]    2    3    0
## 
## , , 3
## 
##      [,1] [,2] [,3]
## [1,]    5    2    7
## [2,]    3    8    1
## 
## , , 4
## 
##      [,1] [,2] [,3]
## [1,]    2    5    8
## [2,]    6    3    5

str(arr)

##  num [1:2, 1:3, 1:4] 2 4 3 1 6 3 9 2 6 3 ...

Il pourrait être représenté comme suit :

1.1.4 Exemple de liste

Une liste est pour sa part un objet récursif : elle contient d’autres objets, de types quelconques. Voici un exemple de liste :

liste

## [[1]]
##      [,1] [,2]
## [1,]    2    3
## [2,]    4    1
## 
## [[2]]
## [[2]][[1]]
## [1] 2 3
## 
## [[2]][[2]]
## [1] 8
## 
## 
## [[3]]
##   V1 V2
## 1  2  1
## 2  4  5
## 3  3  3

str(liste)

## List of 3
##  $ : num [1:2, 1:2] 2 4 3 1
##  $ :List of 2
##   ..$ : num [1:2] 2 3
##   ..$ : num 8
##  $ :'data.frame':    3 obs. of  2 variables:
##   ..$ V1: num [1:3] 2 4 3
##   ..$ V2: num [1:3] 1 5 3

Elle pourrait être représentée comme suit :

Les éléments d’une liste (séparés par une ligne pointillée dans la figure) ne sont pas de simples données comme dans un vecteur. Il s’agit d’autres objets. Dans cet exemple, la liste contient même une autre liste (deuxième élément).

1.1.5 Exemple de data frame

Le data frame est en quelque sorte un type particulier de liste, mais il partage aussi des caractéristiques avec les matrices, étant réputé posséder 2 dimensions (des lignes et des colonnes). Ses éléments sont des objets contraints d’être de dimensions concordantes. Dans la grande majorité des cas, les éléments sont des vecteurs ou des facteurs de même longueur, formant les colonnes du data frame. Voici un exemple de data frame.

dat

##    V1         V2    V3
## 1 3.5      matin  TRUE
## 2 7.8 après-midi  TRUE
## 3 9.9       soir FALSE
## 4 5.7       nuit  TRUE

str(dat)

## 'data.frame':    4 obs. of  3 variables:
##  $ V1: num  3.5 7.8 9.9 5.7
##  $ V2: chr  "matin" "après-midi" "soir" "nuit"
##  $ V3: logi  TRUE TRUE FALSE TRUE

Il pourrait être illustré comme suit :

La taille de la première dimension d’un data frame typique est la longueur commune des objets qu’il contient (4 dans l’exemple) et la taille de sa deuxième dimension est le nombre d’objets qu’il contient (dans l’exemple, le data frame contient 3 vecteurs).

Les data frames ont été créés spécialement pour l’analyse statistique de données. Ils représentent des tableaux de données dans lesquels les lignes sont des observations et les colonnes des variables (des variables au sens statistique et non au sens informatique). Le data frame fait donc penser à une matrice. Cependant, contrairement à une matrice, les données dans les différentes colonnes d’un data frame n’ont pas à être du même type.

1.1.6 Exemple de facteur

Un autre type d’objet propre à la statistique a été créé en R : le facteur. Ce type d’objet est utilisé pour stocker les valeurs observées d’une variable catégorique.

fac

## [1] 5 2 5 5
## Levels: 2 5

str(fac)

##  Factor w/ 2 levels "2","5": 2 1 2 2

Il s’agit d’une généralisation du vecteur.

1.2.1 Données réelles

Une donnée réelle est un nombre réel, par exemple

re <- 5.8
re

## [1] 5.8

Le terme informatique en anglais pour une donnée réelle est « double ».

typeof(re)

## [1] "double"

Par contre, en R, la distinction entre les réels et les entiers est peu utilisée. R simplifie les choses et dit parfois d’une donnée réelle qu’il s’agit d’une donnée numérique.

str(re)

##  num 5.8

1.2.2 Données entières

Une donnée entière est un nombre entier (en anglais integer), donc sans partie décimale.

en <- 1L
en

## [1] 1

Dans cet exemple, le caractère L après le nombre indique à R que nous désirons qu’il le considère comme un entier.

str(en)

##  int 1

typeof(en)

## [1] "integer"

is.numeric(en)

## [1] TRUE

is.integer(en)

## [1] TRUE

is.double(en)

## [1] FALSE

Sans ce caractère L, la majorité des fonctions en R traite par défaut les nombres comme des réels.

un <- 1
un

## [1] 1

str(un)

##  num 1

typeof(un)

## [1] "double"

is.numeric(un)

## [1] TRUE

is.integer(un)

## [1] FALSE

is.double(un)

## [1] TRUE

1.2.3 Données caractères

Une donnée caractère est une chaîne de caractères.

ca <- "Hello world!"
ca

## [1] "Hello world!"

str(ca)

##  chr "Hello world!"

typeof(ca)

## [1] "character"

Ce sont les guillemets (simples ou doubles) qui indiquent à R qu’il s’agit d’une donnée de type caractère.

str("1")

##  chr "1"

1.2.4 Données logiques

Une donnée logique est simplement TRUE ou FALSE.

lo <- TRUE
lo

## [1] TRUE

str(lo)

##  logi TRUE

typeof(lo)

## [1] "logical"

Attention : "TRUE" est une chaîne de caractères et non une donnée logique, à cause des guillemets bien sûr.

str("TRUE")

##  chr "TRUE"

1.2.5 Données manquantes

Peu importe le type de données, une donnée manquante est représentée en R par la constante NA (pour « Not Available »).

NA

## [1] NA

Ce n’est pas la même chose que NaN qui signifie plutôt « Not a Number ».

0/0

## [1] NaN

L’existence d’une constante pour représenter les données manquantes est une autre particularité du langage R spécifique à l’analyse de données.

1.3.1 Attributs des objets

Les structures de données R peuvent posséder des attributs, qui servent à contenir des informations supplémentaires concernant les données stockées dans l’objet. Ces informations supplémentaires sont parfois appelées métadonnées.

Par exemple, une matrice ou un array possède toujours un attribut portant le nom dim contenant les tailles de toutes les dimensions de l’objet.

attributes(mat)

## $dim
## [1] 4 3

Le fonction attributes retourne une liste contenant tous les attributs d’un objet, nommés. La fonction attr permet d’accéder à la valeur d’un attribut particulier, identifié par son nom.

attr(mat, "dim")

## [1] 4 3

Pour certains attributs communs, tels que dim, il existe même des fonctions spécifiques pour obtenir leur valeur. Par exemple :

• dim retourne l’attribut dim d’un objet,

dim(mat)

## [1] 4 3

• nrow retourne la taille de la première dimension d’un objet,

nrow(mat)

## [1] 4

• ncol retourne la taille de la deuxième dimension d’un objet,

ncol(mat)

## [1] 3

Certains types d’objets, tels que le vecteur, ne possèdent pas d’attributs par défaut.

attributes(vec)

## NULL

Il est cependant toujours possible d’ajouter des attributs à un objet, portant le nom de notre choix. Les fonctions qui retournent les valeurs d’attributs peuvent aussi servir à initialiser ou remplacer les valeurs des attributs. Pour ce faire, il suffit d’accompagner la commande d’extraction de l’attribut d’un opérateur d’assignation (<-) suivi de la valeur souhaitée, comme dans l’exemple ci-dessus.

attr(vec, "description") <- "exemple de vecteur"
str(vec)

##  num [1:4] 3.5 7.8 9.9 5.7
##  - attr(*, "description")= chr "exemple de vecteur"

Pour retirer un attribut, il faut lui assigner la valeur spéciale NULL.

attr(vec, "description") <- NULL
str(vec)

##  num [1:4] 3.5 7.8 9.9 5.7

1.4.1 Opérateurs d’indiçage

Il y a trois opérateurs d’indiçage d’éléments d’un objet R : [, [[ et $. Ces opérateurs permettent d’extraire des éléments s’ils sont utilisés seuls, et ils permettent de remplacer des éléments s’ils sont utilisés en combinaison avec une assignation.

vec

## [1] 3.5 7.8 9.9 5.7

vec[c(2, 4)]

## [1] 7.8 5.7

str(liste)

## List of 3
##  $ : num [1:2, 1:2] 2 4 3 1
##  $ :List of 2
##   ..$ : num [1:2] 2 3
##   ..$ : num 8
##  $ :'data.frame':    3 obs. of  2 variables:
##   ..$ V1: num [1:3] 2 4 3
##   ..$ V2: num [1:3] 1 5 3

extrait_1_liste <- liste[1]
str(extrait_1_liste)

## List of 1
##  $ : num [1:2, 1:2] 2 4 3 1

extrait_2_liste <- liste[[1]]
str(extrait_2_liste)

##  num [1:2, 1:2] 2 4 3 1

mat

##       [,1]  [,2]  [,3]
## [1,]  TRUE FALSE FALSE
## [2,]  TRUE  TRUE FALSE
## [3,] FALSE  TRUE  TRUE
## [4,]  TRUE  TRUE  TRUE

attributes(mat)

## $dim
## [1] 4 3

extrait_mat <- mat[[1, 3]]
extrait_mat

## [1] FALSE

attributes(extrait_mat)

## NULL

arr[2, 1, 3]

## [1] 3

str(dat)

## 'data.frame':    4 obs. of  3 variables:
##  $ V1: num  3.5 7.8 9.9 5.7
##  $ V2: chr  "matin" "après-midi" "soir" "nuit"
##  $ V3: logi  TRUE TRUE FALSE TRUE

attr(dat, "names")

## [1] "V1" "V2" "V3"

dat$V2

## [1] "matin"      "après-midi" "soir"       "nuit"

dat[[2, "V2"]]

## [1] "après-midi"

vec

## [1] 3.5 7.8 9.9 5.7

vec[[2.6]]

## [1] 7.8

vec[c(1, 3)]

## [1] 3.5 9.9

vec[-c(2, 4)]

## [1] 3.5 9.9

dat[c("V1", "V2")]

##    V1         V2
## 1 3.5      matin
## 2 7.8 après-midi
## 3 9.9       soir
## 4 5.7       nuit

vec[c(TRUE, FALSE, TRUE, FALSE)]

## [1] 3.5 9.9

dat[2, ]

##    V1         V2   V3
## 2 7.8 après-midi TRUE

vec[c(1, 1, 1, 2, 2, 3, 3, 3, 3)]

## [1] 3.5 3.5 3.5 7.8 7.8 9.9 9.9 9.9 9.9

dat[, c("V2", "V2")]

##           V2       V2.1
## 1      matin      matin
## 2 après-midi après-midi
## 3       soir       soir
## 4       nuit       nuit

str(dat)

## 'data.frame':    4 obs. of  3 variables:
##  $ V1: num  3.5 7.8 9.9 5.7
##  $ V2: chr  "matin" "après-midi" "soir" "nuit"
##  $ V3: logi  TRUE TRUE FALSE TRUE

str(dat[c(1, 3), 2])

##  chr [1:2] "matin" "soir"

str(dat[2, ])

## 'data.frame':    1 obs. of  3 variables:
##  $ V1: num 7.8
##  $ V2: chr "après-midi"
##  $ V3: logi TRUE

str(arr[, 2, 4])

##  num [1:2] 5 3

str(arr[, 2, 4, drop = FALSE])

##  num [1:2, 1, 1] 5 3

str(dat[c(1, 3), 2, drop = FALSE])

## 'data.frame':    2 obs. of  1 variable:
##  $ V2: chr  "matin" "soir"

1.4.2 Fonctions d’extraction

En plus des opérateurs d’indiçage, certaines fonctions permettent aussi d’extraire des éléments, notamment les fonctions head, tail et subset.

head(vec, n = 2)

## [1] 3.5 7.8

head(dat, n = 3)

##    V1         V2    V3
## 1 3.5      matin  TRUE
## 2 7.8 après-midi  TRUE
## 3 9.9       soir FALSE

tail(vec, n = 3)

## [1] 7.8 9.9 5.7

tail(dat, n = 1)

##    V1   V2   V3
## 4 5.7 nuit TRUE

subset(vec, subset = c(FALSE, TRUE, TRUE, TRUE))

## [1] 7.8 9.9 5.7

subset(mat, subset = c(FALSE, TRUE, FALSE, TRUE), select = 1)

##      [,1]
## [1,] TRUE
## [2,] TRUE

subset(dat, subset = c(TRUE, FALSE, FALSE, TRUE), select = -V3)

##    V1    V2
## 1 3.5 matin
## 4 5.7  nuit

subset(dat, subset = V1 < 6, select = -V3)

##    V1    V2
## 1 3.5 matin
## 4 5.7  nuit

2.2.1 Fonction c

La fonction c permet de créer un objet de type vecteur comme suit.

de <- c(2, 3, 4, 1, 2, 3, 5, 6, 5, 4)
de

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

La lettre c a été choisie comme nom pour cette fonction, car celle-ci sert à combiner (an anglais combine) ou concaténer des éléments dans un vecteur.

Bien que les nombres dans ce vecteur soient des entiers, ils ont été stockés sous le format réel. C’est ce que fait par défaut la fonction c.

typeof(de)

## [1] "double"

2.2.2 Fonction vector

Une autre fonction permet de créer des vecteurs : la fonction vector. Elle initialise des vecteurs, qui sont remplis par la suite. Avec vector, il faut identifier la longueur du vecteur créé et le type des données qu’il doit contenir, comme dans cet exemple.

ve <- vector(mode = "numeric", length = 3)
ve

## [1] 0 0 0

L’utilisateur ne contrôle pas les données initiales placées dans un vecteur créé avec vector. Il doit plutôt les modifier a posteriori.

ve[1] <- 5
ve

## [1] 5 0 0

Cette fonction sera utile pour initialiser des vecteurs servant à contenir des valeurs créées itérativement dans une boucle.

2.2.3 Fonction as.vector

La fonction as.vector sert quant à elle à transformer un objet en vecteur. Tous les attributs de l’objet sont retirés lors de l’opération. Voici un exemple.

as.vector(mat)

##  [1]  TRUE  TRUE FALSE  TRUE FALSE  TRUE  TRUE  TRUE FALSE FALSE  TRUE  TRUE

2.2.4 Fonction rep

Si un vecteur doit contenir des données qui se répètent, la fonction rep est utile. Ainsi, plutôt que de créer, par exemple, un vecteur contenant cinq 1 suivis de cinq 2 avec la fonction c comme suit

c(1, 1, 1, 1, 1, 2, 2, 2, 2, 2)

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

il est plus succinct de le créer en utilisant conjointement les fonctions rep et c comme suit

rep(c(1, 2), each = 5)

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

L’utilisation de l’argument each de rep produit des répétitions consécutives élément par élément. Si la fonction rep est appelée sans attribuer explicitement les valeurs fournies en entrée à des arguments, alors la deuxième valeur fournie sera assignée à l’argument times et non each. Dans ce cas, un unique entier positif fourni en deuxième position provoque la répétition du vecteur entier fourni en première position un certain nombre de fois, comme dans cet exemple.

rep(c(1, 2), 5)

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

Le nombre de répétitions pourrait aussi varier d’un élément à l’autre en fournissant à l’argument times un vecteur de nombre de répétitions aussi long que le vecteur fourni comme premier argument.

rep(c(1, 2), times = c(4, 3))

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

Il est même possible d’exploiter simultanément les arguments each et times.

rep(c(1, 2), each = 3, times = 2)

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

2.2.5 Création de séquences avec : ou seq

Pour créer un vecteur contenant une séquence régulière de nombres, l’opérateur : ou la fonction seq sont très utiles.

Avec l’opérateur :, les séquences créées comportent des nombres séparés par des bonds de 1, par exemple

6:-2

## [1]  6  5  4  3  2  1  0 -1 -2

0.2:4.2

## [1] 0.2 1.2 2.2 3.2 4.2

Le nombre placé devant l’opérateur indique le début de la séquence et le nombre placé après indique la fin.

La fonction seq généralise : en permettant des bonds de longueur autre que 1. Voici des exemples.

seq(from = 0, to = 9, by = 3)

## [1] 0 3 6 9

seq(from = 0, to = 9, length.out = 4)

## [1] 0 3 6 9

2.2.6 Vecteur de longueur 1

Si un objet R est créé en lui assignant une seule donnée, cet objet est considéré comme un vecteur de longueur 1.

une_donnee <- "a"
str(une_donnee)

##  chr "a"

is.vector(une_donnee)

## [1] TRUE

length(une_donnee)

## [1] 1

Ainsi, l’appel à la fonction c n’est pas nécessaire pour créer un vecteur contenant un seul élément.

2.3.1 Fonction c

En plus de servir à créer de nouveaux vecteurs, c permet de concaténer des vecteurs (autant que souhaité), comme dans cet exemple.

c(de, ve, 6:-2)

##  [1]  2  3  4  1  2  3  5  6  5  4  5  0  0  6  5  4  3  2  1  0 -1 -2

2.3.2 Fonction append

La fonction append fait aussi de la concaténation de vecteurs. Contrairement à c, elle est limitée à la fusion de deux vecteurs. Cependant, elle permet d’insérer le deuxième vecteur n’importe où dans le premier vecteur, pas nécessairement à la fin. Voici un exemple.

append(de, ve, after = 3)

##  [1] 2 3 4 5 0 0 1 2 3 5 6 5 4

2.5.1 Un seul élément

Un élément d’un vecteur peut être extrait en l’identifiant par sa position comme suit.

de[1]

## l1 
##  2

de[[1]]

## [1] 2

Remarquons que l’opérateur [ préserve le nom de l’élément (l’attribut names), alors que l’opérateur [[ ne le conserve pas, ce qui concorde avec les propriétés de ces opérateurs vues précédemment.

Un élément peut aussi être extrait en l’identifiant par son nom.

de["l1"]   

## l1 
##  2

Mais l’opérateur d’extraction $ ne fonctionne pas avec un objet atomique tel qu’un vecteur.

de$l1

## Error in de$l1: $ operator is invalid for atomic vectors

2.5.2 Plusieurs éléments

Pour extraire plusieurs éléments simultanément, il faut utiliser un autre vecteur afin d’identifier les éléments à extraire. Voici quelques exemples selon le type du vecteur d’identifiants.

posObs <- c(3, 6, 7)
de[posObs]
# ou directement

de[c(3, 6, 7)]

## l3 l6 l7 
##  4  3  5

de[[c(3, 6, 7)]] 

## Error in de[[c(3, 6, 7)]]: attempt to select more than one element in vectorIndex

de[1:5]

## l1 l2 l3 l4 l5 
##  2  3  4  1  2

de[seq(from = 2, to = 10, by = 2)]

##  l2  l4  l6  l8 l10 
##   3   1   3   6   4

de[c("l3","l6","l7")]

## l3 l6 l7 
##  4  3  5

index.logic <- c(TRUE, rep(FALSE, 8), TRUE)
index.logic

##  [1]  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE  TRUE

de[index.logic]

##  l1 l10 
##   2   4

2.5.3 Extraction par exclusion

Une autre méthode d’extraction d’éléments d’un vecteur consiste à identifier des éléments à exclure. Pour ce faire, il faut utiliser un indicateur numérique de position négatif. Voici un exemple qui permet d’extraire tous les éléments de de à l’exception des deux premiers.

de[-(1:2)]          

##  l3  l4  l5  l6  l7  l8  l9 l10 
##   4   1   2   3   5   6   5   4

Il est aussi possible de tronquer les derniers éléments en modifiant la longueur du vecteur.

length(de) <- 5
de

## l1 l2 l3 l4 l5 
##  2  3  4  1  2

Si sa longueur initiale est réassignée au vecteur, que se passe-t-il?

length(de) <- 10
de

## l1 l2 l3 l4 l5                
##  2  3  4  1  2 NA NA NA NA NA

R ne sachant pas quelles données mettre dans les positions supplémentaires, il introduit sa constante pour les données manquantes NA.

2.6.1 Fonctions paste et paste0

Une fonction très utile pour créer des vecteurs de chaînes de caractères est la fonction paste. Comme son nom l’indique, elle permet de coller ensemble des chaînes de caractères. Par exemple, l’appel à la fonction paste suivant combine "Hello" et "world" dans une seule chaîne de caractères.

paste("Hello", "world", sep = " ")

## [1] "Hello world"

L’argument sep = " " indique à paste de séparer les chaînes de caractères par un espace lors de la combinaison.

Il existe une fonction raccourcie pour l’utilisation de la fonction paste avec sep = "" (aucun caractère pour séparer les chaînes de caractères) : la fonction paste0.

paste0("Hello", "world")

## [1] "Helloworld"

En comparaison, la combinaison de ces deux chaînes de caractères avec la fonction c aurait créé un vecteur de longueur 2.

tentative <- c("Hello", "world")
str(tentative)

##  chr [1:2] "Hello" "world"

Les fonctions paste et paste0 travaillent, tout comme nchar, de façon vectorielle. Si elles reçoivent en entrée des vecteurs, elles les combinent élément par élément et retournent un vecteur de même longueur que ceux fournis.

paste(LETTERS, letters, sep = "-")

##  [1] "A-a" "B-b" "C-c" "D-d" "E-e" "F-f" "G-g" "H-h" "I-i" "J-j" "K-k" "L-l" "M-m"
## [14] "N-n" "O-o" "P-p" "Q-q" "R-r" "S-s" "T-t" "U-u" "V-v" "W-w" "X-x" "Y-y" "Z-z"

Les fonctions paste et paste0 permettent aussi de combiner dans une seule chaîne de caractères les chaînes de caractères comprises dans un vecteur grâce à leur argument collapse.

paste(LETTERS, collapse = ",")

## [1] "A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z"

3.2.1 Fonction matrix

La fonction matrix permet de créer un objet de type matrice à partir d’un vecteur contenant les éléments à mettre dans la matrice.

mat <- matrix(
  c(TRUE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE), 
  ncol = 3, nrow = 4, byrow = FALSE
)

L’objet obtenu est celui que nous venons d’observer.

La fonction matrix attend comme premier argument un vecteur d’éléments, ensuite un nombre de colonnes (argument ncol) et/ou un nombre de lignes (argument nrow). L’argument byrow permet de spécifier si les éléments du vecteur fourni comme premier argument doivent être placés dans la matrice ligne par ligne ou colonne par colonne (ce qui est fait par défaut).

3.2.2 Fonction as.matrix

Pour tenter de convertir en matrice un objet d’un autre type, la fonction as.matrix est utile. Par exemple, convertissons en matrice la data frame dat créé précédemment.

as.matrix(dat)

##      V1    V2           V3     
## [1,] "3.5" "matin"      NA     
## [2,] "7.8" "après-midi" "FALSE"
## [3,] "9.9" "soir"       "FALSE"
## [4,] "5.7" "nuit"       "TRUE"

Étant donné qu’une matrice est un objet atomique, tous ses éléments doivent être des données du même type. Ici, toutes les données ont donc été converties en chaînes de caractères. Nous reviendrons plus loin sur les conversions de types de données.

3.2.3 Fonctions rbind et cbind

Nous allons maintenant étendre notre exemple de données provenant de 10 lancers d’un dé à des données provenant de 10 lancers de 2 dés. Supposons donc qu’en plus des résultats du dé 1 (2, 3, 4, 1, 2, 3, 5, 6, 5, 4), nous avons les résultats du dé 2 : 1, 4, 2, 3, 5, 4, 6, 2, 5, 3.

Les fonctions rbind et cbind permettent de créer des matrices à partir d’une série de vecteurs de même longueur, comme dans cet exemple.

de_1 <- c(2, 3, 4, 1, 2, 3, 5, 6, 5, 4)
de_2 <- c(1, 4, 2, 3, 5, 4, 6, 2, 5, 3)

des_lignes <- rbind(de_1, de_2)
des_lignes

##      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
## de_1    2    3    4    1    2    3    5    6    5     4
## de_2    1    4    2    3    5    4    6    2    5     3

Le r dans le nom rbind indique que la fonction combine des vecteurs par rows en anglais ou lignes en français, dans le sens que chacun des vecteurs devient une ligne de la matrice produite.

Pour les données de lancers de dés, il serait plus approprié de combiner les vecteurs par colonnes, afin que les lignes de la matrice obtenue représentent des observations et les colonnes des variables. Nous utiliserons donc plutôt cbind (c pour columns en anglais ou colonnes en français)

des <- cbind(de_1, de_2)
des

##       de_1 de_2
##  [1,]    2    1
##  [2,]    3    4
##  [3,]    4    2
##  [4,]    1    3
##  [5,]    2    5
##  [6,]    3    4
##  [7,]    5    6
##  [8,]    6    2
##  [9,]    5    5
## [10,]    4    3

3.3.1 Fonctions rbind et cbind

Les fonctions rbind et cbind acceptent aussi en entrée des matrices, qu’elles concatènent, comme dans cet exemple.

rbind(des_lignes, des_lignes)

##      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
## de_1    2    3    4    1    2    3    5    6    5     4
## de_2    1    4    2    3    5    4    6    2    5     3
## de_1    2    3    4    1    2    3    5    6    5     4
## de_2    1    4    2    3    5    4    6    2    5     3

Des matrices concaténées en lignes doivent avoir le même nombre de colonnes et des matrices concaténées en colonnes doivent avoir le même nombre de lignes.

3.5.1 Un seul élément

Un élément est identifié par sa position en ligne et en colonne.

des[9, 2]

## [1] 5

En réalité, cette extraction est équivalente à

des[19]

## [1] 5

parce qu’en mémoire, une matrice est stockée comme un vecteur, en mettant bout à bout ses colonnes.

3.5.2 Plusieurs éléments

Il est possible d’extraire des lignes complètes,

des[2:4, ]

##    de1 de2
## l2   3   4
## l3   4   2
## l4   1   3

ou encore des colonnes.

des[, -2]

##  l1  l2  l3  l4  l5  l6  l7  l8  l9 l10 
##   2   3   4   1   2   3   5   6   5   4

Étant donné qu’il ne restait qu’une seule colonne, R a par défaut transformé la matrice en vecteur. Rappelons que pour empêcher cette simplification d’être effectuée, il faut utiliser l’argument drop = FALSE.

des[, -2, drop = FALSE]

##     de1
## l1    2
## l2    3
## l3    4
## l4    1
## l5    2
## l6    3
## l7    5
## l8    6
## l9    5
## l10   4

Les lignes ou les colonnes peuvent aussi être identifiées par leur nom dans l’extraction.

des[, "de1"]

##  l1  l2  l3  l4  l5  l6  l7  l8  l9 l10 
##   2   3   4   1   2   3   5   6   5   4

4.2.1 Fonction array

La fonction array sert à créer des arrays. Il faut lui fournir le vecteur des éléments à stocker dans l’array et les tailles des dimensions de celui-ci, comme dans cet exemple.

collection <- array(1:12, dim = c(2, 2, 3))
collection

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

Les arrays sont utiles, notamment, pour ranger dans une même structure plusieurs matrices de même taille.

4.2.2 Fonction as.array

Il est aussi possible de tenter de créer un array à partir d’un objet R quelconque avec as.array. Par exemple, les vecteurs ne sont pas considérés comme des types particuliers d’arrays.

vec

## [1] 2.0 4.9 2.0 0.2

is.array(vec)

## [1] FALSE

Cependant, un vecteur peut être transformé en array comme suit.

array_vec <- as.array(vec)
array_vec

## [1] 2.0 4.9 2.0 0.2

is.array(array_vec)

## [1] TRUE

Même si les affichages des objets vec et array_vec sont identiques, les deux objets ne sont pas du même type.

5.2.1 Fonction list

Nous venons tout juste d’utiliser la fonction de création de listes nommée list pour créer la valeur à assigner à l’attribut dimnames de l’array collection.

noms <- list(
  paste0("ligne", 1:2), 
  paste0("colonne", 1:2),
  paste0("matrice", 1:3)
)
noms

## [[1]]
## [1] "ligne1" "ligne2"
## 
## [[2]]
## [1] "colonne1" "colonne2"
## 
## [[3]]
## [1] "matrice1" "matrice2" "matrice3"

Pour utiliser cette fonction, il suffit de lui donner en entrée tous les objets à inclure dans la liste, dans l’ordre souhaité.

5.2.2 Fonction as.list

La fonction as.list permet quant à elle de transformer n’importe quel objet R en liste. Par exemple, en appliquant la fonction as.list sur un vecteur, elle crée une liste pour laquelle chaque élément du vecteur est devenu un vecteur de longueur 1 en élément de la liste.

as.list(vec)

## [[1]]
## [1] 2
## 
## [[2]]
## [1] 4.9
## 
## [[3]]
## [1] 2
## 
## [[4]]
## [1] 0.2

Pour obtenir plutôt une liste de longueur 1 comportant le vecteur comme seul élément, il aurait plutôt fallu utiliser la fonction list comme suit.

list(vec)

## [[1]]
## [1] 2.0 4.9 2.0 0.2

5.2.3 Fonction vector

La fonction vector permet aussi de créer des listes (rappelons qu’une liste est considérée être un vecteur récursif).

ex <- vector(mode = "list", length = 2)
ex

## [[1]]
## NULL
## 
## [[2]]
## NULL

Une liste créée avec la fonction vector, comme dans l’exemple ci-dessus, est initialement vide. Elle est remplie en assignant des objets à ses éléments.

ex[[1]] <- matrix(1:8, nrow = 2, ncol = 4, byrow = TRUE)
ex

## [[1]]
##      [,1] [,2] [,3] [,4]
## [1,]    1    2    3    4
## [2,]    5    6    7    8
## 
## [[2]]
## NULL

5.3.1 Fonction c

Les éléments de plusieurs listes peuvent être concaténés avec la fonction c comme suit.

combine <- c(noms, ex)
combine

## [[1]]
## [1] "ligne1" "ligne2"
## 
## [[2]]
## [1] "colonne1" "colonne2"
## 
## [[3]]
## [1] "matrice1" "matrice2" "matrice3"
## 
## [[4]]
##      [,1] [,2] [,3] [,4]
## [1,]    1    2    3    4
## [2,]    5    6    7    8
## 
## [[5]]
## NULL

Ainsi, la fonction c n’est pas seulement utile avec les vecteurs atomiques, elle l’est aussi avec les vecteurs récursifs.

5.5.1 Un seul élément

Voici quelques exemples :

noms[1]          

## $lignes
## [1] "ligne1" "ligne2"

noms[[1]]

## [1] "ligne1" "ligne2"

Nous avons déjà vu un exemple similaire. Il est important de remarquer ici que noms[1] est une liste de longueur 1, alors que noms[[1]] est l’objet en position 1 dans la liste noms, soit ici un vecteur. L’opérateur [[ sort l’élément extrait de la structure de l’objet d’origine si celui-ci est récursif.

D’ailleurs, puisqu’une liste est un objet récursif, l’opérateur $ peut être utilisé pour extraire un de ses éléments. Cependant, l’opérateur $ est seulement utilisable lorsque les éléments de la liste sont nommés. Il faut inscrire le nom de l’élément à extraire après l’opérateur, comme dans cet exemple.

noms$lignes

## [1] "ligne1" "ligne2"

Cette dernière opération est équivalente à la suivante.

noms[["lignes"]]

## [1] "ligne1" "ligne2"

Contrairement à l’opérateur [[, l’opérateur $ n’exige pas que le nom de l’élément à extraire soit encadré de guillemets, sauf s’il comporte un ou des espaces.

Il est parfois utile d’utiliser des opérateurs d’extraction à la chaîne. Par exemple, la commande suivante extrait l’élément lignes dans le sous-objet liste de la liste exemple.

exemple$liste$lignes

## [1] "ligne1" "ligne2"

5.5.2 Plusieurs éléments

Pour extraire d’un coup plusieurs éléments d’une liste, il faut employer l’opérateur [. Voici un exemple.

noms[1:2]

## $lignes
## [1] "ligne1" "ligne2"
## 
## $colonnes
## [1] "colonne1" "colonne2"

5.5.3 Extraction par exclusion

La façon la plus simple de retirer un élément d’une liste est d’assigner la valeur NULL à l’élément en question.

noms$lignes <- NULL
noms

## $colonnes
## [1] "colonne1" "colonne2"
## 
## $matrices
## [1] "matrice1" "matrice2" "matrice3"

6.1.1 Définitions

• Données : En statistique, des données sont des valeurs numériques (des nombres) ou alphanumériques (des chaînes de caractères) représentant les observations de certaines variables sur certains individus. Elles se présentent souvent sous la forme de jeux de données, c’est-à-dire de tableaux de valeurs, stockées dans un fichier informatique.

• Population : La population est l’ensemble de référence sur lequel porte l’étude dans le cadre de laquelle les données ont été recueillies.

• Individu ou unité statistique : Un individu est un élément de la population. L’ensemble des individus constitue la population. Chaque observation est associée à un individu.

• Échantillon : L’échantillon est un sous-groupe de la population, composé des individus pour lesquels des observations ont été recueillies. Si des mesures ont été prises pour tous les individus de la population, il s’agit d’un recensement.

• Variable : Le terme variable désigne la représentation d’une caractéristique des individus. Ainsi, une variable n’est pas la caractéristique elle-même, mais plutôt une mesure de cette caractéristique.

• Observation : Une observation est l’ensemble des valeurs obtenues en mesurant des variables sur un individu de la population.

6.1.2 Représentation en R

Dans un logiciel informatique, une façon courante de stocker un jeu de données est d’utiliser une structure de données à deux dimensions et d’y placer les observations en lignes et les variables en colonnes. En R, si toutes les variables sont du même type, il est possible d’utiliser une matrice. Cependant, lorsque les valeurs observées des différentes variables ne sont pas du même type, par exemple si certaines sont numériques et d’autres caractères, il est impossible de regrouper ces variables au sein d’une seule matrice. Le data frame a été créé pour stocker un tel jeu de données.

Observons de nouveau la structure du data frame illustré en introduction.

dat

##    V1         V2    V3
## 1 3.5      matin    NA
## 2 7.8 après-midi FALSE
## 3 9.9       soir FALSE
## 4 5.7       nuit  TRUE

Il s’agit d’un exemple de jeu de données sous la forme « observations en lignes, variables en colonnes ». La sortie de la fonction str appliquée à un data frame énonce clairement cette interprétation du data frame.

str(dat)

## 'data.frame':    4 obs. of  3 variables:
##  $ V1: num  3.5 7.8 9.9 5.7
##  $ V2: chr  "matin" "après-midi" "soir" "nuit"
##  $ V3: logi  NA FALSE FALSE TRUE

Ici, la mention « 4 obs. of 3 variables » signifie que les lignes doivent être vues comme des observations et les colonnes comme des variables.

6.3.1 Fonction data.frame

Ajoutons à la matrice des créée précédemment, qui contient des données fictives de lancers de deux dés, une colonne contenant le nom de la personne qui a lancé le dé. Le résultat ne peut pas être une matrice si nous voulons conserver des données de type numérique dans les deux premières colonnes et caractère dans la troisième colonne. Il faut donc créer un data frame, ce que réalise la commande suivante.

des_plus <- data.frame(des, lanceur = rep(c("Luc", "Kim"), each = 5))
des_plus

##     de1 de2 lanceur
## l1    2   1     Luc
## l2    3   4     Luc
## l3    4   2     Luc
## l4    1   3     Luc
## l5    2   5     Luc
## l6    3   4     Kim
## l7    5   6     Kim
## l8    6   2     Kim
## l9    5   5     Kim
## l10   4   3     Kim

La principale fonction de création d’un data frame se nomme data.frame. Il faut lui donner en entrée tous les vecteurs et/ou facteurs que le data frame doit contenir, dans l’ordre désiré. La fonction data.frame accepte aussi en entrée des matrices, comme dans l’exemple précédent, auquel cas les colonnes des matrices en entrée deviennent des colonnes dans le data frame en sortie.

Regardons la structure interne du data frame que nous venons de créer.

str(des_plus)

## 'data.frame':    10 obs. of  3 variables:
##  $ de1    : num  2 3 4 1 2 3 5 6 5 4
##  $ de2    : num  1 4 2 3 5 4 6 2 5 3
##  $ lanceur: chr  "Luc" "Luc" "Luc" "Luc" ...

Les trois colonnes de des_plus sont des vecteurs.

des_plus_fac <- data.frame(
  des,
  lanceur = rep(c("Luc", "Kim"), each = 5), 
  stringsAsFactors = TRUE
)
str(des_plus_fac)

## 'data.frame':    10 obs. of  3 variables:
##  $ de1    : num  2 3 4 1 2 3 5 6 5 4
##  $ de2    : num  1 4 2 3 5 4 6 2 5 3
##  $ lanceur: Factor w/ 2 levels "Kim","Luc": 2 2 2 2 2 1 1 1 1 1

options(stringsAsFactors = TRUE)

6.3.2 Fonction as.data.frame

Pour transformer, si possible, un objet R en data frame, il faut utiliser la fonction as.data.frame. Par exemple, transformons la matrice mat en data frame.

df_mat <- as.data.frame(mat)
df_mat

##      V1    V2    V3
## 1  TRUE FALSE FALSE
## 2  TRUE  TRUE FALSE
## 3 FALSE  TRUE  TRUE
## 4  TRUE  TRUE  TRUE

6.4.1 Fonction data.frame

En plus de servir à créer des data frames, la fonction data.frame permet d’en combiner par concaténation de colonnes.

jour <- data.frame(jour = rep(1, 10))
str(jour)

## 'data.frame':    10 obs. of  1 variable:
##  $ jour: num  1 1 1 1 1 1 1 1 1 1

autre <- data.frame(des_plus, jour)
str(autre)

## 'data.frame':    10 obs. of  4 variables:
##  $ de1    : num  2 3 4 1 2 3 5 6 5 4
##  $ de2    : num  1 4 2 3 5 4 6 2 5 3
##  $ lanceur: chr  "Luc" "Luc" "Luc" "Luc" ...
##  $ jour   : num  1 1 1 1 1 1 1 1 1 1

6.4.2 Fonctions rbind et cbind

Une concaténation de data frames peut aussi s’effectuer avec les fonctions rbind et cbind. Comme avec une matrice, rbind effectue une concaténation en lignes et cbind en colonnes.

La fonction rbind permet donc de mettre en commun les observations de plusieurs data frames, comme dans cet exemple.

des_plus_exp_2 <- data.frame(de1 = c(3, 5), de2 = c(4, 2), lanceur = "Paul")
des_plus_exp_3 <- data.frame(de1 = c(6, 1), de2 = c(2, 5), lanceur = "Paul")
rbind(des_plus, des_plus_exp_2, des_plus_exp_3)

##     de1 de2 lanceur
## l1    2   1     Luc
## l2    3   4     Luc
## l3    4   2     Luc
## l4    1   3     Luc
## l5    2   5     Luc
## l6    3   4     Kim
## l7    5   6     Kim
## l8    6   2     Kim
## l9    5   5     Kim
## l10   4   3     Kim
## 1     3   4    Paul
## 2     5   2    Paul
## 11    6   2    Paul
## 21    1   5    Paul

Pour que la concaténation fonctionne, les noms des variables (colonnes) dans les data frames doivent concorder.

Une concaténation de data frames avec cbind est quant à elle similaire à une concaténation avec data.frame : des variables sont rassemblées dans un seul data frame.

cbind(des_plus, jour)

##     de1 de2 lanceur jour
## l1    2   1     Luc    1
## l2    3   4     Luc    1
## l3    4   2     Luc    1
## l4    1   3     Luc    1
## l5    2   5     Luc    1
## l6    3   4     Kim    1
## l7    5   6     Kim    1
## l8    6   2     Kim    1
## l9    5   5     Kim    1
## l10   4   3     Kim    1

Cette fois, les noms des observations (lignes) n’ont pas besoin de concorder entre les data frames, mais les nombres d’observations doivent être égaux.

6.6.1 En traitant le data frame comme une liste

Comme il a déjà été mentionné à quelques reprises maintenant, le data frame est un objet récursif et ses éléments sont ses colonnes. Alors, extraire des éléments d’un data frame signifie extraire des colonnes.

Tous les opérateurs d’indiçage introduits plus tôt fonctionnent avec le data frame, comme le démontre ces exemples.

des_plus[c("de1", "de2")]

##     de1 de2
## l1    2   1
## l2    3   4
## l3    4   2
## l4    1   3
## l5    2   5
## l6    3   4
## l7    5   6
## l8    6   2
## l9    5   5
## l10   4   3

des_plus[[1]]

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

des_plus$de1

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

6.6.2 En traitant le data frame comme une matrice

Il est aussi possible d’exploiter les deux dimensions du data frame et d’extraire des éléments de ses colonnes. Pour ce faire, il faut simplement traiter le data frame comme une matrice et fournir deux arguments à l’opérateur d’indiçage [ ou [[ : le premier pour identifier des lignes, le deuxième pour identifier des colonnes. Voici quelques exemples.

des_plus[, "de1"]

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

des_plus[c(rep(FALSE, 6), rep(TRUE, 3), FALSE), 2:3]

##    de2 lanceur
## l7   6     Kim
## l8   2     Kim
## l9   5     Kim

des_plus[[1, 1]]

## [1] 2

6.6.3 Extraction par exclusion

Comme pour une liste, assigner la valeur NULL à un élément d’un data frame l’efface de celui-ci, comme dans cet exemple.

autre$jour <- NULL
autre

##     de1 de2 lanceur
## l1    2   1     Luc
## l2    3   4     Luc
## l3    4   2     Luc
## l4    1   3     Luc
## l5    2   5     Luc
## l6    3   4     Kim
## l7    5   6     Kim
## l8    6   2     Kim
## l9    5   5     Kim
## l10   4   3     Kim

6.7.1 Tibbles

Les packages du tidyverse utilisent des tibbles en remplacement des data frames. Le tidyverse est une collection de packages dit être spécialisés en « science des données ». Plusieurs des développeurs de ces packages sont affiliés à RStudio. Cette collection comprend notamment le très populaire package ggplot2 et d’autres packages développés par Hadley Wickham.

Voyons un exemple de tibble.

library(tibble)
des_plus_tibble <- tibble(
  de1 = c(2, 3, 4, 1, 2, 3, 5, 6, 5, 4),
  de2 = c(1, 4, 2, 3, 5, 4, 6, 2, 5, 3), 
  lanceur = rep(c("Luc", "Kim"), each = 5)
)
des_plus_tibble

## # A tibble: 10 x 3
##      de1   de2 lanceur
##    <dbl> <dbl> <chr>  
##  1     2     1 Luc    
##  2     3     4 Luc    
##  3     4     2 Luc    
##  4     1     3 Luc    
##  5     2     5 Luc    
##  6     3     4 Kim    
##  7     5     6 Kim    
##  8     6     2 Kim    
##  9     5     5 Kim    
## 10     4     3 Kim

str(des_plus_tibble)

## tibble[,3] [10 x 3] (S3: tbl_df/tbl/data.frame)
##  $ de1    : num [1:10] 2 3 4 1 2 3 5 6 5 4
##  $ de2    : num [1:10] 1 4 2 3 5 4 6 2 5 3
##  $ lanceur: chr [1:10] "Luc" "Luc" "Luc" "Luc" ...

Un tibble se manipule comme un data frame, mais il possède les distinctions suivantes :

• l’affichage (print) a été repensé : pas plus de 10 lignes affichées par défaut, abréviations des types des colonnes affichées;
• l’extraction d’éléments d’un tibble avec l’opérateur [ retourne toujours un autre tibble, sa sortie n’est jamais simplifiée (pas d’argument drop);
• la règle de recyclage lors de la création d’un tibble s’applique seulement pour des vecteurs de longueur unitaire;
• certaines opérations d’extraction sont plus rapides.

6.7.2 Data tables

Le data table est une extension du data frame développée dans le but de rendre plus rapides et conviviales les manipulations de jeu de données en R.

Voyons un exemple de data table.

library(data.table)
des_plus_data_table <- data.table(
  de1 = c(2, 3, 4, 1, 2, 3, 5, 6, 5, 4),
  de2 = c(1, 4, 2, 3, 5, 4, 6, 2, 5, 3),
  lanceur = rep(c("Luc", "Kim"), each = 5)
)
des_plus_data_table

##     de1 de2 lanceur
##  1:   2   1     Luc
##  2:   3   4     Luc
##  3:   4   2     Luc
##  4:   1   3     Luc
##  5:   2   5     Luc
##  6:   3   4     Kim
##  7:   5   6     Kim
##  8:   6   2     Kim
##  9:   5   5     Kim
## 10:   4   3     Kim

str(des_plus_data_table)

## Classes 'data.table' and 'data.frame':   10 obs. of  3 variables:
##  $ de1    : num  2 3 4 1 2 3 5 6 5 4
##  $ de2    : num  1 4 2 3 5 4 6 2 5 3
##  $ lanceur: chr  "Luc" "Luc" "Luc" "Luc" ...
##  - attr(*, ".internal.selfref")=<externalptr>

La force du data table est la rapidité d’exécution des manipulations et la possibilité d’en faire beaucoup plus avec l’opérateur [ comparativement au data frame. Pour illustrer ce dernier point, voici un exemple de calcul de statistiques descriptives avec l’opérateur [.

des_plus_data_table[
  j = .(moy_de1 = mean(de1), moy_de2 = mean(de2)), 
  by = lanceur
]

##    lanceur moy_de1 moy_de2
## 1:     Luc     2.4       3
## 2:     Kim     4.6       4

Les deux premiers arguments (i et j) de l’opérateur [ acceptent plus de valeurs pour un data table que pour un data frame. Dans le cas d’un data frame, ces arguments servent uniquement à identifier des lignes et des colonnes. Pour un data table, ils ont plus d’utilités et servent notamment à demander le calcul de statistiques sur une partie des données. Dans l’exemple ci-dessus, le calcul de moyennes sur les variables de1 et de2 est demandé. La syntaxe pour demander de tels calculs est simple.

De plus, l’opérateur [ pour le data table possède plusieurs autres arguments, dont l’argument by. Dans la commande précédente, l’argument by a permis de demander un calcul distinct selon la valeur d’une variable.

Dans les valeurs fournies aux arguments de l’opérateur [ pour le data table, il est possible de référer aux colonnes du data table par leurs noms sans encadrer ces noms de guillemets.

Nous verrons dans un prochain cours comment produire avec les fonctionnalités de base de R les mêmes calculs que ceux de l’exemple exploité ici.

7.2.1 Fonctions factor et as.factor

Pour créer un facteur de toutes pièces, il faut faire appel à la fonction factor ou as.factor.

reponses <- factor(rep(c("roche", "papier", "ciseau"), times = 3))
reponses

## [1] roche  papier ciseau roche  papier ciseau roche  papier ciseau
## Levels: ciseau papier roche

str(reponses)

##  Factor w/ 3 levels "ciseau","papier",..: 3 2 1 3 2 1 3 2 1

Les niveaux du facteur sont extraits automatiquement par la fonction factor et placés en ordre alphanumérique. Pour contrôler l’ordre des facteurs, il faut spécifier cet ordre dans la commande de création du facteur avec l’argument levels.

reponses <- factor(
  rep(c("roche", "papier", "ciseau"), times = 3),
  levels = c("roche", "papier", "ciseau")
)
reponses

## [1] roche  papier ciseau roche  papier ciseau roche  papier ciseau
## Levels: roche papier ciseau

str(reponses)

##  Factor w/ 3 levels "roche","papier",..: 1 2 3 1 2 3 1 2 3

Il est utile de contrôler l’ordre des niveaux d’un facteur, car dans des sorties ou graphiques produits avec un facteur, l’ordre de ses niveaux est respecté.

La fonction as.factor agit comme la fonction factor, mais elle ne possède pas d’arguments supplémentaires au vecteur à transformer.

7.3.1 Fonction levels

Pour modifier les libellés des niveaux, il suffit de combiner l’utilisation de la fonction levels à une assignation de données comme suit.

levels(reponses) <- c("pomme", "orange", "poire")
reponses

## [1] pomme  orange poire  pomme  orange poire  pomme  orange poire 
## Levels: pomme orange poire

str(reponses)

##  Factor w/ 3 levels "pomme","orange",..: 1 2 3 1 2 3 1 2 3

7.3.2 Réordonnancement des niveaux

Il est toujours possible de modifier l’ordre des niveaux d’un facteur après sa création. Pour ce faire, il faut de nouveau faire appel à la fonction factor, en lui donnant en entrée le facteur et les niveaux dans l’ordre désiré. En réassignant le résultat au nom du facteur, il en ressort modifié, comme dans l’exemple suivant.

reponses <- factor(reponses, levels = c("poire", "pomme", "orange"))
reponses

## [1] pomme  orange poire  pomme  orange poire  pomme  orange poire 
## Levels: poire pomme orange

str(reponses)

##  Factor w/ 3 levels "poire","pomme",..: 2 3 1 2 3 1 2 3 1