Tutorial de Dplyr: fusionar y unir datos en R con ejemplos

Introducción al análisis de datos

El análisis de datos se puede dividir en tres partes:

• Extracción: Primero, necesitamos recopilar datos de muchas fuentes y combinarlas.
• Transformar: Este paso implica la manipulación de datos. Una vez que hayamos consolidado todas las fuentes de datos, podemos comenzar a limpiar los datos.
• Visualizar: El último paso es visualizar nuestros datos para comprobar la irregularidad.

Uno de los desafíos más importantes que enfrentan los científicos de datos es la manipulación de datos. Los datos nunca están disponibles en el formato deseado. Los científicos de datos necesitan dedicar al menos la mitad de su tiempo a limpiar y manipular los datos. Ésa es una de las tareas más críticas del trabajo. Si el proceso de manipulación de datos no es completo, preciso y riguroso, el modelo no funcionará correctamente.

R Dplyr

R tiene una biblioteca llamada dplyr para ayudar en la transformación de datos. La biblioteca dplyr se crea fundamentalmente en torno a cuatro funciones para manipular los datos y cinco verbos para limpiar los datos. Después de eso, podemos usar la biblioteca ggplot para analizar y visualizar los datos.

Aprenderemos cómo usar la biblioteca dplyr para manipular un Marco de datos.

Fusionar datos con R Dplyr

dplyr proporciona una forma agradable y cómoda de combinar conjuntos de datos. Es posible que tengamos muchas fuentes de datos de entrada y, en algún momento, necesitemos combinarlas. Una combinación con dplyr agrega variables a la derecha del conjunto de datos original.

Dplyr se une

A continuación se presentan cuatro tipos importantes de uniones utilizadas en dplyr para fusionar dos conjuntos de datos:

Función	Objetivo	Argumentos	Llaves múltiples
unión_izquierda()	Fusionar dos conjuntos de datos. Mantener todas las observaciones de la tabla de origen.	datos, origen, destino, por = “ID”	origen, destino, por = c(“ID”, “ID2”)
unión_derecha()	Fusionar dos conjuntos de datos. Mantener todas las observaciones de la tabla de destino.	datos, origen, destino, por = “ID”	origen, destino, por = c(“ID”, “ID2”)
unir internamente()	Fusionar dos conjuntos de datos. Excluye todas las filas no coincidentes	datos, origen, destino, por = “ID”	origen, destino, por = c(“ID”, “ID2”)
unión_completa()	Fusionar dos conjuntos de datos. Mantiene todas las observaciones.	datos, origen, destino, por = “ID”	origen, destino, por = c(“ID”, “ID2”)

Estudiaremos todos los tipos de uniones mediante un ejemplo sencillo.

En primer lugar, construimos dos conjuntos de datos. La Tabla 1 contiene dos variables, ID e y, mientras que la Tabla 2 reúne ID y z. En cada situación, necesitamos tener un Par de claves variable. En nuestro caso, la identificación es nuestra clave variable. La función buscará valores idénticos en ambas tablas y vinculará los valores devueltos a la derecha de la tabla 1.

library(dplyr)
df_primary <- tribble(
  ~ID, ~y,
   "A", 5,
   "B", 5,
   "C", 8,
   "D", 0,
  "F", 9)
df_secondary <- tribble(
  ~ID, ~z,
   "A", 30,
   "B", 21,
   "C", 22,
   "D", 25,
   "E", 29)

Dplyr left_join()

La forma más común de fusionar dos conjuntos de datos es utilizar la función left_join(). Podemos ver en la imagen a continuación que el par de claves coincide perfectamente con las filas A, B, C y D de ambos conjuntos de datos. Sin embargo, sobran E y F. ¿Cómo tratamos estas dos observaciones? Con left_join(), mantendremos todas las variables en la tabla original y no consideraremos las variables que no tienen un par de claves en la tabla de destino. En nuestro ejemplo, la variable E no existe en la tabla 1. Por lo tanto, la fila se eliminará. La variable F proviene de la tabla de origen; se mantendrá después de left_join() y devolverá NA en la columna z. La siguiente figura reproduce lo que sucederá con left_join().

Ejemplo de dplyr left_join()

left_join(df_primary, df_secondary, by ='ID')

Salida:

## 
# A tibble: 5 x 3
##      ID   y.x   y.y
##   <chr> <dbl> <dbl>		
## 1     A     5    30
## 2     B     5    21
## 3     C     8    22
## 4     D     0    25
## 5     F     9    NA

Dplyr right_join()

La función right_join() funciona exactamente como left_join(). La única diferencia es que se eliminó la fila. El valor E, disponible en el marco de datos de destino, existe en la nueva tabla y toma el valor NA para la columna y.

Ejemplo de dplyr right_join()

right_join(df_primary, df_secondary, by = 'ID')

Salida:

##
# A tibble: 5 x 3
##      ID   y.x   y.y
##   <chr> <dbl> <dbl>
## 1     A     5    30
## 2     B     5    21
## 3     C     8    22
## 4     D     0    25
## 5     E    NA    29

Dplyr unión_interna()

Cuando estemos 100% seguros de que los dos conjuntos de datos no coincidirán, podemos considerar regresar only filas existentes en ambas conjunto de datos. Esto es posible cuando necesitamos un conjunto de datos limpio o cuando no queremos imputar valores faltantes con la media o la mediana.

Inner_join() viene a ayudar. Esta función excluye las filas no coincidentes.

Ejemplo de dplyr internal_join()

inner_join(df_primary, df_secondary, by ='ID')

Salida:

## 
# A tibble: 4 x 3
##      ID   y.x   y.y
##   <chr> <dbl> <dbl>
## 1     A     5    30
## 2     B     5    21
## 3     C     8    22
## 4     D     0    25

dplyr full_join()

Finalmente, la función full_join() mantiene todas las observaciones y reemplaza los valores faltantes con NA.

Ejemplo de dplyr full_join()

full_join(df_primary, df_secondary, by = 'ID')

Salida:

## # A tibble: 6 x 3
##      ID   y.x   y.y
##   <chr> <dbl> <dbl>
## 1     A     5    30
## 2     B     5    21
## 3     C     8    22
## 4     D     0    25
## 5     F     9    NA
## 6     E    NA    29

Múltiples pares de claves

Por último, pero no por ello menos importante, podemos tener varias claves en nuestro conjunto de datos. Considere el siguiente conjunto de datos donde tenemos años o una lista de productos comprados por el cliente.

Si intentamos fusionar ambas tablas, R arroja un error. Para solucionar la situación, podemos pasar dos variables de pares de claves, es decir, ID y año, que aparecen en ambos conjuntos de datos. Podemos utilizar el siguiente código para fusionar la tabla 1 y la tabla 2

df_primary <- tribble(
  ~ID, ~year, ~items,
  "A", 2015,3,
  "A", 2016,7,
  "A", 2017,6,
  "B", 2015,4,
  "B", 2016,8,
  "B", 2017,7,
  "C", 2015,4,
  "C", 2016,6,
  "C", 2017,6)
df_secondary <- tribble(
  ~ID, ~year, ~prices,
  "A", 2015,9,
  "A", 2016,8,
  "A", 2017,12,
  "B", 2015,13,
  "B", 2016,14,
  "B", 2017,6,
  "C", 2015,15,
  "C", 2016,15,
  "C", 2017,13)
left_join(df_primary, df_secondary, by = c('ID', 'year'))

Salida:

## # A tibble: 9 x 4
##      ID  year items prices
##   <chr> <dbl> <dbl>  <dbl>
## 1     A  2015     3      9
## 2     A  2016     7      8
## 3     A  2017     6     12
## 4     B  2015     4     13
## 5     B  2016     8     14
## 6     B  2017     7      6
## 7     C  2015     4     15
## 8     C  2016     6     15
## 9     C  2017     6     13

Funciones de limpieza de datos en R

A continuación se presentan las cuatro funciones importantes para ordenar (limpiar) los datos:

Función	Objetivo	Argumentos
recolectar()	Transforma los datos de ancho a largo	(datos, clave, valor, na.rm = FALSO)
desparramar()	Transforme los datos de largo a ancho	(datos, clave, valor)
separado()	Dividir una variable en dos	(datos, col, dentro, sep= “”, eliminar = VERDADERO)
unidad()	Unir dos variables en una	(datos, col, conc, sep= “”, eliminar = VERDADERO)

Usamos la biblioteca tidyr. Esta biblioteca pertenece a la colección de la biblioteca para manipular, limpiar y visualizar los datos. Si instalamos R con anaconda, la biblioteca ya está instalada. Podemos encontrar la biblioteca aquí, https://anaconda.org/r/r-tidyr.

Si aún no está instalado, ingrese el siguiente comando para instalar tidyr:

install tidyr : install.packages("tidyr")

recolectar()

El objetivo de la función together() es transformar los datos de ancho a largo.

Sintaxis

gather(data, key, value, na.rm = FALSE)
Arguments:
-data: The data frame used to reshape the dataset 
-key: Name of the new column created
-value: Select the columns used to fill the key column
-na.rm: Remove missing values. FALSE by default

Ejemplo

A continuación, podemos visualizar el concepto de remodelación de ancho a largo. Queremos crear una sola columna llamada crecimiento, llena con las filas de las variables del trimestre.

library(tidyr)
# Create a messy dataset
messy <- data.frame(
  country = c("A", "B", "C"),
  q1_2017 = c(0.03, 0.05, 0.01),
  q2_2017 = c(0.05, 0.07, 0.02),
  q3_2017 = c(0.04, 0.05, 0.01),
  q4_2017 = c(0.03, 0.02, 0.04))
messy

Salida:

##   country q1_2017 q2_2017 q3_2017 q4_2017
## 1       A    0.03    0.05    0.04    0.03
## 2       B    0.05    0.07    0.05    0.02
## 3       C    0.01    0.02    0.01    0.04

# Reshape the data
tidier <-messy %>%
gather(quarter, growth, q1_2017:q4_2017)
tidier

Salida:

##    country quarter growth
## 1        A q1_2017   0.03
## 2        B q1_2017   0.05
## 3        C q1_2017   0.01
## 4        A q2_2017   0.05
## 5        B q2_2017   0.07
## 6        C q2_2017   0.02
## 7        A q3_2017   0.04
## 8        B q3_2017   0.05
## 9        C q3_2017   0.01
## 10       A q4_2017   0.03
## 11       B q4_2017   0.02
## 12       C q4_2017   0.04

En la función recopilar(), creamos dos nuevas variables, trimestre y crecimiento, porque nuestro conjunto de datos original tiene una variable de grupo: es decir, país y pares clave-valor.

desparramar()

La función spread() hace lo contrario de reunir.

Sintaxis

spread(data, key, value)
arguments: 
data: The data frame used to reshape the dataset
key: Column to reshape long to wide
value: Rows used to fill the new column

Ejemplo

Podemos remodelar el conjunto de datos más ordenado y volverlo desordenado con spread()

# Reshape the data
messy_1 <- tidier %>%
  spread(quarter, growth) 
messy_1

Salida:

##   country q1_2017 q2_2017 q3_2017 q4_2017
## 1       A    0.03    0.05    0.04    0.03
## 2       B    0.05    0.07    0.05    0.02
## 3       C    0.01    0.02    0.01    0.04

separado()

La función separa() divide una columna en dos según un separador. Esta función es útil en algunas situaciones donde la variable es una fecha. Nuestro análisis puede requerir centrarse en el mes y el año y queremos separar la columna en dos nuevas variables.

Sintaxis

separate(data, col, into, sep= "", remove = TRUE)
arguments:
-data: The data frame used to reshape the dataset 
-col: The column to split
-into: The name of the new variables
-sep: Indicates the symbol used that separates the variable, i.e.:  "-", "_", "&"
-remove: Remove the old column. By default sets to TRUE.

Ejemplo

Podemos dividir el trimestre del año en el conjunto de datos más ordenado aplicando la función separa().

separate_tidier <-tidier %>%
separate(quarter, c("Qrt", "year"), sep ="_")
head(separate_tidier)

Salida:

##   country Qrt year growth
## 1       A  q1 2017   0.03
## 2       B  q1 2017   0.05
## 3       C  q1 2017   0.01
## 4       A  q2 2017   0.05
## 5       B  q2 2017   0.07
## 6       C  q2 2017   0.02

unir()

La función unir() concana dos columnas en una.

Sintaxis

unit(data, col, conc ,sep= "", remove = TRUE)
arguments:
-data: The data frame used to reshape the dataset 
-col: Name of the new column
-conc: Name of the columns to concatenate
-sep: Indicates the symbol used that unites the variable, i.e:  "-", "_", "&"
-remove: Remove the old columns. By default, sets to TRUE

Ejemplo

En el ejemplo anterior, separamos el trimestre del año. ¿Qué sucede si queremos fusionarlos? Usamos el siguiente código:

unit_tidier <- separate_tidier %>%
  unite(Quarter, Qrt, year, sep ="_")
head(unit_tidier)

Salida:

##   country Quarter growth
## 1       A q1_2017   0.03
## 2       B q1_2017   0.05
## 3       C q1_2017   0.01
## 4       A q2_2017   0.05
## 5       B q2_2017   0.07
## 6       C q2_2017   0.02

Resumen

• El análisis de datos Se puede dividir en tres partes: Extracción, Transformación y Visualización.
• R tiene una biblioteca llamada dplyr para ayudar en la transformación de datos. La biblioteca dplyr se crea fundamentalmente en torno a cuatro funciones para manipular los datos y cinco verbos para limpiar los datos.
• dplyr proporciona una forma agradable y cómoda de combinar conjuntos de datos. Una combinación con dplyr agrega variables a la derecha del conjunto de datos original.
• La belleza de dplyr es que maneja cuatro tipos de uniones similares a SQL:
• unión_izquierda() – Fusionar dos conjuntos de datos y mantener todas las observaciones de la tabla de origen.
• unión_derecha() – Para fusionar dos conjuntos de datos y mantener todas las observaciones de la tabla de destino.
• unir internamente() – Para fusionar dos conjuntos de datos y excluir todas las filas no coincidentes.
• unión_completa() – Fusionar dos conjuntos de datos y conservar todas las observaciones.
• Usando la biblioteca tidyr, puedes transformar un conjunto de datos usando las siguientes funciones:
• recolectar(): transforma los datos de ancho a largo.
• desparramar(): transforma los datos de largo a ancho.
• separado(): Divide una variable en dos.
• unidad(): Une dos variables en una.