En esta lección aprenderá a extraer elementos de un vector basandose en condiciones especificas.Por ejemplo, estamos interesados en los primeros 20 elementos de un vector, solo los elementos que no son NA, solo aquellos que son positivos o corresponden a una variable especifica de interes.

Este material esta basado en la leccion de “Subsetting vectors” de “R Programming”, paquete swirl.Author: Nick Carchedi, Organization: JHU Biostat, Version: 2.2.0.

Comencemos ahora!

Primero crearemos un vector x que contiene 20 numeros aleatorios (a partir de una distribución normal) y 20 NAs.

x <- sample(c(rnorm(20), rep(NA, 20)))
x
##  [1]  0.565967027 -1.513945984 -0.549186933           NA           NA
##  [6]  1.692455353 -1.531761484           NA  0.647878855  0.792076274
## [11] -1.473640313  1.147280724           NA           NA  2.420973807
## [16]           NA  0.234141912  0.974827131  0.006510678           NA
## [21]           NA           NA -0.901293936           NA           NA
## [26]           NA           NA           NA -0.799215579           NA
## [31]           NA           NA  0.625291032  0.002847028 -1.624721545
## [36] -1.721089646 -0.488227824           NA           NA           NA

Para acceder a un subconjunto (subset) de elementos del vector x tenemos que utilizar la expresión x[1:10], en eset caso se obtendrá los primeros 10 elementos de x. Es decir luego del nombre del vector de abre un corchete donde se indica el o los indices del vector que se desea obtener.

x[1:10]
##  [1]  0.5659670 -1.5139460 -0.5491869         NA         NA  1.6924554
##  [7] -1.5317615         NA  0.6478789  0.7920763

Los indices de vectores pueden ser de diferente tipo: vectores lógicos, vectores de enteros positivos, vectores de enteros negativos, vectores con cadenas de caracteres. Ellos serán tratados en esta lección.

Comencemos con indices de vectores lógicos. Un ejemplo es cuando queremos extraer todos aquellos valores que no sean NA (missing data). Recuerde que is.na(x) es una función que arroja un vector con valores logicos (TRUE y FALSE) de la misma longitud que x. TRUE corresponde para los valores NA y FALSE para los valores que no son NA.

Cual crees que es el resultado de la siguiente expresión: x[is.na(x)].

x[is.na(x)]
##  [1] NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA NA

Si por el contrario lo que se quiere obtener es el vector con valores que no son NA, debe usarse el operador lógico de negación !, es decir !is.na(x) y que puede leerse como ‘no es NA’.

y <- x[!is.na(x)]

Ahora que hemos “eliminado” los valores NA podemos continuar extrayendo subconjutnos de y.

La expresión y > 0 nos da un vector de valores lógicos indicando con TRUE cuales valores son mayores a 0 y con FALSE aquellos igual o menores a 0. Sin embargo si se desea obtener los valores numericos originales debe combinarse esta expresión con la función se subsetting: y[y > 0]

Esto no puede aplicarse directamente sobre el vector x ya que contiene valores NA. Escribe x[x > 0] y observa el por que.NA no es un valor sino un marcador de posición, luego la expresión NA > 0 evalua el NA y arroja un conjunto de NA junto con los valores positivos.

Para obtener a partir de x y en un solo paso el vector de valores positivos, deben combinarse 2 operadores lógicos: x[!is.na(x) & x > 0]. Esta expresión arroja los valores que al mismo tiempo sean no NA y mayores a cero.

y > 0
##  [1]  TRUE FALSE FALSE  TRUE FALSE  TRUE  TRUE FALSE  TRUE  TRUE  TRUE
## [12]  TRUE  TRUE FALSE FALSE  TRUE  TRUE FALSE FALSE FALSE
y[y > 0]
##  [1] 0.565967027 1.692455353 0.647878855 0.792076274 1.147280724
##  [6] 2.420973807 0.234141912 0.974827131 0.006510678 0.625291032
## [11] 0.002847028
x[x > 0]
##  [1] 0.565967027          NA          NA 1.692455353          NA
##  [6] 0.647878855 0.792076274 1.147280724          NA          NA
## [11] 2.420973807          NA 0.234141912 0.974827131 0.006510678
## [16]          NA          NA          NA          NA          NA
## [21]          NA          NA          NA          NA          NA
## [26]          NA 0.625291032 0.002847028          NA          NA
## [31]          NA
x[!is.na(x) & x > 0]
##  [1] 0.565967027 1.692455353 0.647878855 0.792076274 1.147280724
##  [6] 2.420973807 0.234141912 0.974827131 0.006510678 0.625291032
## [11] 0.002847028

Anteriormente vimos como pedir los 10 primeros valores con x[1:10]. En R el primer elemento siempre es 1 (en otros lenguajes de programación puede ser 0). Prueba que sucede si se pide el elemento 0, que no está definido en R, con x[0].Lo mismo sucede si pedimos un numero extremadamente alto como x[3000] (recuerda que x tiene solo 40 elementos)

A continuación vamos a pedir elementos concretos como por ejemplo el que se encuentra en la 3era, 5ta y 7ma posición. Para ello utilizamos la función c(): x[c(3, 5, 7)]. Esta es la forma de pedir valores enteros positivos

x[0]
## numeric(0)
x[3000]
## [1] NA
x[c(3, 5, 7)]
## [1] -0.5491869         NA -1.5317615

Imagine que estamos interesados en pedir todos los elementos de x, exepto los valores de la 2da y 10ava posición. Si pidieramos x[c(2, 10)] nos daria solo los valores de la 2da y 10ava posición, pero si pedimos x[c(-2, -10)] nos dará todos los elementos expeto los de la 2da y 10ava posición. x[-c(2, 10)] es equivalente a la expresión anterior. Esto es un ejemplo de los vectores de enteros negativos

x[c(2, 10)]
## [1] -1.5139460  0.7920763
x[c(-2, -10)]
##  [1]  0.565967027 -0.549186933           NA           NA  1.692455353
##  [6] -1.531761484           NA  0.647878855 -1.473640313  1.147280724
## [11]           NA           NA  2.420973807           NA  0.234141912
## [16]  0.974827131  0.006510678           NA           NA           NA
## [21] -0.901293936           NA           NA           NA           NA
## [26]           NA -0.799215579           NA           NA           NA
## [31]  0.625291032  0.002847028 -1.624721545 -1.721089646 -0.488227824
## [36]           NA           NA           NA
x[-c(2, 10)]
##  [1]  0.565967027 -0.549186933           NA           NA  1.692455353
##  [6] -1.531761484           NA  0.647878855 -1.473640313  1.147280724
## [11]           NA           NA  2.420973807           NA  0.234141912
## [16]  0.974827131  0.006510678           NA           NA           NA
## [21] -0.901293936           NA           NA           NA           NA
## [26]           NA -0.799215579           NA           NA           NA
## [31]  0.625291032  0.002847028 -1.624721545 -1.721089646 -0.488227824
## [36]           NA           NA           NA

El único tipo que queda nos obliga a introducir el concepto “nombre”de elementos.

Cree un vector numérico con con tres nombres de elementos usando vect <- c(foo = 11, bar = 2, norf = NA).Podemos observar el nombre de los elementos con la función names().

vect <- c(foo = 11, bar = 2, norf = NA)
vect
##  foo  bar norf 
##   11    2   NA
names(vect)
## [1] "foo"  "bar"  "norf"

También podemos crear un vector vect2 sin nombres con los datos c(11, 2, NA).Luego, asignamos los nombres a vect2 con names(vect2) <- c(“foo”, “bar”, “norf”).

vect2 <- c(11, 2, NA)
vect2
## [1] 11  2 NA
names(vect2) <- c("foo", "bar", "norf")
vect2
##  foo  bar norf 
##   11    2   NA

Ahora revisemos que vect y vect2 sean iguales. Para ello usamos la función identical(). El resultado dice que ambas variables son identicas.

identical(vect, vect2)
## [1] TRUE

VOlvamos a la tarea de obtener subconjuntos de vectores usando el nombre de los elementos. En este caso se debe incluir entre los corchetes el nombre del elemento a obtener entre comillas. De la misma manera, podemos especificar varios nombres al mismo tiempo con vect[c(“foo”, “bar”)]

vect["bar"]
## bar 
##   2
vect[c("foo", "bar")]
## foo bar 
##  11   2

Ha llegado al final de esta leccion!