Łączenie dwóch ramek danych według wierszy (rbind), gdy mają różne zestawy kolumn

Nowszym rozwiązaniem jest użycie dplyr ' S bind_rows funkcja, która zakładam, że jest bardziej wydajna niż smartbind.

df1 <- data.frame(a = c(1:5), b = c(6:10))
df2 <- data.frame(a = c(11:15), b = c(16:20), c = LETTERS[1:5])
dplyr::bind_rows(df1, df2)
    a  b    c
1   1  6 <NA>
2   2  7 <NA>
3   3  8 <NA>
4   4  9 <NA>
5   5 10 <NA>
6  11 16    A
7  12 17    B
8  13 18    C
9  14 19    D
10 15 20    E

Możesz użyć smartbind z pakietu gtools.

Przykład:

library(gtools)
df1 <- data.frame(a = c(1:5), b = c(6:10))
df2 <- data.frame(a = c(11:15), b = c(16:20), c = LETTERS[1:5])
smartbind(df1, df2)
# result
     a  b    c
1.1  1  6 <NA>
1.2  2  7 <NA>
1.3  3  8 <NA>
1.4  4  9 <NA>
1.5  5 10 <NA>
2.1 11 16    A
2.2 12 17    B
2.3 13 18    C
2.4 14 19    D
2.5 15 20    E

Alternatywa z data.table:

library(data.table)
df1 = data.frame(a = c(1:5), b = c(6:10))
df2 = data.frame(a = c(11:15), b = c(16:20), c = LETTERS[1:5])
rbindlist(list(df1, df2), fill = TRUE)

rbind będzie działać również w data.table tak długo, jak obiekty zostaną przekonwertowane na obiekty data.table, więc

rbind(setDT(df1), setDT(df2), fill=TRUE)

Będzie również działać w tej sytuacji. Może to być preferowane, gdy masz kilka danych.tabel i nie chce konstruować listy.

Większość odpowiedzi bazy R odnosi się do sytuacji, w której tylko jedno dane.ramka ma dodatkowe kolumny lub dane wynikowe.rama miałaby przecięcie kolumn. Ponieważ OP pisze , mam nadzieję zachować kolumny, które nie pasują do siebie po bindzie , odpowiedź za pomocą metod base R, aby rozwiązać ten problem, jest prawdopodobnie warta opublikowania.

Poniżej przedstawiam dwie podstawowe metody R: jedną, która zmienia oryginalne dane.ramki, i takie, które nie. dodatkowo oferuję metoda, która uogólnia metodę nieniszczącą do więcej niż dwóch danych.ramki.

Najpierw zdobądźmy przykładowe dane.

# sample data, variable c is in df1, variable d is in df2
df1 = data.frame(a=1:5, b=6:10, d=month.name[1:5])
df2 = data.frame(a=6:10, b=16:20, c = letters[8:12])

Dwa dane.ramki, alter oryginały
W celu zachowania wszystkich kolumn z obu danych.ramki w rbind (i pozwalają na działanie funkcji bez powodowania błędu), dodajesz kolumny NA do każdej z danych.ramka z odpowiednimi brakującymi nazwami wypełniona za pomocą setdiff.

# fill in non-overlapping columns with NAs
df1[setdiff(names(df2), names(df1))] <- NA
df2[setdiff(names(df1), names(df2))] <- NA

Teraz, rbind-em

rbind(df1, df2)
    a  b        d    c
1   1  6  January <NA>
2   2  7 February <NA>
3   3  8    March <NA>
4   4  9    April <NA>
5   5 10      May <NA>
6   6 16     <NA>    h
7   7 17     <NA>    i
8   8 18     <NA>    j
9   9 19     <NA>    k
10 10 20     <NA>    l

Zauważ, że pierwsze dwie linie zmieniają oryginalne dane.ramki, df1 i df2, dodając do obu pełny zestaw kolumn.

Dwa dane.ramki, nie zmieniaj oryginałów
Aby zostawić oryginalne dane.ramki nienaruszone, pierwsza pętla przez różne nazwy, zwraca nazwany wektor serwera NAs, który jest połączony w listę z danymi.frame using c. Następnie data.frame zamienia wynik na odpowiednie dane.ramka na rbind.

rbind(
  data.frame(c(df1, sapply(setdiff(names(df2), names(df1)), function(x) NA))),
  data.frame(c(df2, sapply(setdiff(names(df1), names(df2)), function(x) NA)))
)

Wiele danych.ramki, do nie zmieniaj oryginałów
W przypadku, gdy masz więcej niż dwa dane.ramki, można zrobić następujące.

# put data.frames into list (dfs named df1, df2, df3, etc)
mydflist <- mget(ls(pattern="df\\d+"))
# get all variable names
allNms <- unique(unlist(lapply(mydflist, names)))

# put em all together
do.call(rbind,
        lapply(mydflist,
               function(x) data.frame(c(x, sapply(setdiff(allNms, names(x)),
                                                  function(y) NA)))))

Może trochę ładniej nie widzieć nazw wierszy oryginalnych danych.ramki? Więc zrób to.

do.call(rbind,
        c(lapply(mydflist,
                 function(x) data.frame(c(x, sapply(setdiff(allNms, names(x)),
                                                    function(y) NA)))),
          make.row.names=FALSE))

Jeśli kolumny w df1 są podzbiorem tych w df2 (według nazw kolumn):

df3 <- rbind(df1, df2[, names(df1)])

Możesz też po prostu wyciągnąć popularne nazwy kolumn.

> cols <- intersect(colnames(df1), colnames(df2))
> rbind(df1[,cols], df2[,cols])

Napisałem do tego funkcję, ponieważ lubię, gdy mój kod mówi mi, czy coś jest nie tak. Ta funkcja wyraźnie powie Ci, które nazwy kolumn nie pasują i czy masz niedopasowanie typu. Następnie dołoży wszelkich starań, aby połączyć dane.ramki w każdym razie. Ograniczenie polega na tym, że można łączyć tylko dwa dane.ramki na raz.

### combines data frames (like rbind) but by matching column names
# columns without matches in the other data frame are still combined
# but with NA in the rows corresponding to the data frame without
# the variable
# A warning is issued if there is a type mismatch between columns of
# the same name and an attempt is made to combine the columns
combineByName <- function(A,B) {
    a.names <- names(A)
    b.names <- names(B)
    all.names <- union(a.names,b.names)
    print(paste("Number of columns:",length(all.names)))
    a.type <- NULL
    for (i in 1:ncol(A)) {
        a.type[i] <- typeof(A[,i])
    }
    b.type <- NULL
    for (i in 1:ncol(B)) {
        b.type[i] <- typeof(B[,i])
    }
    a_b.names <- names(A)[!names(A)%in%names(B)]
    b_a.names <- names(B)[!names(B)%in%names(A)]
    if (length(a_b.names)>0 | length(b_a.names)>0){
        print("Columns in data frame A but not in data frame B:")
        print(a_b.names)
        print("Columns in data frame B but not in data frame A:")
        print(b_a.names)
    } else if(a.names==b.names & a.type==b.type){
        C <- rbind(A,B)
        return(C)
    }
    C <- list()
    for(i in 1:length(all.names)) {
        l.a <- all.names[i]%in%a.names
        pos.a <- match(all.names[i],a.names)
        typ.a <- a.type[pos.a]
        l.b <- all.names[i]%in%b.names
        pos.b <- match(all.names[i],b.names)
        typ.b <- b.type[pos.b]
        if(l.a & l.b) {
            if(typ.a==typ.b) {
                vec <- c(A[,pos.a],B[,pos.b])
            } else {
                warning(c("Type mismatch in variable named: ",all.names[i],"\n"))
                vec <- try(c(A[,pos.a],B[,pos.b]))
            }
        } else if (l.a) {
            vec <- c(A[,pos.a],rep(NA,nrow(B)))
        } else {
            vec <- c(rep(NA,nrow(A)),B[,pos.b])
        }
        C[[i]] <- vec
    }
    names(C) <- all.names
    C <- as.data.frame(C)
    return(C)
}

Może całkowicie źle odczytałem twoje pytanie, ale "mam nadzieję zachować kolumny, które nie pasują po bindzie" sprawia, że myślę, że szukasz left join LUB right join podobnego do zapytania SQL. R posiada funkcję merge, która pozwala określić połączenia lewe, prawe lub wewnętrzne podobne do łączenia tabel w SQL.

Jest już świetne pytanie i odpowiedź na ten temat tutaj: Jak połączyć (scalić) ramki danych (wewnętrzne, zewnętrzne, lewe, prawe)?

Gtools / smartbind nie lubił pracować z datami, prawdopodobnie dlatego, że był as.vectoring. Oto moje rozwiązanie...

sbind = function(x, y, fill=NA) {
    sbind.fill = function(d, cols){ 
        for(c in cols)
            d[[c]] = fill
        d
    }

    x = sbind.fill(x, setdiff(names(y),names(x)))
    y = sbind.fill(y, setdiff(names(x),names(y)))

    rbind(x, y)
}

Tylko dla dokumentacji. Możesz wypróbować bibliotekę Stack i jej funkcję Stack w następującej formie:

Stack(df_1, df_2)

Możesz również użyć sjmisc::add_rows(), który używa dplyr::bind_rows(), ale w przeciwieństwie do bind_rows(), add_rows() zachowuje atrybuty i dlatego jest przydatny dla oznaczonych danymi .

Patrz poniższy przykład z oznaczonym zestawem danych. Funkcja frq() - wyświetla tabele częstotliwości z etykietami wartości, jeśli dane są etykietowane.

library(sjmisc)
library(dplyr)

data(efc)
# select two subsets, with some identical and else different columns
x1 <- efc %>% select(1:5) %>% slice(1:10)
x2 <- efc %>% select(3:7) %>% slice(11:20)

str(x1)
#> 'data.frame':    10 obs. of  5 variables:
#>  $ c12hour : num  16 148 70 168 168 16 161 110 28 40
#>   ..- attr(*, "label")= chr "average number of hours of care per week"
#>  $ e15relat: num  2 2 1 1 2 2 1 4 2 2
#>   ..- attr(*, "label")= chr "relationship to elder"
#>   ..- attr(*, "labels")= Named num  1 2 3 4 5 6 7 8
#>   .. ..- attr(*, "names")= chr  "spouse/partner" "child" "sibling" "daughter or son -in-law" ...
#>  $ e16sex  : num  2 2 2 2 2 2 1 2 2 2
#>   ..- attr(*, "label")= chr "elder's gender"
#>   ..- attr(*, "labels")= Named num  1 2
#>   .. ..- attr(*, "names")= chr  "male" "female"
#>  $ e17age  : num  83 88 82 67 84 85 74 87 79 83
#>   ..- attr(*, "label")= chr "elder' age"
#>  $ e42dep  : num  3 3 3 4 4 4 4 4 4 4
#>   ..- attr(*, "label")= chr "elder's dependency"
#>   ..- attr(*, "labels")= Named num  1 2 3 4
#>   .. ..- attr(*, "names")= chr  "independent" "slightly dependent" "moderately dependent" "severely dependent"

bind_rows(x1, x1) %>% frq(e42dep)
#> 
#> # e42dep <numeric> 
#> # total N=20  valid N=20  mean=3.70  sd=0.47
#>  
#>   val frq raw.prc valid.prc cum.prc
#>     3   6      30        30      30
#>     4  14      70        70     100
#>  <NA>   0       0        NA      NA

add_rows(x1, x1) %>% frq(e42dep)
#> 
#> # elder's dependency (e42dep) <numeric> 
#> # total N=20  valid N=20  mean=3.70  sd=0.47
#>  
#>  val                label frq raw.prc valid.prc cum.prc
#>    1          independent   0       0         0       0
#>    2   slightly dependent   0       0         0       0
#>    3 moderately dependent   6      30        30      30
#>    4   severely dependent  14      70        70     100
#>   NA                   NA   0       0        NA      NA

rbind.ordered=function(x,y){

  diffCol = setdiff(colnames(x),colnames(y))
  if (length(diffCol)>0){
    cols=colnames(y)
    for (i in 1:length(diffCol)) y=cbind(y,NA)
    colnames(y)=c(cols,diffCol)
  }

  diffCol = setdiff(colnames(y),colnames(x))
  if (length(diffCol)>0){
    cols=colnames(x)
    for (i in 1:length(diffCol)) x=cbind(x,NA)
    colnames(x)=c(cols,diffCol)
  }
  return(rbind(x, y[, colnames(x)]))
}