R Language
Subconjunto
Buscar..
Introducción
Dado un objeto R, podemos requerir un análisis por separado para una o más partes de los datos contenidos en él. El proceso de obtención de estas partes de los datos de un objeto dado se llama subsetting .
Observaciones
Valores faltantes:
Los valores faltantes ( NA s) utilizados en la subcontratación con [ return NA desde un índice de NA
elige un elemento desconocido y devuelve NA en el elemento correspondiente.
El tipo de NA "predeterminado" es "lógico" ( typeof(NA) ), lo que significa que, como cualquier vector "lógico" utilizado en la subconjunto, se reciclará para que coincida con la longitud del objeto subcontratado. Entonces x[NA] es equivalente a x[as.logical(NA)] que es equivalente a x[rep_len(as.logical(NA), length(x))] y, en consecuencia, devuelve un valor faltante ( NA ) para cada elemento de x . Como ejemplo:
x <- 1:3
x[NA]
## [1] NA NA NA
Mientras se indexa con "numérico" / "entero", NA elige un solo elemento de NA (para cada NA en el índice):
x[as.integer(NA)]
## [1] NA
x[c(NA, 1, NA, NA)]
## [1] NA 1 NA NA
Subconjunto fuera de límites:
El [ operador, con un argumento pasado, permite índices que son > length(x) y devuelve NA para vectores atómicos o NULL para vectores genéricos. Por el contrario, con [[ y cuando [ se pasan más argumentos (es decir, subconjunto de objetos fuera de límites con length(dim(x)) > 2 ) se devuelve un error:
(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
El comportamiento es el mismo cuando se subcontrata con vectores de "caracteres", que no coinciden en el atributo "nombres" del objeto, también:
c(a = 1, b = 2)["c"]
## <NA>
## NA
list(a = 1, b = 2)["c"]
## <NA>
## NULL
Temas de ayuda:
Ver ?Extract para más información.
Vectores atómicos
Los vectores atómicos (que excluyen listas y expresiones, que también son vectores) son subconjuntos usando el operador [ operador:
# create an example vector
v1 <- c("a", "b", "c", "d")
# select the third element
v1[3]
## [1] "c"
El [ operador también puede tomar un vector como argumento. Por ejemplo, para seleccionar el primer y tercer elemento:
v1 <- c("a", "b", "c", "d")
v1[c(1, 3)]
## [1] "a" "c"
Algunas veces es posible que debamos omitir un valor particular del vector. Esto se puede lograr usando un signo negativo ( - ) antes del índice de ese valor. Por ejemplo, para omitir omitir el primer valor de v1, use v1[-1] . Esto se puede extender a más de un valor de manera directa. Por ejemplo, v1[-c(1,3)] .
> v1[-1]
[1] "b" "c" "d"
> v1[-c(1,3)]
[1] "b" "d"
En algunas ocasiones, nos gustaría saber, especialmente, cuando la longitud del vector es grande, el índice de un valor particular, si existe:
> v1=="c"
[1] FALSE FALSE TRUE FALSE
> which(v1=="c")
[1] 3
Si el vector atómico tiene nombres (un atributo de names ), puede ser subconjunto utilizando un vector de caracteres de nombres:
v <- 1:3
names(v) <- c("one", "two", "three")
v
## one two three
## 1 2 3
v["two"]
## two
## 2
El operador [[ también se puede usar para indexar vectores atómicos, con diferencias en que acepta un vector de indexación con una longitud de uno y elimina cualquier nombre presente:
v[[c(1, 2)]]
## Error in v[[c(1, 2)]] :
## attempt to select more than one element in vectorIndex
v[["two"]]
## [1] 2
Los vectores también pueden ser subconjuntos usando un vector lógico. En contraste con el subconjunto con vectores numéricos y de caracteres, el vector lógico usado para subconjuntar tiene que ser igual a la longitud del vector cuyos elementos se extraen, por lo que si un vector lógico y se usa para subcontratar x , es decir, x[y] , si length(y) < length(x) luego y se reciclará para que coincida con 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)
Liza
Una lista se puede subcontratar con [ :
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"
Tenga en cuenta que el resultado de l1[2] sigue siendo una lista, ya que el operador [ selecciona los elementos de una lista y devuelve una lista más pequeña. El [[ operador extrae los elementos de la lista, devolviendo un objeto del tipo del elemento de la lista.
Los elementos se pueden indexar por número o una cadena de caracteres del nombre (si existe). Se pueden seleccionar varios elementos con [ pasando un vector de números o cadenas de nombres. La indexación con un vector de length > 1 en [ y [[ devuelve una "lista" con los elementos especificados y un subconjunto recursivo (si está disponible), respectivamente :
l1[c(3, 1)]
## [[1]]
## [[1]][[1]]
## [1] 10
##
## [[1]][[2]]
## [1] 20
##
##
## [[2]]
## [1] 1 2 3
Comparado con:
l1[[c(3, 1)]]
## [1] 10
que es equivalente a:
l1[[3]][[1]]
## [1] 10
El operador $ permite seleccionar elementos de la lista únicamente por nombre, pero a diferencia de [ y [[ , no requiere comillas). Como operador de infijo, $ solo puede tomar un único nombre:
l1$two
## [1] "a" "b" "c"
Además, el operador $ permite una coincidencia parcial de forma predeterminada:
l1$t
## [1] "a" "b" "c"
en contraste con [[ donde debe especificarse si se permite una coincidencia parcial:
l1[["t"]]
## NULL
l1[["t", exact = FALSE]]
## [1] "a" "b" "c"
Configurando options(warnPartialMatchDollar = TRUE) , se da una "advertencia" cuando ocurre una coincidencia parcial con $ :
l1$t
## [1] "a" "b" "c"
## Warning message:
## In l1$t : partial match of 't' to 'two'
Matrices
Para cada dimensión de un objeto, el [ operador toma un argumento. Los vectores tienen una dimensión y toman un argumento. Las matrices y los marcos de datos tienen dos dimensiones y toman dos argumentos, dados como [i, j] donde i es la fila y j es la columna. La indexación comienza en 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] es el elemento en la i -fila, j -th columna de la matriz mat . Por ejemplo, un valor i de 2 y un valor j de 1 da el número en la segunda fila y la primera columna de la matriz. Omitir i o j devuelve todos los valores en esa dimensión.
mat[ , 3]
## row1 row2
## 5 6
mat[1, ]
# col1 col2 col3
# 1 3 5
Cuando la matriz tiene nombres de fila o columna (no es obligatorio), estos se pueden usar para subcontratar:
mat[ , 'col1']
# row1 row2
# 1 2
De forma predeterminada, el resultado de un subconjunto se simplificará si es posible. Si el subconjunto solo tiene una dimensión, como en los ejemplos anteriores, el resultado será un vector unidimensional en lugar de una matriz bidimensional. Este valor predeterminado se puede anular con el argumento drop = FALSE para [ :
## 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"
Por supuesto, las dimensiones no se pueden eliminar si la selección en sí tiene dos dimensiones:
mat[1:2, 2:3] ## A 2x2 matrix
# col2 col3
# row1 3 5
# row2 4 6
Seleccionando entradas de matrices individuales por sus posiciones.
También es posible usar una matriz Nx2 para seleccionar N elementos individuales de una matriz (como cómo funciona un sistema de coordenadas). Si desea extraer, en un vector, las entradas de una matriz en la (1st row, 1st column), (1st row, 3rd column), (2nd row, 3rd column), (2nd row, 1st column) esto puede se puede hacer fácilmente creando una matriz de índice con esas coordenadas y usándola para subcontratar la matriz:
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
En el ejemplo anterior, la 1ª columna de la matriz de ind refiere a las filas en mat , la 2ª columna de ind refiere a las columnas en mat .
Marcos de datos
Subconfigurar un marco de datos en un marco de datos más pequeño se puede lograr de la misma manera que un subconjunto de una lista.
> 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
El subconjunto de un marco de datos en un vector de columna se puede lograr usando corchetes dobles [[]] o el operador de signo de dólar $.
> 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
El subconjunto de datos como una matriz bidimensional se puede lograr usando los términos i y 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
Nota: el subconjunto solo por j (columna) simplifica el tipo propio de la variable, pero el subconjunto solo por i devuelve un data.frame , ya que las diferentes variables pueden tener diferentes tipos y clases. Establecer el parámetro drop en FALSE mantiene el cuadro de datos.
> is.vector(df3[, 2])
## TRUE
> is.data.frame(df3[2, ])
## TRUE
> is.data.frame(df3[, 2, drop = FALSE])
## TRUE
Otros objetos
Los operadores [ y [[ son funciones primitivas que son genéricas]. Esto significa que cualquier objeto en R (específicamente isTRUE(is.object(x)) tiene un atributo "clase" explícito) puede tener su propio comportamiento específico cuando se subcontrata; Es decir, tiene sus propios métodos para [ y / o [[ .
Por ejemplo, este es el caso de los objetos "data.frame" ( is.object(iris) ) en los que se definen los métodos [.data.frame y [[.data.frame y están [[.data.frame para exhibir ambos "matrices", como y "lista", como subconjunto. Al forzar un error cuando se subcontrata un "cuadro de datos", vemos que, en realidad, se llamó a una función [.data.frame cuando usamos [ simplemente [ .
iris[invalidArgument, ]
## Error in `[.data.frame`(iris, invalidArgument, ) :
## object 'invalidArgument' not found
Sin más detalles sobre el tema actual, un ejemplo [ método:
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
Podemos superar el envío de métodos de [ mediante el uso de .subset no genérico .subset (y .subset2 para [[ )]. Esto es especialmente útil y eficiente cuando programamos nuestras propias "clases" y queremos evitar soluciones (como unclass(x) ) cuando unclass(x) nuestras "clases" de manera eficiente (evitando el envío de métodos y la copia de objetos):
.subset(x, c(3, 2, 4))
## [1] 3 2 4
Indexación vectorial
Para este ejemplo, usaremos el vector:
> x <- 11:20
> x
[1] 11 12 13 14 15 16 17 18 19 20
Los vectores R tienen un índice de 1, por lo que, por ejemplo, x[1] devolverá 11 . También podemos extraer un subvector de x pasando un vector de índices al operador de corchete:
> x[c(2,4,6)]
[1] 12 14 16
Si pasamos un vector de índices negativos, R devolverá un subvector con los índices especificados excluidos:
> x[c(-1,-3)]
[1] 12 14 15 16 17 18 19 20
También podemos pasar un vector booleano al operador de corchete, en cuyo caso devuelve un vector secundario correspondiente a las coordenadas donde el vector de indexación es TRUE :
> x[c(rep(TRUE,5),rep(FALSE,5))]
[1] 11 12 13 14 15 16
Si el vector de indexación es más corto que la longitud de la matriz, entonces se repetirá, como en:
> x[c(TRUE,FALSE)]
[1] 11 13 15 17 19
> x[c(TRUE,FALSE,FALSE)]
[1] 11 14 17 20
Operaciones de matriz de Elementwise
Sean A y B dos matrices de la misma dimensión. Los operadores + , - , / , * , ^ cuando se utilizan con matrices de la misma dimensión realizan las operaciones requeridas en los elementos correspondientes de las matrices y devuelven una nueva matriz de la misma dimensión. Estas operaciones suelen denominarse operaciones de elementos.
| Operador | A op B | Sentido |
|---|---|---|
| + | A + B | Adición de elementos correspondientes de A y B |
| - | A - B | Resta los elementos de B de los elementos correspondientes de A |
| / | A / B | Divide los elementos de A por los elementos correspondientes de B |
| * | A * B | Multiplica los elementos de A por los elementos correspondientes de B. |
| ^ | A ^ (- 1) | Por ejemplo, da una matriz cuyos elementos son recíprocos de A |
Para la multiplicación de matriz "verdadera", como se ve en el Álgebra Lineal , use %*% . Por ejemplo, la multiplicación de A con B es: A %*% B Los requisitos dimensionales son que el ncol() de A sea el mismo que nrow() de B
Algunas funciones utilizadas con matrices
| Función | Ejemplo | Propósito |
|---|---|---|
| nrow () | aro (A) | determina el número de filas de A |
| ncol () | ncol (A) | Determina el número de columnas de A |
| rownames () | nombres de pila (A) | imprime los nombres de las filas de la matriz A |
| colnames () | nombres de pila (A) | imprime los nombres de las columnas de la matriz A |
| rowMeans () | rowMeans (A) | calcula las medias de cada fila de la matriz A |
| colMeans () | colMeans (A) | calcula las medias de cada columna de la matriz A |
| upper.tri () | upper.tri (A) | Devuelve un vector cuyos elementos son la parte superior. |
| matriz triangular de matriz cuadrada A | ||
| lower.tri () | lower.tri (A) | devuelve un vector cuyos elementos son los más bajos |
| matriz triangular de matriz cuadrada A | ||
| det () | det (A) | resulta en el determinante de la matriz A |
| resolver() | resolver (A) | resulta en la inversa de la matriz no singular A |
| diag () | diag (a) | devuelve una matriz diagonal cuyos elementos no diagonales son ceros y |
| Las diagonales son las mismas que las de la matriz cuadrada A | ||
| t () | ejército de reserva) | Devuelve la transposición de la matriz A |
| eigen () | eigen (A) | Retuens los valores propios y vectores propios de la matriz A |
| is.matrix () | is.matrix (A) | devuelve VERDADERO o FALSO dependiendo de si A es una matriz o no. |
| como.matrix () | como.matrix (x) | crea una matriz fuera del vector x |
