Załóżmy, że po prostu nie znasz wcześniej rozmiaru ramki data.frame. Może to być kilka rzędów lub kilka milionów. Trzeba mieć jakiś pojemnik, który będzie się dynamicznie rozrastał. Biorąc pod uwagę moje doświadczenie i wszystkie powiązane odpowiedzi w SO, przedstawiam 4 różne rozwiązania:
rbindlist do data.frame
Skorzystaj data.tablez szybkiej setobsługi i połącz ją z ręcznym podwojeniem stołu w razie potrzeby.
Użyj RSQLitei dołącz do tabeli przechowywanej w pamięci.
data.framewłasna zdolność do rozwijania i używania niestandardowego środowiska (które ma semantykę referencyjną) do przechowywania data.frame, aby nie było kopiowane po zwróceniu.
Oto test wszystkich metod zarówno dla małej, jak i dużej liczby dołączonych wierszy. Z każdą metodą są powiązane 3 funkcje:
create(first_element)która zwraca odpowiedni obiekt podkładowy z first_elementwstawioną.
append(object, element)który dołącza znak elementdo końca tabeli (reprezentowany przez object).
access(object)pobiera data.frameze wszystkimi wstawionymi elementami.
rbindlist do data.frame
To dość łatwe i proste:
create.1<-function(elems)
{
return(as.data.table(elems))
}
append.1<-function(dt, elems)
{
return(rbindlist(list(dt, elems),use.names = TRUE))
}
access.1<-function(dt)
{
return(dt)
}
data.table::set + w razie potrzeby ręczne podwojenie tabeli.
Będę przechowywać prawdziwą długość tabeli w rowcountatrybucie.
create.2<-function(elems)
{
return(as.data.table(elems))
}
append.2<-function(dt, elems)
{
n<-attr(dt, 'rowcount')
if (is.null(n))
n<-nrow(dt)
if (n==nrow(dt))
{
tmp<-elems[1]
tmp[[1]]<-rep(NA,n)
dt<-rbindlist(list(dt, tmp), fill=TRUE, use.names=TRUE)
setattr(dt,'rowcount', n)
}
pos<-as.integer(match(names(elems), colnames(dt)))
for (j in seq_along(pos))
{
set(dt, i=as.integer(n+1), pos[[j]], elems[[j]])
}
setattr(dt,'rowcount',n+1)
return(dt)
}
access.2<-function(elems)
{
n<-attr(elems, 'rowcount')
return(as.data.table(elems[1:n,]))
}
SQL powinien być zoptymalizowany pod kątem szybkiego wstawiania rekordów, więc początkowo miałem duże nadzieje na RSQLiterozwiązanie
To jest po prostu skopiuj i wklej odpowiedź Karstena W. w podobnym wątku.
create.3<-function(elems)
{
con <- RSQLite::dbConnect(RSQLite::SQLite(), ":memory:")
RSQLite::dbWriteTable(con, 't', as.data.frame(elems))
return(con)
}
append.3<-function(con, elems)
{
RSQLite::dbWriteTable(con, 't', as.data.frame(elems), append=TRUE)
return(con)
}
access.3<-function(con)
{
return(RSQLite::dbReadTable(con, "t", row.names=NULL))
}
data.framewłasne dołączanie wierszy + środowisko niestandardowe.
create.4<-function(elems)
{
env<-new.env()
env$dt<-as.data.frame(elems)
return(env)
}
append.4<-function(env, elems)
{
env$dt[nrow(env$dt)+1,]<-elems
return(env)
}
access.4<-function(env)
{
return(env$dt)
}
Zestaw testów:
Dla wygody użyję jednej funkcji testowej, aby objąć je wszystkie połączeniami pośrednimi. (Sprawdziłem: używanie do.callzamiast bezpośredniego wywoływania funkcji nie powoduje, że kod działa dłużej).
test<-function(id, n=1000)
{
n<-n-1
el<-list(a=1,b=2,c=3,d=4)
o<-do.call(paste0('create.',id),list(el))
s<-paste0('append.',id)
for (i in 1:n)
{
o<-do.call(s,list(o,el))
}
return(do.call(paste0('access.', id), list(o)))
}
Zobaczmy wydajność dla n = 10 wstawień.
Dodałem również funkcje „placebo” (z sufiksem 0), które nic nie wykonują - tylko po to, aby zmierzyć narzut konfiguracji testowej.
r<-microbenchmark(test(0,n=10), test(1,n=10),test(2,n=10),test(3,n=10), test(4,n=10))
autoplot(r)
Dla rzędów 1E5 (pomiary wykonane na procesorze Intel (R) Core (TM) i7-4710HQ @ 2,50 GHz):
nr function time
4 data.frame 228.251
3 sqlite 133.716
2 data.table 3.059
1 rbindlist 169.998
0 placebo 0.202
Wygląda na to, że sulution oparty na SQLite, chociaż odzyskuje pewną prędkość na dużych danych, nie jest nigdzie w pobliżu data.table + ręczny wzrost wykładniczy. Różnica wynosi prawie dwa rzędy wielkości!
Podsumowanie
Jeśli wiesz, że dodasz niewielką liczbę wierszy (n <= 100), użyj najprostszego możliwego rozwiązania: po prostu przypisz wiersze do data.frame za pomocą notacji nawiasowej i zignoruj fakt, że data.frame jest nie wypełnione wstępnie.
Do wszystkiego innego używaj data.table::seti rozwijaj data.table wykładniczo (np. Używając mojego kodu).