Vectors.qmd

# Vectores {#sec-vectors-chap}

```{r setup, include = FALSE}
source("common.R")
```

## Introducción

\index{vectors} \index{nodes}

Este capítulo analiza la familia más importante de tipos de datos en base R: vectores[^vectors-1]. Si bien es probable que ya haya usado muchos (si no todos) de los diferentes tipos de vectores, es posible que no haya pensado profundamente en cómo están interrelacionados. En este capítulo, no cubriré los tipos de vectores individuales con demasiado detalle, pero le mostraré cómo encajan todos los tipos como un todo. Si necesita más detalles, puede encontrarlos en la documentación de R.

[^vectors-1]: En conjunto, todos los demás tipos de datos se conocen como tipos de "nodo", que incluyen cosas como funciones y entornos. Lo más probable es que te encuentres con este término altamente técnico cuando uses `gc()`: la "N" en `Ncells` significa nodos y la "V" en `Vcells` significa vectores.

Los vectores vienen en dos sabores: vectores atómicos y listas [^vectors-2]. Se diferencian en cuanto a los tipos de sus elementos: para los vectores atómicos, todos los elementos deben tener el mismo tipo; para las listas, los elementos pueden tener diferentes tipos. Si bien no es un vector, `NULL` está estrechamente relacionado con los vectores y, a menudo, cumple la función de un vector genérico de longitud cero. Este diagrama, que ampliaremos a lo largo de este capítulo, ilustra las relaciones básicas:

[^vectors-2]: Algunos lugares en la documentación de R llaman a listas de vectores genéricos para enfatizar su diferencia con los vectores atómicos.

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/summary-tree.png")
```

Cada vector también puede tener **atributos**, que puede considerar como una lista con nombre de metadatos arbitrarios. Dos atributos son particularmente importantes. El atributo **dimensión** convierte los vectores en matrices y arreglos y el atributo **clase** impulsa el sistema de objetos S3. Si bien aprenderá a usar S3 en el @sec-s3, aquí aprenderá sobre algunos de los vectores S3 más importantes: factores, fecha y hora, data frames y tibbles. Y aunque las estructuras 2D como matrices y data frames no son necesariamente lo que le viene a la mente cuando piensa en vectores, también aprenderá por qué R los considera vectores.

### Prueba {.unnumbered}

Responda este breve cuestionario para determinar si necesita leer este capítulo. Si las respuestas le vienen a la mente rápidamente, puede saltarse cómodamente este capítulo. Puede comprobar sus respuestas en la @sec-data-structure-answers.

1.  ¿Cuáles son los cuatro tipos comunes de vectores atómicos? ¿Cuáles son los dos tipos raros?

2.  ¿Qué son los atributos? ¿Cómo los consigues y los configuras?

3.  ¿En qué se diferencia una lista de un vector atómico? ¿En qué se diferencia una matriz de un data frame?

4.  ¿Puedes tener una lista que sea una matriz? ¿Puede un data frame tener una columna que sea una matriz?

5.  ¿En qué se diferencian los tibbles de los data frames?

### Estructura {.unnumbered}

-   La @sec-atomic-vectors te introduce a los vectores atómicos: lógico, entero, doble y de carácter. Estas son las estructuras de datos más simples de R.

-   La @sec-attributes toma un pequeño desvío para discutir los atributos, la especificación de metadatos flexibles de R. Los atributos más importantes son los nombres, las dimensiones y la clase.

-   La @sec-s3-atomic-vectors analiza los tipos de vectores importantes que se construyen combinando vectores atómicos con atributos especiales. Estos incluyen factores, fechas, fechas-horas y duraciones.

-   La @sec-lists se sumerge en las listas. Las listas son muy similares a los vectores atómicos, pero tienen una diferencia clave: un elemento de una lista puede ser cualquier tipo de datos, incluida otra lista. Esto los hace adecuados para representar datos jerárquicos.

-   La @sec-tibble te enseña sobre data frames y tibbles, que se utilizan para representar datos rectangulares. Combinan el comportamiento de listas y matrices para crear una estructura ideal para las necesidades de los datos estadísticos.

## Vectores atómicos {#sec-atomic-vectors}

\index{atomic vectors} \index{vectors!atomic|see {atomic vectors}} \index{logical vectors} \index{integer vectors} \index{double vectors} \index{numeric vectors} \index{character vectors}

Hay cuatro tipos principales de vectores atómicos: lógico, entero, doble y carácter (que contiene cadenas). En conjunto, los vectores enteros y dobles se conocen como vectores numéricos [^vectors-3]. Hay dos tipos raros: complejos y crudos. No los discutiré más porque los números complejos rara vez se necesitan en las estadísticas, y los vectores sin procesar son un tipo especial que solo se necesita cuando se manejan datos binarios.

[^vectors-3]: Esta es una ligera simplificación ya que R no usa "numérico" de manera consistente, a lo que volveremos en la @sec-numeric-type.

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/summary-tree-atomic.png")
```

### Escalares {#sec-scalars}

\index{scalars} \index{NaN} \index{Inf} \index{L} \index{""} \index{'}

Cada uno de los cuatro tipos principales tiene una sintaxis especial para crear un valor individual, también conocido como **escalar**[^vectors-4]:

[^vectors-4]: Técnicamente, el lenguaje R no posee escalares. Todo lo que parece un escalar es en realidad un vector de longitud uno. Esta es principalmente una distinción teórica, pero significa que expresiones como `1[1]` funcionan.

-   Los lógicos se pueden escribir completos (`TRUE` o `FALSE`) o abreviados (`T` o `F`).

-   Los dobles se pueden especificar en formato decimal (`0.1234`), científico (`1.23e4`) o hexadecimal (`0xcafe`). Hay tres valores especiales únicos para los dobles: `Inf`, `-Inf` y `NaN` (no es un número). Estos son valores especiales definidos por el estándar de punto flotante.

-   Los enteros se escriben de forma similar a los dobles, pero deben ir seguidos de `L`[^vectors-5] (`1234L`, `1e4L` o `0xcafeL`), y no pueden contener valores fraccionarios.

-   Las cadenas están rodeadas por `"` (`"hola"`) o `'` (`'adiós'`). Los caracteres especiales se escapan con `\`; consulte `?Quotes` para obtener detalles completos.

[^vectors-5]: `L` no es intuitivo, y puede que te preguntes de dónde viene. En el momento en que se agregó `L` a R, el tipo de entero de R era equivalente a un entero largo en C, y el código C podía usar un sufijo de `l` o `L` para obligar a un número a ser un entero largo. Se decidió que `l` era demasiado similar visualmente a `i` (usado para números complejos en R), dejando `L`.

### Crear vectores más largos con `c()` {#sec-atomic-constructing}

```{=tex}
\index{typeof()}
\index{length()}
\index{c()}
```
Para crear vectores más largos a partir de otros más cortos, use `c()`, abreviatura de combinar:

```{r}
lgl_var <- c(TRUE, FALSE)
int_var <- c(1L, 6L, 10L)
dbl_var <- c(1, 2.5, 4.5)
chr_var <- c("these are", "some strings")
```

Cuando las entradas son vectores atómicos, `c()` siempre crea otro vector atómico; es decir, se aplana:

```{r}
c(c(1, 2), c(3, 4))
```

En los diagramas, representaré los vectores como rectángulos conectados, por lo que el código anterior podría dibujarse de la siguiente manera:

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/atomic.png")
```

Puedes determinar el tipo de un vector con `typeof()`[^vectors-6] y su longitud con `length()`.

[^vectors-6]: Es posible que haya oído hablar de las funciones `mode()` y `storage.mode()` relacionadas. No los uses: existen solo por compatibilidad con S.

```{r}
typeof(lgl_var)
typeof(int_var)
typeof(dbl_var)
typeof(chr_var)
```

### Valores Faltantes

```{=tex}
\index{NA}
\index{is.na}
```
\index{missing values|see {\texttt{NA}}}

R representa valores faltantes o desconocidos, con un valor centinela especial: `NA` (abreviatura de no aplicable). Los valores faltantes tienden a ser infecciosos: la mayoría de los cálculos que involucran un valor faltante devolverán otro valor faltante.

```{r}
NA > 5
10 * NA
!NA
```

Sólo hay unas pocas excepciones a esta regla. Estos ocurren cuando alguna identidad se mantiene para todas las entradas posibles:

```{r}
NA ^ 0
NA | TRUE
NA & FALSE
```

La propagación de faltantes conduce a un error común al determinar qué valores faltan en un vector:

```{r}
x <- c(NA, 5, NA, 10)
x == NA
```

Este resultado es correcto (aunque un poco sorprendente) porque no hay motivo para creer que un valor faltante tiene el mismo valor que otro. En su lugar, use `is.na()` para probar la presencia de ausencias:

```{r}
is.na(x)
```

NB: Técnicamente, hay cuatro valores faltantes[^vectors-7], uno para cada uno de los tipos atómicos: `NA` (lógico), `NA_integer_` (entero), `NA_real_` (doble) y `NA_character_` (carácter). Esta distinción generalmente no es importante porque 'NA' será forzado automáticamente al tipo correcto cuando sea necesario.

[^vectors-7]: Bueno, técnicamente, cinco si incluimos `NA_complex_`, pero ignoramos este tipo "raro", como se mencionó anteriormente.

### Pruebas y coerción

\index{coercion} \index{is.vector()} \index{is.atomic()} \index{is.numeric()}

En general, puede **probar** si un vector es de un tipo dado con una función `is.*()`, pero estas funciones deben usarse con cuidado. `is.logical()`, `is.integer()`, `is.double()` y `is.character()` hacen lo que cabría esperar: prueban si un vector es un carácter, doble, entero o lógico. Evite `is.vector()`, `is.atomic()` y `is.numeric()`: no comprueban si tiene un vector, un vector atómico o un vector numérico; deberá leer detenidamente la documentación para descubrir qué es lo que realmente hacen.

Para los vectores atómicos, el tipo es una propiedad de todo el vector: todos los elementos deben ser del mismo tipo. Cuando intente combinar diferentes tipos, se **coaccionarán** en un orden fijo: carácter → doble → entero → lógico. Por ejemplo, la combinación de un carácter y un número entero produce un carácter:

```{r}
str(c("a", 1))
```

La coerción a menudo ocurre automáticamente. La mayoría de las funciones matemáticas (`+`, `log`, `abs`, etc.) se convertirán en numéricas. Esta coerción es particularmente útil para vectores lógicos porque `TRUE` se convierte en 1 y `FALSE` se convierte en 0.

```{r}
x <- c(FALSE, FALSE, TRUE)
as.numeric(x)

# Número total de VERDADEROS
sum(x)

# Proporción que son VERDADERAS
mean(x)
```

En general, puede forzar deliberadamente usando una función `as.*()`, como `as.logical()`, `as.integer()`, `as.double()` o `as.character()`. La coerción fallida de cadenas genera una advertencia y un valor faltante:

```{r}
as.integer(c("1", "1.5", "a"))
```

### Ejercicios

1.  ¿Cómo se crean escalares crudos y complejos? (Ver `?raw` y `?complex`.)

2.  Pon a prueba tu conocimiento de las reglas de coerción de vectores prediciendo el resultado de los siguientes usos de `c()`:

    ```{r, eval=FALSE}
    c(1, FALSE)
    c("a", 1)
    c(TRUE, 1L)
    ```

3.  ¿Por qué `1 == "1"` es verdadero? ¿Por qué `-1 < FALSE` es verdadero? ¿Por qué `"one" < 2` es falso?

4.  ¿Por qué el valor faltante predeterminado, `NA`, es un vector lógico? ¿Qué tienen de especial los vectores lógicos? (Pista: piensa en `c(FALSE, NA_character_)`.)

5.  Precisamente, ¿qué prueban `is.atomic()`, `is.numeric()` y `is.vector()`?

## Atributos {#sec-attributes}

\index{attributes}

Es posible que haya notado que el conjunto de vectores atómicos no incluye una serie de estructuras de datos importantes como matrices, arreglos, factores o fechas y horas. Estos tipos se construyen sobre vectores atómicos agregando atributos. En esta sección, aprenderá los conceptos básicos de los atributos y cómo el atributo dim crea matrices y arreglos. En la siguiente sección, aprenderá cómo se usa el atributo de clase para crear vectores de S3, incluidos factores, fechas y fechas y horas.

### Conseguir y configurar

\index{attr()}

\index{attributes!attributes@\texttt{attributes()}} \index{structure()}

Puede pensar en los atributos como pares de nombre-valor [^vectors-8] que adjuntan metadatos a un objeto. Los atributos individuales pueden recuperarse y modificarse con `attr()`, o recuperarse en masa con `attributes()`, y establecerse en masa con `structure()`.

[^vectors-8]: Los atributos se comportan como listas con nombre, pero en realidad son listas de pares. Las listas de pares son funcionalmente indistinguibles de las listas, pero son profundamente diferentes bajo el capó. Aprenderá más sobre ellos en la @sec-pairlists.

```{r}
a <- 1:3
attr(a, "x") <- "abcdef"
attr(a, "x")

attr(a, "y") <- 4:6
str(attributes(a))

# Or equivalently
a <- structure(
  1:3, 
  x = "abcdef",
  y = 4:6
)
str(attributes(a))
```

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/attr.png")
```

En general, los atributos deben considerarse efímeros. Por ejemplo, la mayoría de los atributos se pierden en la mayoría de las operaciones:

```{r}
attributes(a[1])
attributes(sum(a))
```

Solo hay dos atributos que se conservan de forma rutinaria:

-   **names**, un vector de caracteres que da a cada elemento un nombre.
-   **dim**, abreviatura de dimensiones, un vector entero, que se utiliza para convertir vectores en matrices o arreglos.

Para conservar otros atributos, deberá crear su propia clase S3, el tema del @sec-s3.

### Nombres {#sec-attr-names}

\index{attributes!names} \index{names()} \index{setNames()}

Puede nombrar un vector de tres maneras:

```{r}
# Cuando lo crea: 
x <- c(a = 1, b = 2, c = 3)

# Al asignar un vector de caracteres a names()
x <- 1:3
names(x) <- c("a", "b", "c")

# En línea con setNames():
x <- setNames(1:3, c("a", "b", "c"))
```

Evite usar `attr(x, "names")` ya que requiere escribir más y es menos legible que `names(x)`. Puede eliminar nombres de un vector usando `x <- unname(x)` o `names(x) <- NULL`.

Para ser técnicamente correcto, al dibujar el vector nombrado `x`, debería dibujarlo así:

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/attr-names-1.png")
```

Sin embargo, los nombres son tan especiales e importantes que, a menos que intente llamar la atención específicamente sobre la estructura de datos de los atributos, los usaré para etiquetar el vector directamente:

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/attr-names-2.png")
```

Para que sea útil con subconjuntos de caracteres (p. ej., la @sec-lookup-tables), los nombres deben ser únicos y no faltantes, pero R no impone esto. Dependiendo de cómo se establezcan los nombres, los nombres faltantes pueden ser `""` o `NA_character_`. Si faltan todos los nombres, `names()` devolverá `NULL`.

### Dimensiones {#sec-attr-dims}

\index{arrays} \index{matrices|see {arrays}} \index{attributes!dimensions}

Agregar un atributo `dim` a un vector le permite comportarse como una **matriz** bidimensional o una **matriz** multidimensional. Las matrices y los arreglos son principalmente herramientas matemáticas y estadísticas, no herramientas de programación, por lo que se usarán con poca frecuencia y solo se tratarán brevemente en este libro. Su característica más importante es el subconjunto multidimensional, que se trata en la @sec-matrix-subsetting.

Puede crear matrices y arreglos con `matrix()` y `array()`, o usando el formulario de asignación de `dim()`:

```{r}
# Dos argumentos escalares especifican tamaños de fila y columna
x <- matrix(1:6, nrow = 2, ncol = 3)
x

# Un argumento vectorial para describir todas las dimensiones
y <- array(1:12, c(2, 3, 2))
y

# También puede modificar un objeto en su lugar configurando dim()
z <- 1:6
dim(z) <- c(3, 2)
z
```

Muchas de las funciones para trabajar con vectores tienen generalizaciones para matrices y arreglos:

| Vector            | Matriz                     | Arreglo          |
|-------------------|----------------------------|------------------|
| `names()`         | `rownames()`, `colnames()` | `dimnames()`     |
| `length()`        | `nrow()`, `ncol()`         | `dim()`          |
| `c()`             | `rbind()`, `cbind()`       | `abind::abind()` |
| ---               | `t()`                      | `aperm()`        |
| `is.null(dim(x))` | `is.matrix()`              | `is.array()`     |

Un vector sin un conjunto de atributos "dim" a menudo se considera unidimensional, pero en realidad tiene dimensiones `NULL`. También puede tener matrices con una sola fila o una sola columna, o arreglos con una sola dimensión. Pueden imprimir de manera similar, pero se comportarán de manera diferente. Las diferencias no son demasiado importantes, pero es útil saber que existen en caso de que obtenga un resultado extraño de una función (`tapply()` es un infractor frecuente). Como siempre, usa `str()` para revelar las diferencias.

```{r}
str(1:3)                   # 1d vector
str(matrix(1:3, ncol = 1)) # column vector
str(matrix(1:3, nrow = 1)) # row vector
str(array(1:3, 3))         # "array" vector
```

### Ejercicios

1.  ¿Cómo se implementa `setNames()`? ¿Cómo se implementa `unname()`? Lee el código fuente.

2.  ¿Qué devuelve `dim()` cuando se aplica a un vector unidimensional? ¿Cuándo podría usar `NROW()` o `NCOL()`?

3.  ¿Cómo describirías los siguientes tres objetos? ¿Qué los hace diferentes de `1:5`?

    ```{r}
    x1 <- array(1:5, c(1, 1, 5))
    x2 <- array(1:5, c(1, 5, 1))
    x3 <- array(1:5, c(5, 1, 1))
    ```

4.  Un borrador inicial usó este código para ilustrar `structure()`:

    ```{r}
    structure(1:5, comment = "my attribute")
    ```

    Pero cuando imprime ese objeto, no ve el atributo de comentario. ¿Por qué? ¿Falta el atributo o hay algo más especial en él? (Sugerencia: intente usar la ayuda).

## Vectores atómicos S3 {#sec-s3-atomic-vectors}

\index{attributes!S3} \index{S3!vectors}

Uno de los atributos vectoriales más importantes es la `clase`, que subyace en el sistema de objetos S3. Tener un atributo de clase convierte un objeto en un **objeto S3**, lo que significa que se comportará de manera diferente a un vector regular cuando se pasa a una función **genérica**. Cada objeto de S3 se crea sobre un tipo base y, a menudo, almacena información adicional en otros atributos. Aprenderá los detalles del sistema de objetos de S3 y cómo crear sus propias clases de S3 en el @sec-s3.

En esta sección, analizaremos cuatro vectores S3 importantes que se utilizan en la base R:

-   Datos categóricos, donde los valores provienen de un conjunto fijo de niveles registrados en vectores de **factores**.

-   Fechas (con resolución de día), que se registran en vectores **Fecha**.

-   Fechas-horas (con resolución de segundos o subsegundos), que se almacenan en vectores **POSIXct**.

-   Duraciones, que se almacenan en vectores **difftime**.

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/summary-tree-s3-1.png")
```

### Factores

```{=tex}
\index{factor}
\index{stringsAsFactors}
```
Un factor es un vector que solo puede contener valores predefinidos. Se utiliza para almacenar datos categóricos. Los factores se construyen sobre un vector entero con dos atributos: una `class`, "factor", que hace que se comporte de manera diferente a los vectores enteros normales, y `levels`, que define el conjunto de valores permitidos.

```{r}
x <- factor(c("a", "b", "b", "a"))
x

typeof(x)
attributes(x)
```

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/factor.png")
```

Los factores son útiles cuando conoce el conjunto de valores posibles, pero no todos están presentes en un conjunto de datos determinado. A diferencia de un vector de caracteres, cuando tabula un factor obtendrá recuentos de todas las categorías, incluso las no observadas:

```{r}
sex_char <- c("m", "m", "m")
sex_factor <- factor(sex_char, levels = c("m", "f"))

table(sex_char)
table(sex_factor)
```

Los factores **ordenados** son una variación menor de los factores. En general, se comportan como factores regulares, pero el orden de los niveles es significativo (bajo, medio, alto) (una propiedad que algunas funciones de modelado y visualización aprovechan automáticamente).

```{r}
grade <- ordered(c("b", "b", "a", "c"), levels = c("c", "b", "a"))
grade
```

En base R[^vectors-9], tiende a encontrar factores con mucha frecuencia porque muchas funciones de base R (como `read.csv()` y `data.frame()`) convierten automáticamente los vectores de caracteres en factores. Esto es subóptimo porque no hay forma de que esas funciones conozcan el conjunto de todos los niveles posibles o su orden correcto: los niveles son una propiedad de la teoría o el diseño experimental, no de los datos. En su lugar, utilice el argumento `stringsAsFactors = FALSE` para suprimir este comportamiento y luego convierta manualmente los vectores de caracteres en factores usando su conocimiento de los datos "teóricos". Para conocer el contexto histórico de este comportamiento, recomiendo [*stringsAsFactors: Una biografía no autorizada*](https://simplystatistics.org/posts/2015-07-24-stringsasfactors-an-unauthorized-biography) de Roger Peng, y [*stringsAsFactors = \<sigh\>*](http://notstatschat.tumblr.com/post/124987394001/stringsas%20factores-suspiro) de Thomas Lumley.

[^vectors-9]: El tidyverse nunca fuerza automáticamente a los personajes a factores, y proporciona el paquete forcats [@forcats] específicamente para trabajar con factores.

Si bien los factores se ven (y a menudo se comportan como) vectores de caracteres, se construyen sobre números enteros. Así que tenga cuidado al tratarlos como cadenas. Algunos métodos de cadena (como `gsub()` y `grepl()`) forzarán automáticamente los factores a cadenas, otros (como `nchar()`) generarán un error y otros (como `c()`) usarán los valores enteros subyacentes. Por esta razón, normalmente es mejor convertir explícitamente los factores en vectores de caracteres si necesita un comportamiento similar al de una cadena.

### Fechas

\index{Date}

Los vectores de fecha se construyen sobre vectores dobles. Tienen clase "Date" y ningún otro atributo:

```{r}
today <- Sys.Date()

typeof(today)
attributes(today)
```

El valor del doble (que se puede ver quitando la clase), representa el número de días desde 1970-01-01[^vectors-10]:

[^vectors-10]: Esta fecha especial se conoce como la Época Unix.

```{r}
date <- as.Date("1970-02-01")
unclass(date)
```

### Fecha-Hora

\index{date-times|see {\texttt{POSIXct}}} \index{POSIXct}

Base R[^vectors-11] proporciona dos formas de almacenar información de fecha y hora, POSIXct y POSIXlt. Estos son nombres ciertamente extraños: "POSIX" es la abreviatura de Portable Operating System Interface, que es una familia de estándares multiplataforma. "ct" representa la hora del calendario (el tipo `time_t` en C), y "lt" la hora local (el tipo `struct tm` en C). Aquí nos centraremos en `POSIXct`, porque es el más simple, está construido sobre un vector atómico y es más apropiado para usar en tramas de datos. Los vectores POSIXct se construyen sobre vectores dobles, donde el valor representa la cantidad de segundos desde 1970-01-01.

[^vectors-11]: tidyverse proporciona el paquete lubridate [@lubridate] para trabajar con fechas y horas. Proporciona una serie de útiles ayudantes que funcionan con el tipo POSIXct base.

```{r}
now_ct <- as.POSIXct("2018-08-01 22:00", tz = "UTC")
now_ct

typeof(now_ct)
attributes(now_ct)
```

El atributo `tzone` controla solo cómo se formatea la fecha y la hora; no controla el instante de tiempo representado por el vector. Tenga en cuenta que la hora no se imprime si es medianoche.

```{r}
structure(now_ct, tzone = "Asia/Tokyo")
structure(now_ct, tzone = "America/New_York")
structure(now_ct, tzone = "Australia/Lord_Howe")
structure(now_ct, tzone = "Europe/Paris")
```

### Duraciones

\index{durations|see {difftime}} \index{difftime}

Las duraciones, que representan la cantidad de tiempo entre pares de fechas o fechas-horas, se almacenan en difftimes. Los tiempos de diferencia se construyen sobre los dobles y tienen un atributo de `unidades` que determina cómo se debe interpretar el número entero:

```{r}
one_week_1 <- as.difftime(1, units = "weeks")
one_week_1

typeof(one_week_1)
attributes(one_week_1)

one_week_2 <- as.difftime(7, units = "days")
one_week_2

typeof(one_week_2)
attributes(one_week_2)
```

### Ejercicios

1.  ¿Qué tipo de objeto devuelve `table()`? ¿Cuál es su tipo? ¿Qué atributos tiene? ¿Cómo cambia la dimensionalidad a medida que tabula más variables?

2.  ¿Qué le sucede a un factor cuando modificas sus niveles?

    ```{r, results = FALSE}
    f1 <- factor(letters)
    levels(f1) <- rev(levels(f1))
    ```

3.  ¿Qué hace este código? ¿En qué se diferencian `f2` y `f3` de `f1`?

    ```{r, results = FALSE}
    f2 <- rev(factor(letters))

    f3 <- factor(letters, levels = rev(letters))
    ```

## Listas {#sec-lists}

\index{lists} \index{vectors!recursive|see {lists}} \index{vectors!generic|see {lists}}

Las listas son un paso más en complejidad que los vectores atómicos: cada elemento puede ser de cualquier tipo, no solo vectores. Técnicamente hablando, cada elemento de una lista es en realidad del mismo tipo porque, como viste en la @sec-list-references, cada elemento es realmente una *referencia* a otro objeto, que puede ser de cualquier tipo.

### Creando {#sec-list-creating}

\index{list()}

Construyes listas con `list()`:

```{r}
l1 <- list(
  1:3, 
  "a", 
  c(TRUE, FALSE, TRUE), 
  c(2.3, 5.9)
)

typeof(l1)

str(l1)
```

Dado que los elementos de una lista son referencias, crear una lista no implica copiar los componentes en la lista. Por esta razón, el tamaño total de una lista puede ser más pequeño de lo esperado.

```{r}
lobstr::obj_size(mtcars)

l2 <- list(mtcars, mtcars, mtcars, mtcars)
lobstr::obj_size(l2)
```

Las listas pueden contener objetos complejos, por lo que no es posible elegir un único estilo visual que funcione para todas las listas. En general, dibujaré listas como vectores, usando colores para recordarle la jerarquía.

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/list.png")
```

Las listas a veces se denominan vectores **recursivos** porque una lista puede contener otras listas. Esto los hace fundamentalmente diferentes de los vectores atómicos.

```{r}
l3 <- list(list(list(1)))
str(l3)
```

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/list-recursive.png")
```

`c()` combinará varias listas en una sola. Si se le da una combinación de vectores atómicos y listas, `c()` convertirá los vectores en listas antes de combinarlos. Compara los resultados de `list()` y `c()`:

```{r}
l4 <- list(list(1, 2), c(3, 4))
l5 <- c(list(1, 2), c(3, 4))
str(l4)
str(l5)
```

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/list-c.png")
```

### Pruebas y coerción {#sec-list-types}

El `typeof()` una lista es `list`. Puede probar una lista con `is.list()` y obligar a una lista con `as.list()`.

```{r}
list(1:3)
as.list(1:3)
```

Puedes convertir una lista en un vector atómico con `unlist()`. Las reglas para el tipo resultante son complejas, no están bien documentadas y no siempre son equivalentes a lo que obtendría con `c()`.

### Matrices y arreglos {#sec-list-array}

\index{lists!list-arrays} \index{arrays!list-arrays}

Con vectores atómicos, el atributo de dimensión se usa comúnmente para crear matrices. Con las listas, el atributo de dimensión se puede usar para crear matrices de listas o arreglos de listas:

```{r}
l <- list(1:3, "a", TRUE, 1.0)
dim(l) <- c(2, 2)
l

l[[1, 1]]
```

Estas estructuras de datos son relativamente esotéricas, pero pueden ser útiles si desea organizar objetos en una estructura similar a una cuadrícula. Por ejemplo, si está ejecutando modelos en una cuadrícula espacio-temporal, podría ser más intuitivo almacenar los modelos en una matriz 3D que coincida con la estructura de la cuadrícula.

### Ejercicios

1.  Enumere todas las formas en que una lista difiere de un vector atómico.

2.  ¿Por qué necesita usar `unlist()` para convertir una lista en un vector atómico? ¿Por qué no funciona `as.vector()`?

3.  Compare y contraste `c()` y `unlist()` al combinar una fecha y una fecha y hora en un solo vector.

## Data frames y tibbles {#sec-tibble}

\index{data frames} \index{tibbles|see {data frames}} \index{row.names}

Los dos vectores S3 más importantes construidos sobre las listas son los data frames y los tibbles.

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/summary-tree-s3-2.png")
```

Si realiza análisis de datos en R, utilizará data frames. Un data frame es una lista con nombre de vectores con atributos para (columna) `nombres`, `fila.nombres` [^vectors-12], y su clase, "data.frame":

[^vectors-12]: Los nombres de fila son una de las estructuras de datos más sorprendentemente complejas en R. También han sido una fuente persistente de problemas de rendimiento a lo largo de los años. La implementación más sencilla es un vector de caracteres o entero, con un elemento para cada fila. Pero también hay una representación compacta para nombres de fila "automáticos" (enteros consecutivos), creada por `.set_row_names()`. R 3.5 tiene una forma especial de diferir la conversión de enteros a caracteres que está diseñada específicamente para acelerar `lm()`; consulte <https://svn.r-project.org/R/branches/ALTREP/ALTREP.html#deferred_string_conversions> para obtener detalles.

```{r}
df1 <- data.frame(x = 1:3, y = letters[1:3])
typeof(df1)

attributes(df1)
```

A diferencia de una lista regular, un data frame tiene una restricción adicional: la longitud de cada uno de sus vectores debe ser la misma. Esto le da a los data frames su estructura rectangular y explica por qué comparten las propiedades de las matrices y las listas:

-   Un data frame tiene `rownames()`[^vectors-13] y `colnames()`. Los `names()` de un data frame son los nombres de las columnas.

-   Un data frame tiene filas `nrow()` y columnas `ncol()`. La `longitud()` de un data frame da el número de columnas.

[^vectors-13]: técnicamente, se recomienda usar `row.names()`, no `rownames()` con data frames, pero esta distinción rara vez es importante.

Los data frames son una de las ideas más grandes e importantes de R, y una de las cosas que diferencian a R de otros lenguajes de programación. Sin embargo, en los más de 20 años desde su creación, las formas en que las personas usan R han cambiado y algunas de las decisiones de diseño que tenían sentido en el momento en que se crearon los data frames ahora causan frustración.

Esta frustración condujo a la creación del tibble [@tibble], una reinvención moderna del data frame. Los Tibbles están diseñados para ser (en la medida de lo posible) reemplazos directos de los data frames que solucionan esas frustraciones. Una forma concisa y divertida de resumir las principales diferencias es que los tibbles son vagos y hoscos: hacen menos y se quejan más. Verá lo que eso significa a medida que avance en esta sección.

Los tibbles son proporcionados por el paquete tibble y comparten la misma estructura que los data frames. La única diferencia es que el vector de clase es más largo e incluye `tbl_df`. Esto permite que los tibbles se comporten de manera diferente en las formas clave que discutiremos a continuación.

```{r}
library(tibble)

df2 <- tibble(x = 1:3, y = letters[1:3])
typeof(df2)

attributes(df2)
```

### Creando {#sec-df-create}

\index{stringsAsFactors}

\index{data frames!data.frame@\texttt{data.frame()}}

Creas un data frame proporcionando pares de vector de nombre a `data.frame()`:

```{r}
df <- data.frame(
  x = 1:3, 
  y = c("a", "b", "c")
)
str(df)
```

Si está utilizando una versión de R anterior a la 4.0.0, tenga cuidado con la conversión predeterminada de cadenas a factores. Use `stringsAsFactors = FALSE` para suprimir esto y mantener los vectores de caracteres como vectores de caracteres:

```{r}
df1 <- data.frame(
  x = 1:3,
  y = c("a", "b", "c"),
  stringsAsFactors = FALSE
)
str(df1)
```

Crear un tibble es similar a crear un data frame. La diferencia entre los dos es que los tibbles nunca coaccionan su entrada (esta es una característica que los hace perezosos):

```{r}
df2 <- tibble(
  x = 1:3, 
  y = c("a", "b", "c")
)
str(df2)
```

Además, mientras que los data frames transforman automáticamente los nombres no sintácticos (a menos que `check.names = FALSE`), los tibbles no lo hacen (aunque sí imprimen nombres no sintácticos rodeados por `` ` ``).

```{r}
names(data.frame(`1` = 1))

names(tibble(`1` = 1))
```

Si bien cada elemento de un data frame (o tibble) debe tener la misma longitud, tanto `data.frame()` como `tibble()` reciclarán entradas más cortas. Sin embargo, mientras que los data frames reciclan automáticamente las columnas que son múltiplos enteros de la columna más larga, los tibbles solo reciclan vectores de longitud uno.

```{r, error = TRUE}
data.frame(x = 1:4, y = 1:2)
data.frame(x = 1:4, y = 1:3)

tibble(x = 1:4, y = 1)
tibble(x = 1:4, y = 1:2)
```

Hay una última diferencia: `tibble()` te permite referirte a las variables creadas durante la construcción:

```{r}
tibble(
  x = 1:3,
  y = x * 2
)
```

(Las entradas se evalúan de izquierda a derecha).

Al dibujar data frames y tibbles, en lugar de centrarse en los detalles de implementación, es decir, los atributos:

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/data-frame-1.png")
```

Los dibujaré de la misma manera que una lista con nombre, pero los ordenaré para enfatizar su estructura en columnas.

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/data-frame-2.png")
```

### Nombres de filas {#sec-rownames}

\index{row.names}

Los data frames le permiten etiquetar cada fila con un nombre, un vector de caracteres que contiene solo valores únicos:

```{r}
df3 <- data.frame(
  age = c(35, 27, 18),
  hair = c("blond", "brown", "black"),
  row.names = c("Bob", "Susan", "Sam")
)
df3
```

Puede obtener y establecer nombres de fila con `rownames()`, y puede usarlos para crear subconjuntos de filas:

```{r}
rownames(df3)

df3["Bob", ]
```

Los nombres de las filas surgen naturalmente si piensa en los data frames como estructuras 2D como matrices: las columnas (variables) tienen nombres, por lo que las filas (observaciones) también deberían tenerlos. La mayoría de las matrices son numéricas, por lo que es importante tener un lugar para almacenar etiquetas de caracteres. Pero esta analogía con las matrices es engañosa porque las matrices poseen una propiedad importante que los data frames no tienen: son transponibles. En las matrices, las filas y las columnas son intercambiables, y la transposición de una matriz da como resultado otra matriz (la transposición nuevamente da como resultado la matriz original). Sin embargo, con los data frames, las filas y las columnas no son intercambiables: la transposición de un data frame no es un data frame.

Hay tres razones por las que los nombres de las filas no son deseables:

-   Los metadatos son datos, por lo que almacenarlos de manera diferente al resto de los datos es fundamentalmente una mala idea. También significa que necesita aprender un nuevo conjunto de herramientas para trabajar con nombres de fila; no puede usar lo que ya sabe sobre la manipulación de columnas.

-   Los nombres de fila son una abstracción deficiente para etiquetar filas porque solo funcionan cuando una fila se puede identificar con una sola cadena. Esto falla en muchos casos, por ejemplo, cuando desea identificar una fila por un vector que no es un carácter (por ejemplo, un punto de tiempo), o con múltiples vectores (por ejemplo, posición, codificado por latitud y longitud).

-   Los nombres de las filas deben ser únicos, por lo que cualquier duplicación de filas (por ejemplo, de arranque) creará nuevos nombres de fila. Si desea hacer coincidir las filas de antes y después de la transformación, deberá realizar una complicada cirugía de hilo.

    ```{r}
    df3[c(1, 1, 1), ]
    ```

Por estas razones, los tibbles no admiten nombres de fila. En cambio, el paquete tibble proporciona herramientas para convertir fácilmente los nombres de las filas en una columna regular con `rownames_to_column()`, o el argumento `rownames` en `as_tibble()`:

```{r}
as_tibble(df3, rownames = "name")
```

### Imprimir

Una de las diferencias más obvias entre tibbles y data frames es cómo se imprimen. Supongo que ya está familiarizado con la forma en que se imprimen los data frames, por lo que aquí resaltaré algunas de las mayores diferencias utilizando un conjunto de datos de ejemplo incluido en el paquete dplyr:

```{r}
dplyr::starwars
```

-   Tibbles solo muestra las primeras 10 filas y todas las columnas que caben en la pantalla. Las columnas adicionales se muestran en la parte inferior.

-   Cada columna está etiquetada con su tipo, abreviado en tres o cuatro letras.

-   Las columnas anchas se truncan para evitar que una sola cadena larga ocupe una fila completa. (Esto todavía es un trabajo en progreso: es un compromiso complicado entre mostrar tantas columnas como sea posible y mostrar las columnas en su totalidad).

-   Cuando se usa en entornos de consola que lo admiten, el color se usa juiciosamente para resaltar información importante y restar énfasis a los detalles complementarios.

### Subconjunto {#sec-safe-subsetting}

Como aprenderá en el @sec-subsetting, puede crear un subconjunto de un data frame o un tibble como una estructura 1D (donde se comporta como una lista), o una estructura 2D (donde se comporta como una matriz).

En mi opinión, los data frames tienen dos comportamientos de subconjunto no deseados:

-   Cuando crea subconjuntos de columnas con `df[, vars]`, obtendrá un vector si `vars` selecciona una variable; de lo contrario, obtendrá un data frame. Esta es una fuente frecuente de errores cuando se usa `[` en una función, a menos que siempre recuerde usar `df[, vars, drop = FALSE]`.

-   Cuando intenta extraer una sola columna con `df$x` y no hay ninguna columna `x`, un data frame seleccionará cualquier variable que comience con `x`. Si ninguna variable comienza con `x`, `df$x` devolverá `NULL`. Esto facilita seleccionar la variable incorrecta o seleccionar una variable que no existe[^vectors-14].

[^vectors-14]: Podemos hacer que R advierta sobre este comportamiento (llamado coincidencia parcial) configurando `options(warnPartialMatchDollar = TRUE)`.

Tibbles modifica estos comportamientos para que un `[` siempre devuelva un tibble, y un `$` no haga coincidencias parciales y advierta si no puede encontrar una variable (esto es lo que hace que Tibbles sea hosco).

```{r opts, include = FALSE}
opts <- options(warnPartialMatchDollar = FALSE)
```

```{r, dependson="opts"}
df1 <- data.frame(xyz = "a")
df2 <- tibble(xyz = "a")

str(df1$x)
str(df2$x)
```

```{r, include = FALSE}
if (!is.null(opts$warnPartialMatchDollar))
  options(opts)
```

La insistencia de un tibble en devolver un data frame de `[` puede causar problemas con el código heredado, que a menudo usa `df[, "col"]` para extraer una sola columna. Si desea una sola columna, le recomiendo usar `df[["col"]]`. Esto comunica claramente su intención y funciona tanto con data frames como con tibbles.

### Pruebas y coacción {#sec-df-test-coerce}

Para verificar si un objeto es un data frame o tibble, use `is.data.frame()`:

```{r}
is.data.frame(df1)
is.data.frame(df2)
```

Por lo general, no debería importar si tiene un tibble o un data frame, pero si necesita estar seguro, use `is_tibble()`:

```{r}
is_tibble(df1)
is_tibble(df2)
```

Puede convertir un objeto en un data frame con `as.data.frame()` o en un tibble con `as_tibble()`.

### Columnas de lista

\index{data frames!list-columns} \index{I()}

Dado que un data frame es una lista de vectores, es posible que un data frame tenga una columna que sea una lista. Esto es muy útil porque una lista puede contener cualquier otro objeto: esto significa que puede colocar cualquier objeto en un data frame. Esto le permite mantener los objetos relacionados juntos en una fila, sin importar cuán complejos sean los objetos individuales. Puede ver una aplicación de esto en el capítulo "Muchos modelos" de *R para la Ciencia de Datos*, <http://r4ds.had.co.nz/many-models.html>.

Las columnas de lista están permitidas en data frames, pero debe hacer un poco de trabajo adicional agregando la columna de lista después de la creación o envolviendo la lista en `I()`[^vectors-15].

[^vectors-15]: `I()` es la abreviatura de identidad y se usa a menudo para indicar que una entrada debe dejarse como está y no transformarse automáticamente.

```{r}
df <- data.frame(x = 1:3)
df$y <- list(1:2, 1:3, 1:4)

data.frame(
  x = 1:3, 
  y = I(list(1:2, 1:3, 1:4))
)
```

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/data-frame-list.png")
```

Las columnas de lista son más fáciles de usar con tibbles porque se pueden incluir directamente dentro de `tibble()` y se imprimirán ordenadamente:

```{r}
tibble(
  x = 1:3, 
  y = list(1:2, 1:3, 1:4)
)
```

### Columnas de matriz y data frame

\index{data frames!matrix-columns}

Siempre que el número de filas coincida con el data frame, también es posible tener una matriz o arreglo como columna de un data frame. (Esto requiere una ligera extensión a nuestra definición de data frame: no es la longitud, `length()`, de cada columna lo que debe ser igual, sino el `NROW()`.) En cuanto a las columnas de lista, debe agregarlas después de la creación o envolverlas en `I()`.

```{r}
dfm <- data.frame(
  x = 1:3 * 10
)
dfm$y <- matrix(1:9, nrow = 3)
dfm$z <- data.frame(a = 3:1, b = letters[1:3], stringsAsFactors = FALSE)

str(dfm)
```

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/vectors/data-frame-matrix.png")
```

Las columnas de matrices y data frames requieren un poco de precaución. Muchas funciones que trabajan con data frames asumen que todas las columnas son vectores. Además, la pantalla impresa puede resultar confusa.

```{r}
dfm[1, ]
```

### Ejercicios

1.  ¿Puede tener un data frame con cero filas? ¿Qué pasa con las columnas cero?

2.  ¿Qué sucede si intenta establecer nombres de fila que no son únicos?

3.  Si `df` es un data frame, ¿qué puede decir acerca de `t(df)` y `t(t(df))`? Realice algunos experimentos, asegurándose de probar diferentes tipos de columnas.

4.  ¿Qué hace `as.matrix()` cuando se aplica a un data frame con columnas de diferentes tipos? ¿En qué se diferencia de `data.matrix()`?

## `NULL`

\index{NULL}

Para terminar este capítulo, quiero hablar sobre una última estructura de datos importante que está estrechamente relacionada con los vectores: `NULL`. `NULL` es especial porque tiene un tipo único, siempre tiene una longitud cero y no puede tener ningún atributo:

```{r, error = TRUE}
typeof(NULL)

length(NULL)

x <- NULL
attr(x, "y") <- 1
```

Puedes probar `NULL`s con `is.null()`:

```{r}
is.null(NULL)
```

Hay dos usos comunes de `NULL`:

-   Representar un vector vacío (un vector de longitud cero) de tipo arbitrario. Por ejemplo, si usas `c()` pero no incluyes ningún argumento, obtienes `NULL`, y concatenar `NULL` a un vector lo dejará sin cambios:

    ```{r}
    c()
    ```

-   Para representar un vector ausente. Por ejemplo, `NULL` a menudo se usa como argumento de función predeterminado, cuando el argumento es opcional pero el valor predeterminado requiere algún cálculo (consulte la @sec-missing-arguments para obtener más información al respecto). Contraste esto con `NA` que se usa para indicar que un *elemento* de un vector está ausente.

Si está familiarizado con SQL, conocerá el `NULL` relacional y puede esperar que sea igual que el de R. Sin embargo, la base de datos `NULL` es en realidad equivalente a `NA` de R.

## Respuestas de la prueba {#sec-data-structure-answers}

1.  Los cuatro tipos comunes de vectores atómicos son lógicos, enteros, dobles y de carácter. Los dos tipos más raros son complejos y crudos.

2.  Los atributos le permiten asociar metadatos adicionales arbitrarios a cualquier objeto. Puede obtener y establecer atributos individuales con `attr(x, "y")` y `attr(x, "y") <- value`; o puede obtener y establecer todos los atributos a la vez con `attributes()`.

3.  Los elementos de una lista pueden ser de cualquier tipo (incluso una lista); los elementos de un vector atómico son todos del mismo tipo. De manera similar, todos los elementos de una matriz deben ser del mismo tipo; en un data frame, diferentes columnas pueden tener diferentes tipos.

4.  Puede crear una matriz de lista asignando dimensiones a una lista. Puede convertir una matriz en una columna de un data frame con `df$x <- matrix()`, o usando `I()` al crear un nuevo data frame `data.frame(x = I(matrix()))`.

5.  Los Tibbles tienen un método de impresión mejorado, nunca obligan a las cadenas a factores y proporcionan métodos de subconjunto más estrictos.