02_objetos.Rmd

# Tipos de objetos {#objetos}

En R existen varios tipos de objectos que permiten que el usuario pueda almacenar la información para realizar procedimientos estadísticos y gráficos. Los principales objetos en R son vectores, matrices, arreglos, marcos de datos y listas. A continuación se presentan las características de estos objetos y la forma para crearlos.

## Variables
Las variables sirven para almacenar un valor que luego vamos a utilizar en algún procedimiento. 

Para hacer la asignación de un valor a alguna variable se utiliza el operador `<-` entre el valor y el nombre de la variable. A continuación un ejemplo sencillo.

```{r}
x <- 5
2 * x + 3
```

En el siguiente ejemplo se crea la variable `pais` y se almacena el nombre Colombia, luego se averigua el número de caracteres de la variable `pais`.

```{r}
pais <- "Colombia"
nchar(pais)
```

## Vectores \index{vector} \label{vector}

Los vectores vectores son arreglos ordenados en los cuales se puede almacenar información de tipo numérico (variable cuantitativa), alfanumérico (variable cualitativa) o lógico (`TRUE` o `FALSE`), pero no mezclas de éstos. La función de R para crear un vector es `c()` y que significa concatenar; dentro de los paréntesis de esta función se ubica la información a almacenar. Una vez construído el vector se acostumbra a etiquetarlo con un nombre corto y representativo de la información que almacena, la asignación se hace por medio del operador `<-` entre el nombre y el vector.

A continuación se presenta un ejemplo de cómo crear tres vectores que contienen las respuestas de cinco personas a tres preguntas que se les realizaron.

```{r}
edad <- c(15, 19, 13, NA, 20)
deporte <- c(TRUE, TRUE, NA, FALSE, TRUE)
comic_fav <- c(NA, 'Superman', 'Batman', NA, 'Batman')
```

El vector `edad` es un vector cuantitativo y contiene las edades de las 5 personas. En la cuarta posición del vector se colocó el símbolo `NA` que significa __Not Available__ debido a que no se registró la edad para esa persona. Al hacer una asignación se acostumbra a dejar un espacio antes y después del operador `<-` de asignación. El segundo vector es llamado `deporte` y es un vector lógico que almacena las respuestas a la pregunta de si la persona practica deporte, nuevamente aquí hay un `NA` para la tercera persona. El último vector `comic_fav` contiene la información del cómic favorito de cada persona, como esta variable es cualitativa es necesario usar las comillas `' '` para encerrar las respuestas. 

```{block2, type='rmdwarning'}
Cuando se usa `NA` para representar una información __Not Available__ no se deben usar comillas.
```

```{block2, type='rmdnote'}
Es posible usar comillas sencillas `'foo'` o comillas dobles `"foo"` para ingresar valores de una variable cualitativa.
```

Si se desea ver lo que está almacenado en cada uno de estos vectores, se debe escribir en la consola de R el nombre de uno de los objetos y luego se presiona la tecla __enter__ o __intro__, al realizar esto lo que se obtiene se muestra a continuación.

```{r}
edad
deporte
comic_fav
```

```{block2, type='rmdnote'}
Una variable es un vector de longitud uno.
```

### ¿Cómo extraer elementos de un vector?
Para extraer un elemento almacenado dentro un vector se usan los corchetes `[]` y dentro de ellos la posición o posiciones que interesan.

### Ejemplo {-}
Si queremos extraer la edad de la tercera persona escribimos el nombre del vector y luego `[3]` para indicar la tercera posición de `edad`, a continuación el código.

```{r}
edad[3]
```

Si queremos conocer el cómic favorito de la segunda y quinta persona, escribimos el nombre del vector y luego, dentro de los corchetes, escribimos otro vector con las posiciones 2 y 5 que nos interesan así `[c(2, 5)]`, a continuación el código. 

```{r}
comic_fav[c(2, 5)]
```

Si nos interesan las respuestas de la práctica de deporte, excepto la de la persona 3, usamos `[-3]` luego del nombre del vector para obtener todo, excepto la tercera posición.

```{r}
deporte[-3]
```

```{block2, type='rmdwarning'}
Si desea extraer varios posiciones de un vector NUNCA escriba esto: `mivector[2, 5, 7]`. Tiene que crear un vector con las posiciones y luego colocarlo dentro de los corchetes así: `mivector[c(2, 5, 7)]`
```

## Matrices
Las matrices \index{matrices} son arreglos rectangulares de filas y columnas con información numérica, alfanumérica o lógica. Para construir una matriz se usa la función `matrix( )`. Por ejemplo, para crear una matriz de 4 filas y 5 columnas (de dimensión $4 \times 5$) con los primeros 20 números positivos se escribe el código siguiente en la consola.

```{r}
mimatriz <- matrix(data=1:20, nrow=4, ncol=5, byrow=FALSE)
```

El argumento `data` de la función sirve para indicar los datos que se van a almacenar en la matriz, los argumentos `nrow` y `ncol` sirven para definir la dimensión de la matriz y por último el argumento `byrow` sirve para indicar si la información contenida en `data` se debe ingresar por filas o no. Para observar lo que quedó almacenado en el objeto `mimatriz` se escribe en la consola el nombre del objeto seguido de la tecla __enter__ o __intro__.

```{r}
mimatriz
```

### ¿Cómo extraer elementos de una matriz?
Al igual que en el caso de los vectores, para extraer elementos almacenados dentro de una matriz se usan los corchetes `[ , ]` y dentro, separado por una coma, el número de fila(s) y el número de columna(s) que nos interesan.

### Ejemplo {-}
Si queremos extraer el valor almacenado en la fila 3 y columna 4 usamos el siguiente código.
```{r}
mimatriz[3, 4]
```

Si queremos recuperar __toda__ la fila 2 usamos el siguiente código.
```{r}
mimatriz[2, ]  # No se escribe nada luego de la coma
```

Si queremos recuperar __toda__ la columna 5 usamos el siguiente código.
```{r}
mimatriz[, 5]  # No se escribe nada antes de la coma
```

Si queremos recuperar la matriz original sin las columnas 2 y 4 usamos el siguiente código.
```{r}
mimatriz[, -c(2, 4)]  # Las columnas como vector
```

Si queremos recuperar la matriz original sin la fila 1 ni columna 3 usamos el siguiente código.
```{r}
mimatriz[-1, -3]  # Signo de menos para eliminar
```

## Arreglos \index{arreglo} \index{array}

Un arreglo es una matriz de varias dimensiones con información numérica, alfanumérica o lógica. Para construir una arreglo se usa la función `array( )`. Por ejemplo, para crear un arreglo de $3 \times 4 \times 2$ con las primeras 24 letras minúsculas del alfabeto se escribe el siguiente código.

```{r}
miarray <- array(data=letters[1:24], dim=c(3, 4, 2))
```

El argumento `data` de la función sirve para indicar los datos que se van a almacenar en el arreglo y el argumento `dim` sirve para indicar las dimensiones del arreglo. Para observar lo que quedó almacenado en el objeto `miarray` se escribe en la consola lo siguiente.

```{r}
miarray
```

### ¿Cómo extraer elementos de un arreglo?
Para recuperar elementos almacenados en un arreglo se usan también corchetes, y dentro de los corchetes, las coordenadas del objeto de interés.

### Ejemplo {-}
Si queremos extraer la letra almacenada en la fila 1 y columna 3 de la segunda capa de `miarray` usamos el siguiente código.
```{r}
miarray[1, 3, 2]  # El orden es importante
```

Si queremos extraer la segunda capa completa usamos el siguiente código.
```{r}
miarray[,, 2]  # No se coloca nada en las primeras posiciones
```

Si queremos extraer la tercera columna de todas las capas usamos el siguiente código.
```{r}
miarray[, 3,]  # No se coloca nada en las primeras posiciones
```


## Marco de datos \index{marco de datos} \index{data.frame}
El marco de datos marco de datos o _data frame_ es uno de los objetos más utilizados porque permite agrupar vectores con información de diferente tipo (numérica, alfanumérica o lógica) en un mismo objeto, la única restricción es que los vectores deben tener la misma longitud. Para crear un marco de datos se usa la función `data.frame( )`, como ejemplo vamos a crear un marco de datos con los vectores `edad`, `deporte` y `comic_fav` definidos anteriormente.

```{r}
mimarco <- data.frame(edad, deporte, comic_fav)
```

Una vez creado el objeto `mimarco` podemos ver el objeto escribiendo su nombre en la consola, a continuación se muestra lo que se obtiene.

```{r}
mimarco
```

De la salida anterior vemos que el marco de datos tiene 3 variables (columnas) cuyos nombres coinciden con los nombres de los vectores creados anteriormente, los números consecutivos al lado izquierdo son sólo de referencia y permiten identificar la información para cada persona en la base de datos.

### ¿Cómo extraer elementos de un marco de datos?
Para recuperar las variables (columnas) almacenadas en un marco de datos se puede usar el operador `$`, corchetes simples `[]` o corchetes dobles `[[]]`. A continuación algunos ejemplos para entender las diferencias entre estas opciones.


### Ejemplo {-}
Si queremos extraer la variable `deporte` del marco de datos `mimarco` como un vector usamos el siguiente código.
```{r}
mimarco$deporte  # Se recomienda si el nombre es corto
```

Otra forma de recuperar la variable `deporte` como vector es indicando el número de la columna donde se encuentra la variable.
```{r}
mimarco[, 2]  # Se recomienda si recordamos su ubicacion
```

Otra forma de extraer la variable `deporte` como vector es usando `[[]]` y dentro el nombre de la variable.
```{r}
mimarco[["deporte"]]
```

Si usamos `mimarco["deporte"]` el resultado es la variable `deporte` pero en forma de marco de datos, no en forma vectorial.
```{r}
mimarco["deporte"]
```

Si queremos extraer un marco de datos sólo con las variables deporte y edad podemos usar el siguiente código.
```{r}
mimarco[c("deporte", "edad")]
```

Por otra, si queremos la `edad` de las personas que están en las posiciones 2 hasta 4 usamos el siguiente código.
```{r}
mimarco[2:4, 1]
```

### ¿Cómo extraer subconjuntos de un marco de datos? \index{subset}
Para extraer partes de un marco de datos se puede utilizar la función `subset(x, subset, select)`. El parámetro `x` sirve para indicar el marco de datos original, el parámetro `subset` sirve para colocar la condición y el parámetro `select` sirve para quedarnos sólo con algunas de las variables del marco de datos. A continuación varios ejemplos de la función `subset` para ver su utilidad.

### Ejemplos {-}
Si queremos el marco de datos `mimarco` sólo con las personas que SI practican deporte usamos el siguiente código.
```{r}
subset(mimarco, subset=deporte == TRUE)
```

Si queremos el marco de datos `mimarco` sólo con las personas mayores o iguales a 17 años usamos el siguiente código.
```{r}
subset(mimarco, subset=edad >= 17)
```

Si queremos el submarco con deporte y comic de las personas menores de 20 años usamos el siguiente código.
```{r}
subset(mimarco, subset=edad < 20, select=c('deporte', 'comic_fav'))
```

Si queremos el marco de datos `mimarco` sólo con las personas menores de 20 años y que SI practican deporte usamos el siguiente código.
```{r}
subset(mimarco, subset=edad < 20 & deporte == TRUE)
```

### Ejemplo {-}
Leer la base de datos medidas del cuerpo disponible en este enlace https://raw.githubusercontent.com/fhernanb/datos/master/medidas_cuerpo. Extraer de esta base de datos una sub-base o subconjunto que contenga sólo la edad, peso, altura y sexo de aquellos que miden más de 185 cm y pesan más de 80 kg.

```{r}
url <- 'https://raw.githubusercontent.com/fhernanb/datos/master/medidas_cuerpo'
dt1 <- read.table(url, header=T)
dim(dt1)  # Para conocer la dimensión de la base original
dt2 <- subset(x=dt1, subset=altura > 185 & peso > 80,
              select=c('sexo', 'edad', 'peso', 'altura'))
dt2  # Para mostrar la base de datos final
```
Al almacenar la nueva base de datos en el objeto `dt2` se puede manipular este nuevo objeto para realizar los análisis de interés.

## Listas \index{lista} \index{list}

Las listas son otro tipo de objeto muy usado para almacenar objetos de diferente tipo. La instrucción para crear una lista es `list( )`. A continuación vamos a crear una lista que contiene tres objetos: un vector con 5 números aleatorios llamado `mivector`, una matriz de dimensión $6 \times 2$ con los primeros doce números enteros positivos llamada `matriz2` y el tercer objeto será el marco de datos `mimarco` creado en el apartado anterior. Las instrucciones para crear la lista requerida se muestran a continuación.

```{r}
set.seed(12345)
mivector <- runif(n=5)
matriz2 <- matrix(data=1:12, ncol=6)
milista <- list(E1=mivector, E2=matriz2, E3=mimarco)
```

La función `set.seed` de la línea número 1 sirve para fijar la semilla de tal manera que los números aleatorios generados en la segunda línea con la función `runif` sean siempre los mismos. En la última línea del código anterior se construye la lista, dentro de la función `list` se colocan los tres objetos `mivector`, `matriz2` y `mimarco`. Es posible colocarle un nombre especial a cada uno de los elementos de la lista, en este ejemplo se colocaron los nombres `E1`, `E2` y `E3` para cada uno de los tres elementos. Para observar lo que quedó almacenado en la lista se escribe `milista` en la consola y el resultado se muestra a continuación.

```{r}
milista
```

### ¿Cómo extraer elementos de una lista?
Para recuperar los elementos almacenadas en una lista se usa el operador `$`, corchetes dobles `[[]]` o corchetes sencillos `[]`. A continuación unos ejemplos para entender cómo extraer elementos de una lista.

### Ejemplos {-}
Si queremos la matriz almacenada con el nombre de `E2` dentro del objeto `milista` se puede usar el siguiente código.

```{r}
milista$E2
```

Es posible indicar la posición del objeto en lugar del nombre, para eso se usan los corchetes dobles.

```{r}
milista[[2]]
```

El resultado obtenido con `milista$E2` y `milista[[2]]` es __exactamente__ el mismo. Vamos ahora a solicitar la posición 2 pero usando corchetes sencillos.

```{r}
milista[2]
```

La apariencia de este último resultado es similar, no igual, al encontrado al usar `$` y `[[]]`. Para ver la diferencia vamos a pedir la clase a la que pertenecen los tres últimos objetos usando la función `class`. A continuación el código usado.

```{r}
class(milista$E2)
class(milista[[2]])
class(milista[2])
```

De lo anterior se observa claramente que cuando usamos `$` o `[[]]` el resultado es el objeto almacenado, una matriz. Cuando usamos `[]` el resultado es una __lista__ cuyo contenido es el objeto almacendado.

```{block2, type='rmdwarning'}
Al manipular listas con `$` y `[[]]` se obtienen los objetos ahí almacenados, al manipular listas con `[]` se obtiene una lista.
```


## EJERCICIOS {-}
Use funciones o procedimientos (varias líneas) de R para responder cada una de las siguientes preguntas.

1. Construya un vector con la primeras 20 letras MAYÚSCULAS usando la función LETTERS.

2. Construya una matriz de $10 \times 10$ con los primeros 100 números positivos pares.

3. Construya una matriz identidad de dimension $3 \times 3$. Recuerde que una matriz identidad tiene sólo unos en la diagonal principal y los demás elementos son cero.

4. Construya una lista con los anteriores tres objetos creados.

2. Construya un marco de datos o data frame con las respuestas de 3 personas a las preguntas: (a) ¿Cuál es su edad en años? (b) ¿Tipo de música que más le gusta? (c) ¿Tiene usted pareja sentimental estable?

3. ¿Cuál es el error al correr el siguiente código? ¿A qué se debe?

```{r, echo = TRUE, eval=F}
edad <- c(15, 19, 13, NA, 20)
deporte <- c(TRUE, TRUE, NA, FALSE, TRUE)
comic_fav <- c(NA, 'Superman', 'Batman', NA, 'Batman')
matrix(edad, deporte, comic_fav)
```