Combinar dataframe en R

Para combinar dos data frames en R, primero decide si quieres agregar registros o relacionar registros mediante una clave. Usa rbind() cuando ambas entradas contengan el mismo tipo de registros y columnas compatibles; usa dplyr::bind_rows() cuando quieras apilar filas e incluir columnas que solo aparezcan en una de las entradas. Usa plyr::join() o merge() de R base cuando debas emparejar filas mediante una clave, como un ID. Los ejemplos siguientes usan tablas pequeñas para que puedas adaptar los nombres de columnas y los valores a tus datos.

Cómo combinar dos data frames en R con la función rbind()

La función rbind() de R base añade las filas de un data frame después de las del otro. Las entradas deben tener las mismas columnas, con nombres coincidentes y valores compatibles. Los nombres coincidentes importan más que el orden de las columnas: rbind() las alinea por nombre, de modo que los valores se mantienen bajo los encabezados correspondientes. No crea una unión de columnas con nombres diferentes ni completa por sí sola los campos ausentes. Si las entradas representan campos distintos, normaliza primero su estructura o usa bind_rows().

Este ejemplo crea dos tablas con la misma estructura y luego apila sus registros con rbind():

x <- data.frame(
  id = c(1, 2),
  score = c(88, 91)
)
y <- data.frame(
  id = c(3, 4),
  score = c(85, 96)
)

combined <- rbind(x, y)
print(combined)

  id score
1  1    88
2  2    91
3  3    85
4  4    96

Cada fila del resultado es otra observación de las mismas variables. Las filas de la primera tabla aparecen primero, seguidas por las de la segunda. Para data frames con conjuntos de campos diferentes, usa bind_rows() para que los valores ausentes se representen como NA.

Cómo combinar dos data frames en R con el paquete dplyr

El paquete dplyr ofrece bind_rows() para apilar registros cuando los data frames de entrada tienen columnas diferentes. La función empareja las columnas por nombre e incluye las que aparecen en cualquiera de las entradas; las filas sin valor para una columna reciben NA. Esto resulta útil cuando dos fuentes describen el mismo tipo de registro, pero una contiene un campo adicional. Sigue siendo una operación de apilado de filas: no empareja registros por ID.

Instala dplyr con install.packages("dplyr") para usar dplyr::bind_rows() en tu propio script. El ejemplo prefiere esa función cuando el paquete está instalado; de lo contrario, recurre a una alternativa pequeña de R base que alinea las columnas con el mismo nombre y completa con NA los valores ausentes, por lo que puede ejecutarse sin instalar otro paquete.

first <- data.frame(id = 1, score = 88)
second <- data.frame(id = 2, group = "B")

if (requireNamespace("dplyr", quietly = TRUE)) {
  combined <- dplyr::bind_rows(first, second)
} else {
  columns <- union(names(first), names(second))
  align_columns <- function(data) {
    for (column in setdiff(columns, names(data))) data[[column]] <- NA
    data[columns]
  }
  combined <- rbind(align_columns(first), align_columns(second))
}

cat("id score group\n")
for (i in seq_len(nrow(combined))) {
  score <- if (is.na(combined$score[i])) "NA" else as.character(combined$score[i])
  group <- if (is.na(combined$group[i])) "NA" else combined$group[i]
  cat(paste(combined$id[i], score, group), "\n", sep = "")
}

id score group
1 88 NA
2 NA B

Cómo combinar dos data frames en R con el paquete plyr

La función join() del paquete plyr combina filas relacionadas mediante columnas clave; es una unión, no un apilado de filas. Asigna la clave compartida a by. Con type = "inner", el resultado conserva solo las claves presentes en ambas entradas; el valor predeterminado, type = "left", conserva todas las filas de la primera entrada. Instala plyr con install.packages("plyr") para usar plyr::join() en tu propio script. El ejemplo prefiere esa función cuando está disponible y, en caso contrario, usa merge() de R base para obtener el mismo resultado de unión interna. Consulta ?plyr::join en el paquete instalado si eliges otro tipo de unión.

people <- data.frame(id = c(1, 2), name = c("Ada", "Ben"))
ages <- data.frame(id = c(2, 3), age = c(25, 30))

if (requireNamespace("plyr", quietly = TRUE)) {
  matched <- plyr::join(people, ages, by = "id", type = "inner")
} else {
  matched <- merge(people, ages, by = "id")
}

cat("id name age\n")
for (i in seq_len(nrow(matched))) {
  cat(paste(matched$id[i], matched$name[i], matched$age[i]), "\n", sep = "")
}

id name age
2 Ben 25

Cómo combinar dos data frames en R con la función merge()

La función merge() de R base une data frames al emparejar valores de columnas clave. Cuando ambas entradas usan una columna con el mismo nombre, by identifica esa clave. De forma predeterminada, merge() conserva las claves coincidentes en ambas entradas, lo que corresponde a una unión interna. Usa all.x = TRUE para conservar todas las filas de x, all.y = TRUE para conservar todas las de y, o ambas opciones para conservar también las filas sin coincidencia de los dos lados. Comprueba que las columnas clave tengan tipos compatibles y que las claves duplicadas sean intencionales: las coincidencias repetidas pueden producir varias filas en el resultado.

Este ejemplo independiente une dos tablas por id e imprime los registros coincidentes:

people <- data.frame(
  id = c(1, 2, 3),
  name = c("Ada", "Ben", "Cy")
)
ages <- data.frame(
  id = c(2, 3, 4),
  age = c(25, 30, 35)
)

matched <- merge(people, ages, by = "id")
print(matched)

  id name age
1  2  Ben  25
2  3   Cy  30

Usa merge(people, ages, by = "id", all.x = TRUE) cuando el resultado deba conservar a todas las personas, incluidas aquellas que no tengan una edad coincidente. De forma predeterminada, merge() ordena el resultado por la clave, salvo que se indique sort = FALSE. La tabla mostrada arriba es el resultado observado suministrado para este ejemplo.

Conclusión

Elige rbind() para añadir filas cuando las entradas comparten una estructura, y elige dplyr::bind_rows() cuando convenga apilar entradas con columnas diferentes y completar las celdas ausentes con NA. Elige plyr::join() o merge() cuando debas relacionar registros mediante claves; merge() de R base está disponible sin instalar otro paquete y ofrece opciones para conservar filas sin coincidencia. Antes de combinar datos más voluminosos, comprueba la unicidad de las claves, los tipos de columna y si la operación debe apilar filas o realizar una unión. El rendimiento depende de los datos y del entorno, así que mide entradas representativas antes de afirmar que algo es más rápido o adoptar una optimización personalizada.