Tutorial de reestructuración de datos en R

La reestructuración de datos en R consiste en organizar filas y columnas a tu manera para usarlas según tus necesidades. Por lo general, los datos se manejan como un data frame en R para procesarlos con funciones como "rbind()", "cbind()", etc.

En este proceso, reorganizas los datos en filas y columnas. Reestructurar significa darle a los datos el formato específico que necesitas para seguir trabajando con ellos.

Creación de tus datos

Vamos a crear un generador de números aleatorios y a construir columnas para concatenarlas en un data frame. También añadiremos un id para usarlo más adelante. "set.seed(123)" se utiliza para producir números aleatorios y garantizar que cualquiera que ejecute el código obtenga la misma muestra. Creamos tres variables: colm1, colm2, colm3. Con "sample()" generamos valores del 1 al 15 con posible repetición. El data frame almacena los datos en forma de tabla y se le añade un id, que es un número único.

set.seed(123)
N <- 15
colm1  <- sample(1:15, N, replace=TRUE)
colm2  <- sample(1:15, N, replace=TRUE)
colm3  <- sample(1:15, N, replace=TRUE)
df_Temp <- data.frame(colm1, colm2,colm3)
df_Temp$id<-seq(nrow(df_Temp))
df_Temp

El código anterior devuelve la siguiente salida, con tres columnas llamadas "colm1", "colm2", "colm3" y un id del 1 al 15. Los valores de cada columna toman números del 1 al 15: algunos se repiten y otros pueden no aparecer.

 colm1   colm2   colm3  id
  15      11     14     1
  15      5      3      2
  3       3      4      3
  14      11     14     4
  3       9      1      5
  10      12     11     6
  2       9      7      7
  6       9      5      8
  11      13     12     9
  5       3      15     10
  4       8      10     11
  14      10     13     12
  6       7      7      13
  9       10     9      14
 10       9      9      15 

Función cbind

Uso: combina vectores, matrices y data frames por columnas.
Parámetros: cbind(v1, v2): v1 y v2 pueden ser vectores, matrices o data frames.

Veamos un ejemplo práctico de combinación.

Se puede seleccionar id con "df_Temp[,4]", mientras que "df_Temp[,2]" selecciona "colm2" de df_Temp. Ambos actúan como parámetros de "cbind()" y se guardan en la variable "cbindexample". Después, los nombres de las columnas pueden cambiarse con "colnames()", que recibe el objeto y un vector con los nuevos nombres, p. ej., "newid", "new_colm2".

cbindexample<-cbind(df_Temp[,4],df_Temp[,2])
colnames(cbindexample)<- c('newid','new_colm2')
cbindexample

El código anterior produce la siguiente salida: has unido dos columnas (id y column2) con la función "cbind" para crear un nuevo data frame. Además, el nombre de la columna "colm2" ha pasado a ser "new_colm2" e "id" ha pasado a "newid".

newid   new_colm2
1         11
2         5
3         3
4         11
5         9
6         12
7         9
8         9
9         13
10         3
11         8
12         10
13         7
14         10
15         9

Función rbind:

Uso: rbind combina vectores, matrices o data frames por filas.
Parámetros: rbind(v1, v2): v1 y v2 pueden ser vectores, matrices o data frames.

Vamos a crear un nuevo vector llamado "new_vector" y a combinarlo con "cbindexample" (de 2 columnas) usando "rbind". Ambos se concatenan y se guardan en "rbindexample".

new_vector<- c(16,15)
rbindexample<- rbind(cbindexample,new_vector)
rbindexample

El código anterior genera la salida de abajo, donde se añade una nueva fila con los valores 16 y 15 en "newid" y "new_colm2", respectivamente.

newid    new_colm2
1        11
2        5
3        3
4        11
5        9
6        12
7        9
8        9
9        13
10       3
11       8
12       10
13       7
14       10
15       9
16       15

Función melt:

Uso: la función melt convierte un objeto a un estado "fundido": toma varias columnas y las transforma en una única columna.
Parámetros: melt(data, …, na.rm=FALSE/TRUE, value.name=”value” )
data: entrada que vas a fundir.
...: argumentos adicionales que se pasan.
na.rm: sirve para convertir valores ausentes explícitos en ausentes implícitos.
value.name: nombre de la columna donde se almacenarán los valores.
Veamos cómo "fundir" los datos usando la variable id para obtener una columna con el nombre de la columna original y su valor:

Importa la librería "reshape2" con "library()" y usa melt para combinar las columnas colm1, colm2, colm3 de "df_Temp" en un único lugar llamado "variable" en función de la variable "id".

library(reshape2)
molted=melt(df_Temp,id.vars=c("id"))
molted

id    variable value
1    colm1    15
2    colm1     15
3    colm1     3
4    colm1     14
5    colm1     3
6    colm1     10
7    colm1     2
8    colm1     6
9    colm1     11
10    colm1     5
11    colm1     4
12    colm1     14
13    colm1     6
14    colm1     9
15    colm1     10
1    colm2     11
2    colm2     5
3    colm2     3
4    colm2     11
5    colm2     9
6    colm2     12
7    colm2     9
8    colm2     9
9    colm2     13
10    colm2     3
11    colm2     8
12    colm2     10
13    colm2     7
14    colm2     10
15    colm2     9
1    colm3     14
2    colm3     3
3    colm3     4
4    colm3     14
5    colm3     1
6    colm3     11
7    colm3     7
8    colm3     5
9    colm3     12
10    colm3     15
11    colm3     10
12    colm3     13
13    colm3     7
14    colm3     9
15    colm3     9

La salida anterior muestra que, al fundir los datos de colm1, colm2 y colm3 según la variable id, todo se combina en una columna llamada "variable" y los valores quedan en la columna "value".

Función dcast:

Uso: cuando tienes un conjunto de datos fundido, puedes devolverlo a su formato original con esta función.
Parámetros: dcast(data, id_variable~value)
data: datos fundidos que se quieren convertir a su forma original.
id_variable: una o varias columnas usadas para fundir los datos de otras columnas en una sola.
~: tras este signo, se indican los valores o la nueva columna fundida del dataset resultante.

A continuación puedes ver el código donde se importa "reshape2" con "library()" y "dcast()" recibe como primer parámetro los datos resultantes de "melt()" y, tras la "~", el id a partir del cual se reconstruyen las columnas originales.

library(reshape2)
dcast(molted,id~variable)

id    colm1    colm2    colm3
1        15        11        14
2        15        5         3
3        3        3         4
4        14        11       14
5        3        9         1
6        10        12        11
7        2         9         7
8        6        9         5
9       11        13        12
10       5        3        15
11       4        8        10
12       14        10        13
13       6        7        7
14       9        10        9
15      10        9        9

Puedes ver que los datos fundidos con "melt()" vuelven al conjunto original. Hay tres columnas con sus valores y el id en una columna aparte.

Función de transposición:

Uso: sirve para convertir filas en columnas y columnas en filas.
Parámetros: t(data), donde data es el data frame que quieres transponer.

Vamos a cambiar filas por columnas y viceversa usando la función de transposición. Se hace simplemente con "t(df_Temp)", como se muestra abajo.

trans <- t(df_Temp)
trans

El código anterior devuelve la siguiente salida:

colm1    15    15    3    14    3    10    2    6    11    5    4    14    6    9    10
colm2    11    5    3    11    9    12    9    9    13    3    8    10    7    10    9
colm3    14    3    4    14    1    11    7    5    12    15    10    13    7    9    9
id    1    2    3    4    5    6    7    8    9    10    11    12    13    14    15

Observa que el data frame, que tenía forma de 15 filas y 4 columnas, pasa a tener 4 filas y 15 columnas tras la transposición.

Enhorabuena

¡Enhorabuena, has llegado al final de este tutorial!

En este tutorial has visto distintas funciones de R como "rbind()", "cbind()", además de "melt()", "dcast()" y, por último, la función de transposición.

Si quieres aprender más sobre R, haz el curso Introduction to R de DataCamp y echa un vistazo a nuestro R Packages: A Beginner's Tutorial.

Referencias:
Funciones melt