Tipos de datos en R

Antes de empezar con la introducción y conocer los distintos tipos de datos en R, vamos a configurar rápidamente el entorno de R tanto en el Terminal como en Jupyter Notebook.

El siguiente comando es para macOS y instalará R en tu terminal.

brew install r --build-from-source

Para comprobar que la instalación se ha realizado correctamente, escribe R (en mayúscula) en el terminal y entrarás en una sesión de R, como se muestra a continuación.

Para la instalación en otros sistemas operativos, puedes consultar este tutorial.

Ahora añadamos el lenguaje de programación R como kernel en Jupyter Notebook. Asegúrate de tener Jupyter Notebook instalado en tu sistema.

Ve al terminal, abre una sesión de R e introduce los dos comandos siguientes para añadir el kernel de R a tu Jupyter Notebook.

install.packages('IRkernel')
IRkernel::installspec()

Cuando estos dos comandos se completen con éxito, ejecuta Jupyter desde el terminal y abre un notebook con el kernel de R como se muestra a continuación:

Ya estás listo para escribir tu primer código en R en Jupyter Notebook.

Introducción

Para aprovechar R al máximo, es clave conocer y entender los distintos tipos de datos y estructuras de datos que existen en R y cómo funcionan. Son fundamentales en prácticamente cualquier problema, especialmente en machine learning, donde todo gira en torno a los datos.

En un lenguaje de programación solemos necesitar variables para almacenar información: enteros, caracteres, números con coma flotante, booleanos, etc. El tipo de la variable depende del tipo de información que contenga. Si se le asigna un entero, entonces la variable tendrá tipo de dato int. Las variables no son más que ubicaciones de memoria reservadas donde se almacenan valores. En cuanto creas una variable, se reserva espacio de memoria para ella.

En función del tipo de dato de una variable, el sistema operativo le asignará cierta memoria. Por ejemplo, en R, una variable que contiene un entero reserva 4 bytes de memoria y 1 byte para un carácter.

En lenguajes como C, C++ y Java, las variables se declaran con su tipo de dato; sin embargo, en Python y R las variables son objetos. Los objetos son estructuras de datos con algunos atributos y métodos que actúan sobre esos atributos.

En este tutorial veremos varios tipos de objetos de R o estructuras de datos como:

• Vectores

• Listas

• Matrices

• Arrays

• Factores

• Data frames

Primero entendamos algunos tipos de datos básicos sobre los que se construyen los objetos de R: numeric, integer, character, factor y logical.

• Numeric: los números con decimales o de naturaleza fraccionaria tienen tipo de dato numeric.

num <- 1.2
print(num)

[1] 1.2

Puedes comprobar el tipo de dato de a usando la palabra clave class().

class(num)

'numeric'

• Integer: los números sin parte decimal tienen tipo de dato integer. Para crear un entero explícitamente, usa as.integer() y pasa la variable como argumento.

int <- as.integer(2.2)
print(int)

[1] 2

class(int)

'integer'

• Character: como su nombre indica, puede ser una letra o una combinación de letras entre comillas; R lo considera tipo de dato character. Puede contener letras o números.

char <- "datacamp"
print(char)

[1] "datacamp"

class(char)

'character'

char <- "12345"
print(char)

[1] "12345"

class(char)

'character'

• Logical: una variable que puede tomar valores TRUE o FALSE, como un booleano, se denomina variable logical.

log_true <- TRUE
print(log_true)

[1] TRUE

class(log_true)

'logical'

log_false <- FALSE
print(log_false)

[1] FALSE

class(log_false)

'logical'

• Factor: es un tipo de dato que se usa para representar relaciones cualitativas como colores, bueno y malo, valoraciones de cursos o películas, etc. Son muy útiles en modelado estadístico.

Para ello, usarás la función c(), que devuelve un vector (unidimensional) combinando todos los elementos.

fac <- factor(c("good", "bad", "ugly","good", "bad", "ugly"))

print(fac)

[1] good bad  ugly good bad  ugly
Levels: bad good ugly

class(fac)

'factor'

El factor fac tiene tres niveles: good, bad y ugly, que puedes consultar con la palabra clave levels; el tipo de los niveles será character.

levels(fac)

1. 'bad'
2. 'good'
3. 'ugly'

nlevels(fac)

3

class(levels(fac))

'character'

Antes de continuar, veamos un par de consejos útiles que te vendrán muy bien.

• Recuerda siempre que R es sensible a mayúsculas y minúsculas. Todos los objetos definidos antes deben usarse exactamente igual, ya sea en mayúsculas o minúsculas, como se ve en este ejemplo.

Num

Error in eval(expr, envir, enclos): object 'Num' not found
Traceback:

• En R, puedes consultar todas las variables u objetos que hayas definido en el entorno de trabajo usando la palabra clave ls(), como se muestra abajo.

ls()

1. 'char'
2. 'int'
3. 'num'

Listas

A diferencia de los vectores, una lista puede contener elementos de varios tipos de datos y suele denominarse colección ordenada de valores. Puede incluir vectores, funciones, matrices e incluso otra lista dentro (lista anidada).

Las listas en R empiezan a indexar en uno; es decir, el índice comienza en uno.

Veamos el concepto de listas con un ejemplo rápido que guardará tres tipos de datos distintos en una misma lista.

lis1 <- 1:5  # vector integer
lis1

1. 1
2. 2
3. 3
4. 4
5. 5

lis2 <- factor(1:5)  # vector factor
lis2

1. 1
2. 2
3. 3
4. 4
5. 5

lis3 <- letters[1:5]  # vector character
lis3

1. 'a'
2. 'b'
3. 'c'
4. 'd'
5. 'e'

combined_list <- list(lis1, lis2, lis3)

combined_list

1. 1. 1
   2. 2
   3. 3
   4. 4
   5. 5
   1. 1
   2. 2
   3. 3
   4. 4
   5. 5
2. Niveles:

   1. '1'
   2. '2'
   3. '3'
   4. '4'
   5. '5'
   1. 'a'
   2. 'b'
   3. 'c'
   4. 'd'
   5. 'e'

Accedamos ahora a cada vector de la lista por separado. Para ello usarás dobles corchetes, ya que los tres vectores están en el mismo nivel dentro de la lista. python combined_list[[1]]

1. 1
2. 2
3. 3
4. 4
5. 5

python combined_list[[2]]

1. 1
2. 2
3. 3
4. 4
5. 5

combined_list[[3]]

1. 'a'
2. 'b'
3. 'c'
4. 'd'
5. 'e'

Ahora intentemos acceder al quinto elemento del tercer vector, que devuelve la letra e.

combined_list[[3]][5]

'e'

Por último, probemos a aplanar la lista. Algo importante a recordar: como combined_list combina datos de tipo character y numeric, el tipo character tiene prioridad y el tipo de dato de toda la lista pasará a ser character.

flat_list <- unlist(combined_list)

class(flat_list)

'character'

flat_list

1. '1'
2. '2'
3. '3'
4. '4'
5. '5'
6. '1'
7. '2'
8. '3'
9. '4'
10. '5'
11. 'a'
12. 'b'
13. 'c'
14. 'd'
15. 'e'

length(flat_list)

15

Vectores

Los vectores son objetos que almacenan múltiples valores del mismo tipo de dato. Un vector no puede mezclar integer y character. Por ejemplo, si quieres guardar las notas totales de 100 estudiantes, en vez de crear 100 variables, crearías un vector de longitud 100 que almacene todas las notas.

Un vector se crea con la función c(), que combina todos los elementos y devuelve un array unidimensional.

Creemos un vector marks con datos de cinco estudiantes de clase numeric.

marks <- c(88,65,90,40,65)

class(marks)

'numeric'

Comprobemos la longitud del vector, que debe devolver el número de elementos que contiene.

length(marks)

5

Ahora intentemos acceder a un elemento concreto por su índice.

marks[4]

40

marks[5]

65

marks[6] #devuelve NA porque no hay sexto elemento en el vector

<NA>

• Slicing: igual que en Python, el concepto de slicing también se puede aplicar en R.

  Intentemos acceder a los elementos del segundo al quinto usando slicing.

marks[2:5]

1. 65
2. 90
3. 40
4. 65

Ahora creemos un vector de tipo character, de forma similar a como creamos el numérico.

char_vector <- c("a", "b", "c")
print(char_vector)

[1] "a" "b" "c"

class(char_vector)

'character'

length(char_vector)

3

char_vector[1:3]

1. 'a'
2. 'b'
3. 'c'

Si creamos un vector que contenga valores numéricos y de texto, los numéricos se convertirán a tipo character.

char_num_vec <- c(1,2, "a")

char_num_vec

1. '1'
2. '2'
3. 'a'

class(char_num_vec)

'character'

Creemos un vector con 1024 valores numéricos con ayuda del concepto de slicing.

vec <- c(1:1024)

Ahora intenta acceder al elemento central y al último. Para ello usarás la función length.

vec[length(vec)]

1024

vec[length(vec)/2]

512

• ¿Cómo creas un vector de números impares?

Para crear un vector de impares, puedes usar la función seq, que recibe tres parámetros: inicio, fin y salto.

seq(1,10, by = 2)

1. 1
2. 3
3. 5
4. 7
5. 9

Matriz

Al igual que un vector, una matriz sirve para almacenar información del mismo tipo de dato. Sin embargo, a diferencia de los vectores, las matrices contienen información bidimensional.

La sintaxis para definir una matriz es:

M <- matrix(vector, nrow=r, ncol=c, byrow=FALSE, dimnames=list(char_vector_rownames, char_vector_colnames))

byrow=TRUE indica que la matriz debe rellenarse por filas. byrow=FALSE indica que debe rellenarse por columnas (valor predeterminado).

Definamos rápidamente una matriz M de forma 2×3.

M = matrix( c('AI','ML','DL','Tensorflow','Pytorch','Keras'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

     [,1]         [,2]      [,3]   
[1,] "AI"         "ML"      "DL"   
[2,] "Tensorflow" "Pytorch" "Keras"

Usemos ahora slicing para obtener elementos por fila y columna.

M[1:2,1:2] #la primera dimensión selecciona ambas filas y la segunda selecciona
#elementos de la 1.ª y 2.ª columna

Data frame

A diferencia de una matriz, los data frames son una forma más generalizada. Contienen datos en formato tabular. Los datos de un data frame pueden repartirse en varias columnas con distintos tipos de datos. La primera columna puede ser character, la segunda integer y la tercera logical.

Las variables o características están en columnas, también conocidas como header, mientras que las observaciones están en filas; el primer elemento es el nombre de la fila seguido de los datos reales, también llamadas filas de datos.

Un data frame puede crearse con la función data.frame().

Los data frames se utilizan ampliamente para leer archivos separados por comas (CSV) y archivos de texto. Su uso no se limita a la lectura: también puedes emplearlos en problemas de machine learning, especialmente con datos numéricos. Son útiles para entender los datos, hacer data wrangling, y para trazar y visualizar.

Creemos un conjunto de datos de ejemplo y veamos algunas funciones específicas de data frame.

dataset <- data.frame(
   Person = c("Aditya", "Ayush","Akshay"),
   Age = c(26, 26, 27),
   Weight = c(81,85, 90),
   Height = c(6,5.8,6.2),
   Salary = c(50000, 80000, 100000)
)

print(dataset)

  Person Age Weight Height Salary
1 Aditya  26     81    6.0  5e+04
2  Ayush  26     85    5.8  8e+04
3 Akshay  27     90    6.2  1e+05

class(dataset)

'data.frame'

nrow(dataset) # te devuelve el número de filas del data frame dataset

3

ncol(dataset) # te devuelve el número de columnas del data frame dataset

5

df1 = rbind(dataset, dataset) # row bind: añade los argumentos en forma de filas.

df1

df2 = cbind(dataset, dataset) # column bind: añade los argumentos en forma de columnas.

df2

Veamos la función head, muy útil cuando tienes millones de registros y quieres ver solo las primeras filas. De forma similar, tail devuelve las últimas filas.

head(df1,3) # aquí solo se imprimirán tres filas

str(dataset) # devuelve la clase o tipo de dato individual de cada columna.

'data.frame':    3 obs. of  5 variables:
 $ Person: Factor w/ 3 levels "Aditya","Akshay",..: 1 3 2
 $ Age   : num  26 26 27
 $ Weight: num  81 85 90
 $ Height: num  6 5.8 6.2
 $ Salary: num  5e+04 8e+04 1e+05

Ahora veamos la función summary(), muy útil cuando quieres entender las estadísticas de tu conjunto de datos. Como verás a continuación, divide tus datos en tres cuartiles, a partir de los cuales puedes intuir la distribución. También muestra si hay valores ausentes en tu dataset.

summary(dataset)

    Person       Age            Weight          Height        Salary      
 Aditya:1   Min.   :26.00   Min.   :81.00   Min.   :5.8   Min.   : 50000  
 Akshay:1   1st Qu.:26.00   1st Qu.:83.00   1st Qu.:5.9   1st Qu.: 65000  
 Ayush :1   Median :26.00   Median :85.00   Median :6.0   Median : 80000  
            Mean   :26.33   Mean   :85.33   Mean   :6.0   Mean   : 76667  
            3rd Qu.:26.50   3rd Qu.:87.50   3rd Qu.:6.1   3rd Qu.: 90000  
            Max.   :27.00   Max.   :90.00   Max.   :6.2   Max.   :100000  

Conclusión

Enhorabuena por completar el tutorial.

Este tutorial es un buen punto de partida para quienes tienen curiosidad por aprender el lenguaje R. Como buen ejercicio, te animamos a explorar más funciones de ayuda relacionadas con cada tipo de dato.

Queda mucha información por descubrir en R: condicionales y control de flujo, utilidades en R y, la más emocionante, machine learning con R. Todo ello se cubrirá en próximos tutoriales, ¡así que permanece atento!

No dudes en dejar cualquier pregunta relacionada con este tutorial en la sección de comentarios.

Si quieres aprender más sobre R, haz el curso Intermediate R de DataCamp y consulta el tutorial Introducción a los data frames en R.