R Language
Sous-location

Introduction

Remarques

x <- 1:3
x[NA]
## [1] NA NA NA

x[as.integer(NA)]
## [1] NA

x[c(NA, 1, NA, NA)]
## [1] NA  1 NA NA

(1:3)[10]
## [1] NA
(1:3)[[10]]
## Error in (1:3)[[10]] : subscript out of bounds
as.matrix(1:3)[10]
## [1] NA
as.matrix(1:3)[, 10]
## Error in as.matrix(1:3)[, 10] : subscript out of bounds
list(1, 2, 3)[10]
## [[1]]
## NULL
list(1, 2, 3)[[10]]
## Error in list(1, 2, 3)[[10]] : subscript out of bounds

c(a = 1, b = 2)["c"]
## <NA> 
##   NA 
list(a = 1, b = 2)["c"]
## <NA>
## NULL

Vecteurs atomiques

Les vecteurs atomiques (qui excluent les listes et les expressions, qui sont également des vecteurs) sont des sous-ensembles utilisant l'opérateur [ operator:

# create an example vector
v1 <- c("a", "b", "c", "d")

# select the third element
v1[3]
## [1] "c"

Le [ opérateur peut également prendre un vecteur comme argument. Par exemple, pour sélectionner les premier et troisième éléments:

v1 <- c("a", "b", "c", "d")

v1[c(1, 3)]
## [1] "a" "c"

Parfois, il peut être nécessaire d'omettre une valeur particulière du vecteur. Cela peut être réalisé en utilisant un signe négatif ( - ) avant l’index de cette valeur. Par exemple, pour ne pas omettre la première valeur de v1, utilisez v1[-1] . Cela peut être étendu à plus d'une valeur de manière simple. Par exemple, v1[-c(1,3)] .

> v1[-1]
[1] "b" "c" "d"
> v1[-c(1,3)]
[1] "b" "d"

Dans certains cas, nous aimerions savoir, en particulier, lorsque la longueur du vecteur est grande, un indice d'une valeur particulière, si elle existe:

> v1=="c"
[1] FALSE FALSE  TRUE FALSE
> which(v1=="c")
[1] 3

Si le vecteur atomique a des noms (un attribut names ), il peut être sous-ensemble en utilisant un vecteur de caractères de noms:

v <- 1:3
names(v) <- c("one", "two", "three")

v
##  one   two three 
##    1     2     3 

v["two"]
## two 
##   2

L'opérateur [[ opérateur] peut également être utilisé pour indexer des vecteurs atomiques, avec des différences en ce sens qu'il accepte un vecteur d'indexation d'une longueur de 1 et supprime tous les noms présents:

v[[c(1, 2)]]
## Error in v[[c(1, 2)]] : 
##  attempt to select more than one element in vectorIndex

v[["two"]]
## [1] 2

Les vecteurs peuvent également être un sous-ensemble en utilisant un vecteur logique. Contrairement aux sous - ensembles de avec des vecteurs numériques et de caractères, le vecteur logique utilisé pour sous - ensemble doit être égale à la longueur du vecteur dont les éléments sont extraits, de sorte que si un vecteur logique y est utilisé pour des sous - ensembles x , soit x[y] , si length(y) < length(x) alors y sera recyclé pour correspondre à la length(x) :

v[c(TRUE, FALSE, TRUE)]
##  one three 
##    1     3 

v[c(FALSE, TRUE)]  # recycled to 'c(FALSE, TRUE, FALSE)'
## two 
##   2 

v[TRUE]   # recycled to 'c(TRUE, TRUE, TRUE)'
##  one   two three 
##    1     2     3 

v[FALSE]   # handy to discard elements but save the vector's type and basic structure
## named integer(0)

Des listes

Une liste peut être sous-ensemble avec [ :

l1 <- list(c(1, 2, 3), 'two' = c("a", "b", "c"), list(10, 20))
l1
## [[1]]
## [1] 1 2 3
## 
## $two
## [1] "a" "b" "c"
##
## [[3]]
## [[3]][[1]]
## [1] 10
##
## [[3]][[2]]
## [1] 20

l1[1]
## [[1]]
## [1] 1 2 3

l1['two']
## $two
## [1] "a" "b" "c"

l1[[2]]
## [1] "a" "b" "c"

l1[['two']]
## [1] "a" "b" "c"

Notez que le résultat de l1[2] est toujours une liste, car [ opérateur sélectionne des éléments d'une liste, renvoyant une liste plus petite. L'opérateur [[ opérateur] extrait les éléments de la liste en renvoyant un objet du type de l'élément liste.

Les éléments peuvent être indexés par numéro ou par une chaîne de caractères du nom (s'il existe). Plusieurs éléments peuvent être sélectionnés avec [ en passant un vecteur de nombres ou de chaînes de noms. Indexer avec un vecteur de length > 1 dans [ et [[ renvoie une "liste" avec les éléments spécifiés et un sous-ensemble récursif (si disponible), respectivement :

l1[c(3, 1)]
## [[1]]
## [[1]][[1]]
## [1] 10
## 
## [[1]][[2]]
## [1] 20
## 
## 
## [[2]]
## [1] 1 2 3

Par rapport à:

l1[[c(3, 1)]]
## [1] 10

ce qui équivaut à:

l1[[3]][[1]]
## [1] 10

L'opérateur $ vous permet de sélectionner des éléments de liste uniquement par leur nom, mais contrairement à [ et [[ , ne nécessite pas de guillemets. En tant qu'opérateur infixe, $ ne peut prendre qu'un seul nom:

l1$two
## [1] "a" "b" "c"

De plus, l'opérateur $ permet une correspondance partielle par défaut:

l1$t
## [1] "a" "b" "c"

contrairement à [[ où il faut spécifier si une correspondance partielle est autorisée:

l1[["t"]]
## NULL
l1[["t", exact = FALSE]]
## [1] "a" "b" "c"

Définition des options(warnPartialMatchDollar = TRUE) , un "avertissement" est donné lorsque la correspondance partielle se produit avec $ :

l1$t
## [1] "a" "b" "c"
## Warning message:
## In l1$t : partial match of 't' to 'two'

Matrices

Pour chaque dimension d'un objet, l'opérateur [ prend un argument. Les vecteurs ont une dimension et prennent un argument. Les matrices et les trames de données ont deux dimensions et prennent deux arguments, donnés comme suit: [i, j] où i est la ligne et j la colonne. L'indexation commence à 1.

## a sample matrix
mat <- matrix(1:6, nrow = 2, dimnames = list(c("row1", "row2"), c("col1", "col2", "col3")))

mat
#      col1 col2 col3
# row1    1    3    5
# row2    2    4    6

mat[i,j] est l'élément dans la i - ième rangée, j colonne de -ième de la matrice mat . Par exemple, une valeur i de 2 et une valeur j de 1 donne le nombre dans la deuxième ligne et la première colonne de la matrice. Omettre i ou j renvoie toutes les valeurs de cette dimension.

mat[ , 3]
## row1 row2 
##    5    6 

mat[1, ]
# col1 col2 col3 
#    1    3    5 

Lorsque la matrice a des noms de ligne ou de colonne (non requis), ceux-ci peuvent être utilisés pour sous-définir:

mat[ , 'col1']
# row1 row2 
#    1    2 

Par défaut, le résultat d'un sous-ensemble sera simplifié si possible. Si le sous-ensemble n'a qu'une dimension, comme dans les exemples ci-dessus, le résultat sera un vecteur à une dimension plutôt qu'une matrice à deux dimensions. Cette valeur par défaut peut être remplacée par l'argument drop = FALSE de [ :

## This selects the first row as a vector
class(mat[1, ])
# [1] "integer"

## Whereas this selects the first row as a 1x3 matrix:
class(mat[1, , drop = F])
# [1] "matrix"

Bien sûr, les dimensions ne peuvent pas être supprimées si la sélection elle-même a deux dimensions:

mat[1:2, 2:3]  ## A 2x2 matrix
#      col2 col3
# row1    3    5
# row2    4    6

Sélection des entrées de matrice individuelles par leurs positions

Il est également possible d'utiliser une matrice Nx2 pour sélectionner N éléments individuels dans une matrice (comme le fonctionnement d'un système de coordonnées). Si vous voulez extraire, dans un vecteur, les entrées d'une matrice dans la (1st row, 1st column), (1st row, 3rd column), (2nd row, 3rd column), (2nd row, 1st column) cela peut être fait facilement en créant une matrice d'index avec ces coordonnées et en utilisant cela pour sous-ensemble la matrice:

mat
#      col1 col2 col3
# row1    1    3    5
# row2    2    4    6

ind = rbind(c(1, 1), c(1, 3), c(2, 3), c(2, 1))
ind
#      [,1] [,2]
# [1,]    1    1
# [2,]    1    3
# [3,]    2    3
# [4,]    2    1

mat[ind]
# [1] 1 5 6 2

Dans l'exemple ci-dessus, la 1ère colonne de la matrice ind réfère aux lignes dans mat , la 2ème colonne de l' ind fait référence aux colonnes dans mat .

Trames de données

La sous-division d'une trame de données en une trame de données plus petite peut être accomplie de la même manière que la sous-définition d'une liste.

> df3 <- data.frame(x = 1:3, y = c("a", "b", "c"), stringsAsFactors = FALSE)

> df3
##   x y
## 1 1 a
## 2 2 b
## 3 3 c

> df3[1]   # Subset a variable by number
##   x
## 1 1
## 2 2
## 3 3

> df3["x"]   # Subset a variable by name 
##   x
## 1 1
## 2 2
## 3 3

> is.data.frame(df3[1])
## TRUE

> is.list(df3[1])
## TRUE

La sous-définition d'un dataframe dans un vecteur de colonne peut être réalisée à l'aide de doubles crochets [[]] ou de l'opérateur de signe dollar $.

> df3[[2]]    # Subset a variable by number using [[ ]]
## [1] "a" "b" "c"

> df3[["y"]]  # Subset a variable by name using [[ ]]
## [1] "a" "b" "c"

> df3$x    # Subset a variable by name using $
## [1] 1 2 3

> typeof(df3$x)
## "integer"

> is.vector(df3$x)
## TRUE

La sous-définition d'une donnée en tant que matrice bidimensionnelle peut être réalisée en utilisant les termes i et j .

> df3[1, 2]    # Subset row and column by number
## [1] "a"

> df3[1, "y"]  # Subset row by number and column by name
## [1] "a"

> df3[2, ]     # Subset entire row by number  
##   x y
## 2 2 b

> df3[ , 1]    # Subset all first variables 
## [1] 1 2 3

> df3[ , 1, drop = FALSE]
##   x
## 1 1
## 2 2
## 3 3

Note: La sous-division par j (colonne) seule simplifie le type propre de la variable, mais la sous-définition par i seul renvoie un data.frame , car les différentes variables peuvent avoir différents types et classes. La définition du paramètre drop sur FALSE conserve le bloc de données.

> is.vector(df3[, 2])
## TRUE

> is.data.frame(df3[2, ])
## TRUE

> is.data.frame(df3[, 2, drop = FALSE])
## TRUE

Autres objets

Les opérateurs [ et [[ sont des fonctions primitives génériques. Cela signifie que tout objet dans R (spécifiquement isTRUE(is.object(x)) --ie a un attribut "class" explicite) peut avoir son propre comportement spécifié lors de la création de sous-location; c.-à-d. a ses propres méthodes pour [ et / ou [[ .

Par exemple, c’est le cas avec les objets "data.frame" ( is.object(iris) ) où [.data.frame et [[.data.frame sont des méthodes définies et qui sont [[.data.frame pour présenter à la fois une matrice "" et "liste" comme sous-ensemble. En forçant une erreur lors de la définition d'un "data.frame", nous voyons que, en fait, une fonction [.data.frame été appelée lorsque nous avons utilisé - [ .

iris[invalidArgument, ]
## Error in `[.data.frame`(iris, invalidArgument, ) : 
##   object 'invalidArgument' not found

Sans plus de détails sur le sujet actuel, un exemple [ méthode:

x = structure(1:5, class = "myClass")
x[c(3, 2, 4)]
## [1] 3 2 4
'[.myClass' = function(x, i) cat(sprintf("We'd expect '%s[%s]' to be returned but this a custom `[` method and should have a `?[.myClass` help page for its behaviour\n", deparse(substitute(x)), deparse(substitute(i))))

x[c(3, 2, 4)]
## We'd expect 'x[c(3, 2, 4)]' to be returned but this a custom `[` method and should have a `?[.myClass` help page for its behaviour
## NULL

Nous pouvons surmonter la méthode de répartition [ en utilisant l'équivalent non générique .subset (et .subset2 pour [[ ). Ceci est particulièrement utile et efficace lors de la programmation de nos propres "class" et vous voulez éviter les contournements (comme unclass(x) ) lors du calcul sur notre "class" es efficacement (en évitant l'envoi et la copie de méthodes):

.subset(x, c(3, 2, 4))
## [1] 3 2 4

Indexation vectorielle

Pour cet exemple, nous utiliserons le vecteur:

> x <- 11:20
> x
 [1] 11 12 13 14 15 16 17 18 19 20

Les vecteurs R sont indexés sur 1, par exemple x[1] renverra 11 . On peut également extraire un sous-vecteur de x en passant un vecteur d'indices à l'opérateur bracket:

> x[c(2,4,6)]
[1] 12 14 16

Si on passe un vecteur d'indices négatifs, R retournera un sous-vecteur avec les indices spécifiés exclus:

> x[c(-1,-3)]
[1] 12 14 15 16 17 18 19 20

On peut aussi passer un vecteur booléen à l’opérateur bracket, auquel cas il retourne un sous-vecteur correspondant aux coordonnées où le vecteur d’indexation est TRUE :

> x[c(rep(TRUE,5),rep(FALSE,5))]
[1] 11 12 13 14 15 16

Si le vecteur d'indexation est plus court que la longueur du tableau, il sera répété, comme dans:

> x[c(TRUE,FALSE)]
[1] 11 13 15 17 19
> x[c(TRUE,FALSE,FALSE)]
[1] 11 14 17 20

Opérations matricielles élémentaires

Soit A et B deux matrices de même dimension. Les opérateurs + , - , / , * , ^ utilisés avec des matrices de même dimension effectuent les opérations requises sur les éléments correspondants des matrices et renvoient une nouvelle matrice de même dimension. Ces opérations sont généralement appelées opérations par éléments.

Pour "vrai" matrice de multiplication, comme vu dans l'algèbre linéaire , utilisez %*% . Par exemple, la multiplication de A avec B est: A %*% B Les exigences dimensionnelles sont que le ncol() de A soit le même que nrow() de B

Quelques fonctions utilisées avec les matrices