Tipos de datos + Estructura

Una de las fuentes más comunes de frustración para los principiantes en R es lidiar con diferentes estructuras y tipos de datos. Aquí se presenta una descripción general de las estructuras de datos y tipos más importantes y cómo comprobar y manipularlos.

Los términos ‘estructura’ y ‘tipo’ a menudo se utilizan indistintamente. Para evitar confusiones, en esta página de ayuda, la estructura de datos se refiere a si los datos son un vector, matriz o marco de datos, etc., y el tipo se refiere a si los datos o variables son enteros, caracteres o numéricos, etc.

Datos unidimensionales (vectores)

La estructura de datos más básica en R es un vector, un conjunto unidimensional de números o caracteres. Esta es la estructura de datos con la que trabajarás más a menudo, aunque desde dentro de un marco de datos (ver más abajo). Los vectores pueden ser atómicos o listas, los vectores atómicos difieren de las listas en que todos los elementos dentro de un vector atómico deben ser del mismo tipo (ver más abajo). En su mayor parte, trabajamos con vectores atómicos y el siguiente archivo de ayuda se refiere a este tipo de datos.

Tipos comunes de vectores

Los tipos comunes de vectores atómicos son lógicos, enteros, numéricos (es decir, dobles), caracteres y factores. Puedes crear fácilmente cada uno de estos tipos de datos utilizando c(). En el ejemplo de enteros, la L obliga a R a considerar esos números como enteros en lugar de numéricos.

eg_logical <- c(T, T, T, F, F)
eg_integer <- c(1L, 6L, 1L, 5L, 4L)
eg_numeric <- c(0, 2.3, 2.45, 2.99, -1.1)
eg_character <- c("things", "in", "apostrophe", "are", "characters")
eg_factor <- factor(c("NSW", "NSW", "ACT", "WA", "WA"))

Factores (un tipo de datos especial)

Observa cómo no pude simplemente usar c() para crear un factor. Aunque los factores se ven (y se comportan en su mayor parte) como caracteres, en realidad son un tipo especial de entero con categorías predefinidas, conocidas como niveles. El factor en este ejemplo tiene tres niveles: NSW, ACT y WA.

Puedes verificar cuántos niveles tiene cualquier factor usando:

levels(eg_factor)

[1] "ACT" "NSW" "WA" 

Esto los hace comportarse de manera diferente a los enteros. Una vez creados, los factores solo pueden contener un conjunto predefinido de niveles. Por ejemplo, si recolecta datos de sitios en toda Australia, podría tener el número fijo de estados como un factor, pero sería mejor tener una variable como sitio como un carácter si planea agregar datos de más sitios más adelante.

Por defecto, R siempre ordenará los niveles en orden alfabético. Si desea que sus factores estén ordenados (es decir, pequeño, medio, alto), use ordered para definir la secuencia que le gustaría que se presenten los niveles. Esto es particularmente útil para gráficos para presentar las categorías a lo largo de un eje x en un orden más lógico.

sizes <- factor(c("small", "large", "large", "small", "medium"))
sizes
## [1] small  large  large  small  medium
## Levels: large medium small
sizes <- ordered(sizes, levels = c("small", "medium", "large"))
sizes
## [1] small  large  large  small  medium
## Levels: small < medium < large

Revición de tipos de datos

Puedes comprobar el tipo de dato de cualquier vector usando las funciones class o is.

Consulta aquí para obtener más información sobre factores ordenados.

Checking data types

You can check the data type of any vector using the class or is functions.

class(eg_logical)
## [1] "logical"
is.integer(eg_integer)
## [1] TRUE
is.factor(eg_factor)
## [1] TRUE

Conversión automática

Como todos los elementos dentro de un vector atómico deben ser del mismo tipo, combinar diferentes tipos hará que los datos se conviertan al tipo más flexible. Los tipos de menor a mayor flexibilidad son: lógico - logical, entero - integer, doble - double y caracter - character. Por ejemplo, combinar enteros y caracteres producirá un vector de caracteres. Esto es algo que debes tener en cuenta al manipular tus propios datos, especialmente cuando se fusionan data frames.

eg_coerced <- c("tricks", 1, 2, 3, 4)
class(eg_coerced)
## [1] "character"

Conversión de datos

Si descubre que sus datos tienen el tipo equivocado, puede utilizar las funciones as para convertir los datos de un tipo a otro. Tenga en cuenta lo que sucede con sus datos después de la conversión. Por ejemplo, la conversión de lógicos a numéricos reemplaza F con 0 y T con 1, y cualquier conversión insensata (como tratar de convertir el carácter “NSW” en un número) resultará en NAs.

as.numeric(eg_logical)
## [1] 1 1 1 0 0
as.numeric(eg_character)
## Warning: NAs introducidos por coerción
## [1] NA NA NA NA NA

Datos bidimensionales (matrices y marcos de datos)

En su mayor parte, tendemos a trabajar con datos bidimensionales que contienen tanto columnas como filas. Al igual que los vectores unidimensionales, vienen en dos formas: matrices, donde todos los vectores deben ser del mismo tipo de datos, y marcos de datos, que pueden estar compuestos por vectores que contienen diferentes tipos de datos.

Matrices

Las matrices se construyen fácilmente en R y se puede verificar si es una matriz utilizando la función class. Por ejemplo, para hacer una matriz con 3 filas y 2 columnas con 6 valores:

eg_matrix <- matrix(c(1, 2, 3, 4, 5, 6), nrow = 3, ncol = 2)

     [,1] [,2]
[1,]    1    4
[2,]    2    5
[3,]    3    6

Piensa en matrices como vectores atómicos con dimensiones; el número de filas y columnas. Al igual que las matrices atómicas, puedes verificar el tipo de datos con is y convertirlo usando las funciones as.

is.logical(eg_matrix)
## [1] FALSE
as.numeric(eg_logical)
## [1] 1 1 1 0 0

Data frames

La estructura de datos más común con la que trabajamos es el marco de datos (data frame en inglés). Los marcos de datos son simplemente una colección de vectores atómicos de igual longitud juntos. Son diferentes a las matrices ya que pueden contener vectores de diferentes tipos.

Para crear un marco de datos simple que combine tres de los vectores que hicimos anteriormente, podríamos usar:

eg_data_frame <- data.frame(eg_character, eg_factor, eg_numeric)

  eg_character eg_factor eg_numeric
1       things       NSW       0.00
2           in       NSW       2.30
3   apostrophe       ACT       2.45
4          are        WA       2.99
5   characters        WA      -1.10

Más comúnmente, importamos datos ingresados en una hoja de cálculo directamente en un marco de datos usando read.csv (consulte la ayuda Importación de datos).

Para verificar los tipos de datos dentro de un marco de datos, use la función str. Esto da una lista de salida para cada columna (es decir, variables) y el tipo de datos correspondiente.

str(eg_data_frame)

'data.frame':   5 obs. of  3 variables:
 $ eg_character: chr  "things" "in" "apostrophe" "are" ...
 $ eg_factor   : Factor w/ 3 levels "ACT","NSW","WA": 2 2 1 3 3
 $ eg_numeric  : num  0 2.3 2.45 2.99 -1.1

Ten en cuenta que los tipos de datos pueden cambiar. En este ejemplo, el vector de caracteres ha sido convertido en un factor en el proceso de crear el marco de datos.

Si deseas verificar el tipo de datos de una sola variable, o cambiar esa variable a otro tipo, utilizamos $ para acceder a esa variable desde dentro del marco de datos. Por ejemplo:

str(eg_data_frame$eg_character)
##  chr [1:5] "things" "in" "apostrophe" "are" "characters"
levels(eg_data_frame$eg_factor)
## [1] "ACT" "NSW" "WA"
is.numeric(eg_data_frame$numeric)
## [1] FALSE

Ayuda adicional

Puedes encontrar más información sobre los tipos de datos en R aquí y aquí.

Autor: Keryn Bain - 2016