Structures de données en R

• réel • entier • caractère • logique.

1.2.1 Données réelles

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

6

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"

7

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

8

[1] NA

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

0/0

[1] NaN

1.3 Obtention d’informations sur les objets

Pour avoir accès aux informations relatives à un objet, il existe une série de fonctions utiles, par exemple :

• type de l’objet : is.(vector/matrix/array/list/data.frame/factor/. . . ) ; • attributs de l’objet : attributes (tous les attributs), attr (un seul attribut) et les fonctions raccourcies

names, dimnames, colnames, rownames, dim, nrow, ncol, class, levels, etc.

• type des éléments : typeof, mode, is.(numeric/character/logical/. . . ) ; • nombre d’éléments : length.

Le tableau suivant résume ce que retournent les fonctions typeof, mode et class pour les différents types d’objets.

Le type simplifié des données retourné par mode est explicité dans le tableau suivant, présentant ce que retournent les fonctions typeof et mode pour les différents types de données.

Ainsi, typeof distingue les données réelles et entières, alors que mode les qualifie toutes de numériques.

1.4 Attributs des objets

Les structures de données R peuvent posséder des attributs, qui servent à contenir des informations sup- plé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

9

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.5 Extraction d’éléments

L’extraction d’éléments dans un jeu de données est une opération très usuelle au cours d’une analyse de données. Par exemple, il arrive souvent de vouloir faire un certain calcul seulement sur une partie des données plutôt que sur le jeu de données entier. Il faut alors prélever les données concernées.

1.5.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.

10

1.5.1.1 [ versus [[ et $ L’opérateur [ effectue de l’extraction d’éléments (potentiellement plus d’un) en préservant presque toujours la structure de l’objet (l’objet produit en résultat de l’extraction est, sauf exception, du même type que l’objet d’origine et conserve la majorité de ses attributs).

Les opérateurs [[ et $ permettent de référer à un seul élément et ils simplifient l’objet lors d’une extraction (retirent des attributs pour les objets atomiques et sortent de l’objet principal pour un objet récursif).

Voici des exemples.

• extraction de deux éléments d’un objet atomique avec [

vec

[1] 3.5 7.8 9.9 5.7

vec[c(2, 4)]

[1] 7.8 5.7

Dans cet exemple, la fonction c sert à créer un vecteur contenant les positions des éléments à extraire.

• extraction d’un élément d’un objet récursif avec [, en préservant la structure de l’objet d’origine

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': ## ##

..$ V1: num [1:3] 2 4 3 ..$ V2: num [1:3] 1 5 3

3 obs. of

2 variables:

extrait_1_liste <- liste[1] str(extrait_1_liste)

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

Ici, le résultat est encore une liste, mais contenant un seul élément.

• extraction d’un élément d’un objet récursif avec [[, avec perte de la structure de l’objet d’origine

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

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

Ici, le résultat est un vecteur, celui qui était stocké en position 1 dans l’objet liste.

• extraction d’un élément d’un objet atomique avec perte d’un attribut

mat

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

[,1] [,2]

11

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

attributes(mat)

$dim ## [1] 4 3

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

[1] FALSE

attributes(extrait_mat)

NULL

1.5.1.2 Extractions d’éléments dans un objet à plusieurs dimensions

Les opérateurs [ et [[ prennent en entrée un argument pour chacune des dimensions d’un objet, comme illustré dans l’exemple précédent. Voici un autre exemple, avec l’array à 3 dimensions arr. La commande suivante extrait un seul élément de arr, dont la position est identifiée par les valeurs fournies en entrée aux arguments de [.

arr[2, 1, 3]

[1] 3

1.5.1.3 Spécificité de l’opérateur $

L’opérateur $ fonctionne seulement avec les objets récursifs (une liste ou un data frame) dont les éléments sont nommés. Il doit être suivi du nom de l’élément à extraire. Ce nom n’a pas besoin d’être encadré de guillemets s’il ne contient pas d’espaces.

Prenons par exemple le data frame dat observé précédemment. Nous ne l’avions peut-être pas remarqué, mais les éléments de dat sont nommés.

str(dat)

4 obs. of 3 variables:

'data.frame': ## $ 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"

Alors il est possible d’extraire disons la deuxième colonne du data frame par la commande suivante.

dat$V2

[1] "matin"

"après-midi" "soir"

"nuit"

1.5.1.4

Identification de l’élément à extraire avec l’opérateur [[

Les arguments fournis à [[ pour identifier l’unique élément à extraire peuvent recevoir des valeurs de type :

• numérique : un nombre spécifiant la position de l’élément selon la dimension, ou • caractère (dans le cas d’éléments nommés) : le nom de l’élément selon la dimension.

12

Par exemple, le 2ième élément de la colonne nommée "V2" du data frame dat peut être extrait ainsi.

dat[[2, "V2"]]

[1] "après-midi"

Si une valeur numérique non entière est fournie en argument, elle est tronquée vers 0, comme dans cet exemple. vec

[1] 3.5 7.8 9.9 5.7

vec[[2.6]]

[1] 7.8

1.5.1.5

Identification du ou des éléments à extraire avec l’opérateur [

Étant donné que l’opérateur [ permet l’extraction de plusieurs éléments, il accepte une plus grande variété de types de valeurs. Voici les valeurs qu’il accepte en argument pour identifier les éléments à extraire :

• un ou des nombres entiers positifs, dont les valeurs sont entre 1 et la taille de la dimension concernée :

positions des éléments à sélectionner ;

• un ou des nombres entiers négatifs, dont les valeurs sont entre 1 et la taille de la dimension concernée :

-1 × positions des éléments à exclure ;

• une ou des chaînes de caractères (possible seulement si les éléments sont nommés) :

noms des éléments à sélectionner ;

• vecteur de logiques (doit être de la même longueur que la dimension concernée) :

TRUE pour les éléments à sélectionner, FALSE pour ceux à exclure ;

• rien : utile par exemple pour extraire tous les éléments selon une dimension d’un objet à plusieurs

dimensions.

Voici quelques exemples :

• extraction d’éléments identifiés par leur position,

vec[c(1, 3)]

[1] 3.5 9.9

• extraction d’éléments par identification d’éléments à exclure,

vec[-c(2, 4)]

[1] 3.5 9.9

• extraction d’éléments identifiés par leurs noms,

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

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

• extraction d’éléments identifiés par un vecteur logique,

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

[1] 3.5 9.9

• extraction de tous les éléments selon une des dimensions.

13

dat[2, ]

V1

V3 ## 2 7.8 après-midi TRUE

V2

Lors de l’indiçage à l’aide de valeurs numériques positives ou de chaînes de caractères, les valeurs peuvent se répéter. Dans ce cas, les éléments sont extraits autant de fois que la fréquence de leur identifiant, comme dans ces exemples.

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.1 V2 ## ## 1 matin matin ## 2 après-midi après-midi soir soir ## 3 nuit nuit ## 4

Les sections suivantes proposent plusieurs autres exemples d’extraction de données.

1.5.1.6 Argument drop de l’opérateur [

L’opérateur [ préserve la structure des objets, sauf dans quelques cas particuliers. Un de ces cas est l’extraction d’une colonne, complète ou partielle, d’un data frame. Le résultat de l’extraction est alors un vecteur ou un facteur, et non un autre data frame, comme dans cet exemple.

str(dat)

4 obs. of 3 variables:

'data.frame': ## $ 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"

Il n’a pas ce comportement lors de l’extraction d’une ligne d’un data frame, car les éléments sur une même ligne ne sont pas nécessairement du même type.

str(dat[2, ])

1 obs. of 3 variables:

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

Cependant, avec les objets atomiques, l’opérateur [ cherche toujours par défaut à réduire le plus possible le nombre de dimensions de l’objet retourné. Ainsi, l’extraction suivante retourne un vecteur, alors que l’objet d’origine est un array à trois dimensions.

str(arr[, 2, 4])

num [1:2] 5 3

14

Il est possible de contrôler ce comportement grâce à l’argument drop. Donner la valeur FALSE à cet argument empêche [ de réduire le nombre de dimensions du résultat retourné. Ainsi, la commande suivante retourne un array,

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

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

et la suivante un data frame.

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

'data.frame': ## $ V2: chr "matin" "soir"

2 obs. of 1 variable:

1.5.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.

1.5.2.1 Fonction head

La fonction head extrait les premiers éléments d’un vecteur, d’une liste ou d’un facteur et les premières lignes d’une matrice ou d’un data frame. L’argument n permet de spécifier combien d’éléments ou de lignes extraire. Voici un exemple.

head(vec, n = 2)

[1] 3.5 7.8

head(dat, n = 3)

V2

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

1.5.2.2 Fonction tail

À l’inverse, la fonction tail extrait les derniers éléments ou les dernières lignes.

tail(vec, n = 3)

[1] 7.8 9.9 5.7

tail(dat, n = 1)

V1

V3 ## 4 5.7 nuit TRUE

V2

1.5.2.3 Fonction subset

La fonction subset est quant à elle une option de rechange à l’opérateur [ utilisé avec des identifiants logiques. Elle fonctionne avec les vecteurs.

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

[1] 7.8 9.9 5.7

Cependant, elle est surtout utile avec des matrices et des data frames. Avec un objet à deux dimensions, l’argument subset de la fonction du même nom sert à identifier les lignes à extraire et l’argument select à identifier les colonnes.

15

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

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

Lorsque le premier argument fourni en entrée à la fonction subset est un data frame, il est possible de référer aux colonnes de celui-ci directement par leurs noms dans les arguments subset et select. Il est aussi possible de retirer une colonne en utilisant l’opérateur - avant le nom de la colonne à retirer dans la valeur fournie à l’argument select.

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

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

Note : Typiquement, le vecteur de TRUE et FALSE servant à identifier les lignes à sélectionner est créé par une condition logique, comme dans l’exemple suivant.

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

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

Nous verrons plus tard comment utiliser des opérateurs logiques pour créer des vecteurs d’identifiants logiques. Avec ces opérateurs, il sera facile d’extraire par exemple toutes les valeurs tombant dans un certain ensemble de valeurs acceptées.

1.6 Remplacement d’éléments

En combinant une extraction à un opérateur d’assignation (<-) suivi de nouvelles valeurs, des éléments d’un objet peuvent être remplacés. Voici un exemple. vec

[1] 3.5 7.8 9.9 5.7

vec[3] <- 6.1 vec

[1] 3.5 7.8 6.1 5.7

Il est tout à fait possible de remplacer plus d’un élément à la fois, comme dans l’exemple suivant. dat

V2

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

dat[c(1, 2), 3] <- c(NA, FALSE) dat

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

V2 matin

16

4 5.7

nuit TRUE

Il est parfois utile d’exploiter la règle de recyclage lors du remplacement d’éléments dans un objet R. Cette règle permet des opérations sur des vecteurs qui ne sont pas de même longueur. Les éléments du vecteur le plus court sont répétés de façon à ce que ce vecteur devienne de la même longueur que le vecteur le plus long.

Par exemple, si une seule valeur de remplacement est fournie, mais que plusieurs éléments sont identifiés, alors ceux-ci seront tous remplacés par l’unique valeur fournie.

vec[1:3] <- 0.5 vec

[1] 0.5 0.5 0.5 5.7

Cela fonctionne aussi lorsque le vecteur le plus court est de longueur supérieure à 1. Dans l’exemple suivant, 4 valeurs sont identifiées à remplacer, mais 2 valeurs de remplacement sont fournies. Le vecteur de valeurs de remplacement est donc dupliqué.

vec[1:4] <- c(0.1, 0.2) vec

[1] 0.1 0.2 0.1 0.2

Si la longueur du vecteur le plus long n’est pas un multiple de la longueur du vecteur le plus court, ça fonctionne encore, mais un avertissement est émis, comme dans cet exemple.

vec[1:3] <- c(2.0, 4.9)

Warning in vec[1:3] <- c(2, 4.9): number of items to replace is not a multiple of ## replacement length vec

[1] 2.0 4.9 2.0 0.2

Mentionnons que la fonction edit permet également de modifier des éléments dans une matrice ou un data frame à l’intérieur d’un chiffrier ouvert dans une fenêtre externe. Aussi, la fonction replace permet de remplacer des éléments dans un vecteur. Ces fonctions ne sont pas illustrées ici.

2 Vecteurs

Un vecteur est un simple objet atomique à une dimension. Toutes les données qu’il contient doivent être du même type.

2.1 Obtention d’informations

Observons le vecteur vec illustré précédemment en utilisant des fonctions déjà vues jusqu’à maintenant.

Il est possible d’afficher les données que vec contient, vec

[1] 2.0 4.9 2.0 0.2

ou encore un résumé de ces données avec la fonction summary.

summary(vec)

##

Min. 1st Qu. Median 2.000 1.550

0.200

Mean 3rd Qu. 2.725

2.275

Max. 4.900

17

Des informations sur la structure de l’objet sont affichées avec la fonction str.

str(vec)

num [1:4] 2 4.9 2 0.2

L’objet possède une certaine longueur, retournée par la fonction length.

length(vec)

[1] 4

Son contenu est d’un certain type, retourné par la fonction typeof.

typeof(vec)

[1] "double"

2.2 Création

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.

18

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 0.2:4.2

5 4 3

2

1 0 -1 -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.

19

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 Concaténation de vecteurs

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.4 Extraction d’éléments

2.4.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]]

20

[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.4.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.

2.4.2.1

Identifiants numériques

Dans cet exemple, les éléments à extraire sont identifiés par des nombres représentant leurs positions.

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

de[c(3, 6, 7)]

l3 l6 l7 ## 4 3 5

Note : L’opérateur [[ sert à extraire uniquement un élément. Donc la commande suivante ne fonctionne pas.

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

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

Exemples de moyens rapides de créer des vecteurs de positions avec l’opérateur : et la fonction seq :

• extraction des 5 premières observations (équivalent à head(de, n = 5)) :

de[1:5]

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

• extraction des observations en positions paires.

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

l2 l4 l6 l8 l10 4 ##

1

3

6

3

2.4.2.2

Identifiants caractères

Dans cet exemple, des chaînes de caractères contenant les noms des éléments à extraire sont utilisées.

21

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

l3 l6 l7 ## 4 3 5

2.4.2.3

Identifiants logiques

Voici un exemple de vecteur logique permettant d’identifier des éléments à extraire. Ce vecteur servira à extraire des éléments du vecteur de. Il doit donc être de longueur 10, tout comme de. Le vecteur contient la valeur TRUE aux positions des éléments à extraire et FALSE aux positions des éléments à exclure.

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

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

TRUE

Ce vecteur est utile pour extraire le premier et le dernier élément de de

de[index.logic]

l1