Saya telah melihat-lihat StackOverflow, tetapi saya tidak dapat menemukan solusi khusus untuk masalah saya, yang melibatkan penambahan baris ke bingkai data R.

Saya menginisialisasi bingkai data 2 kolom kosong, sebagai berikut.

df = data.frame(x = numeric(), y = character())

Kemudian, tujuan saya adalah untuk mengulang melalui daftar nilai dan, di setiap iterasi, menambahkan nilai ke akhir daftar. Saya mulai dengan kode berikut.

for (i in 1:10) {
    df$x = rbind(df$x, i)
    df$y = rbind(df$y, toString(i))
}

Saya juga berusaha fungsi c, appenddan mergetanpa hasil. Tolong beri tahu saya jika Anda punya saran.

Memperbarui

Tidak tahu apa yang Anda coba lakukan, saya akan membagikan satu saran lagi: Lakukan pra-alokasi vektor dari jenis yang Anda inginkan untuk setiap kolom, masukkan nilai ke dalam vektor tersebut, dan kemudian, pada akhirnya, buat data.frame.

Melanjutkan dengan Julian f3(yang dialokasikan sebelumnya data.frame) sebagai opsi tercepat sejauh ini, yang didefinisikan sebagai:

# pre-allocate space
f3 <- function(n){
  df <- data.frame(x = numeric(n), y = character(n), stringsAsFactors = FALSE)
  for(i in 1:n){
    df$x[i] <- i
    df$y[i] <- toString(i)
  }
  df
}

Berikut adalah pendekatan yang serupa, tetapi pendekatan yang data.framedibuat sebagai langkah terakhir.

# Use preallocated vectors
f4 <- function(n) {
  x <- numeric(n)
  y <- character(n)
  for (i in 1:n) {
    x[i] <- i
    y[i] <- i
  }
  data.frame(x, y, stringsAsFactors=FALSE)
}

microbenchmarkdari paket "microbenchmark" akan memberi kita wawasan yang lebih komprehensif daripada system.time:

library(microbenchmark)
microbenchmark(f1(1000), f3(1000), f4(1000), times = 5)
# Unit: milliseconds
#      expr         min          lq      median         uq         max neval
#  f1(1000) 1024.539618 1029.693877 1045.972666 1055.25931 1112.769176     5
#  f3(1000)  149.417636  150.529011  150.827393  151.02230  160.637845     5
#  f4(1000)    7.872647    7.892395    7.901151    7.95077    8.049581     5

f1()(pendekatan di bawah) sangat tidak efisien karena seberapa sering ia memanggil data.framedan karena menumbuhkan objek seperti itu umumnya lambat di R. f3()jauh lebih baik karena pra-alokasi, tetapi data.framestruktur itu sendiri mungkin menjadi bagian dari hambatan di sini. f4()mencoba melewati kemacetan itu tanpa mengorbankan pendekatan yang ingin Anda ambil.

Jawaban asli

Ini sebenarnya bukan ide yang bagus, tetapi jika Anda ingin melakukannya dengan cara ini, saya rasa Anda dapat mencoba:

for (i in 1:10) {
  df <- rbind(df, data.frame(x = i, y = toString(i)))
}

Perhatikan bahwa dalam kode Anda, ada satu masalah lain:

• Anda harus menggunakan stringsAsFactorsjika Anda ingin karakter tidak diubah menjadi faktor. Menggunakan:df = data.frame(x = numeric(), y = character(), stringsAsFactors = FALSE)

Mari kita tolak ukur tiga solusi yang diusulkan:

# use rbind
f1 <- function(n){
  df <- data.frame(x = numeric(), y = character())
  for(i in 1:n){
    df <- rbind(df, data.frame(x = i, y = toString(i)))
  }
  df
}
# use list
f2 <- function(n){
  df <- data.frame(x = numeric(), y = character(), stringsAsFactors = FALSE)
  for(i in 1:n){
    df[i,] <- list(i, toString(i))
  }
  df
}
# pre-allocate space
f3 <- function(n){
  df <- data.frame(x = numeric(1000), y = character(1000), stringsAsFactors = FALSE)
  for(i in 1:n){
    df$x[i] <- i
    df$y[i] <- toString(i)
  }
  df
}
system.time(f1(1000))
#   user  system elapsed 
#   1.33    0.00    1.32 
system.time(f2(1000))
#   user  system elapsed 
#   0.19    0.00    0.19 
system.time(f3(1000))
#   user  system elapsed 
#   0.14    0.00    0.14

Solusi terbaik adalah mengalokasikan ruang terlebih dahulu (seperti yang dimaksudkan di R). Solusi terbaik berikutnya adalah menggunakan list, dan solusi terburuk (setidaknya berdasarkan hasil waktu ini) tampaknya rbind.

Misalkan Anda tidak mengetahui ukuran data.frame sebelumnya. Bisa jadi beberapa baris, atau beberapa juta. Anda perlu memiliki semacam wadah, yang tumbuh secara dinamis. Mempertimbangkan pengalaman saya dan semua jawaban terkait di SO saya datang dengan 4 solusi berbeda:

1. rbindlist ke data.frame

2. Gunakan operasi data.tablecepat setdan pasangkan dengan menggandakan tabel secara manual bila diperlukan.

3. Gunakan RSQLitedan tambahkan ke tabel yang disimpan dalam memori.

4. data.framekemampuan sendiri untuk mengembangkan dan menggunakan lingkungan kustom (yang memiliki semantik referensi) untuk menyimpan data.frame sehingga tidak akan disalin saat kembali.

Berikut adalah pengujian semua metode untuk jumlah baris yang ditambahkan kecil dan besar. Setiap metode memiliki 3 fungsi yang terkait dengannya:

• create(first_element)yang mengembalikan objek pendukung yang sesuai dengan first_elementdimasukkan.

• append(object, element)yang menambahkan elementakhir tabel (diwakili oleh object).

• access(object)mendapatkan data.framedengan semua elemen yang disisipkan.

rbindlist ke data.frame

Itu cukup mudah dan tidak berbelit-belit:

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 + menggandakan tabel secara manual saat diperlukan.

Saya akan menyimpan panjang sebenarnya dari tabel dalam rowcountatribut.

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 harus dioptimalkan untuk penyisipan rekaman cepat, jadi saya awalnya memiliki harapan tinggi untuk RSQLitesolusi

Ini pada dasarnya adalah salin & tempel jawaban Karsten W. di utas serupa.

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.framelingkungan kustom + penambahan baris sendiri.

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)
}

Rangkaian pengujian:

Untuk kenyamanan, saya akan menggunakan satu fungsi uji untuk mencakup semuanya dengan panggilan tidak langsung. (Saya memeriksa: menggunakan do.callalih-alih memanggil fungsi secara langsung tidak membuat kode berjalan terukur lebih lama).

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)))
}

Mari kita lihat kinerja untuk n = 10 penyisipan.

Saya juga menambahkan fungsi 'plasebo' (dengan akhiran 0) yang tidak melakukan apa-apa - hanya untuk mengukur overhead pengaturan pengujian.

r<-microbenchmark(test(0,n=10), test(1,n=10),test(2,n=10),test(3,n=10), test(4,n=10))
autoplot(r)

Untuk 1E5 baris (pengukuran dilakukan pada Intel (R) Core (TM) i7-4710HQ CPU @ 2.50GHz):

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

Sepertinya sulusi berbasis SQLite, meskipun mendapatkan kembali beberapa kecepatan pada data besar, tidak jauh dari pertumbuhan eksponensial data.table + manual. Perbedaannya hampir dua kali lipat!

Ringkasan

Jika Anda tahu bahwa Anda akan menambahkan jumlah baris yang agak kecil (n <= 100), lanjutkan dan gunakan solusi yang paling sederhana: cukup tetapkan baris ke data.frame menggunakan notasi braket dan abaikan fakta bahwa data.frame adalah tidak diisi sebelumnya.

Untuk semua yang lain gunakan data.table::setdan kembangkan data.table secara eksponensial (misalnya menggunakan kode saya).

Perbarui dengan purrr, tidyr & dplyr

Karena pertanyaannya sudah bertanggal (6 tahun), jawabannya tidak ada solusi dengan paket yang lebih baru tidyr dan purrr. Jadi bagi orang-orang yang bekerja dengan paket ini, saya ingin menambahkan solusi ke jawaban sebelumnya - semuanya cukup menarik, khususnya.

Keuntungan terbesar dari purrr dan tidyr adalah IMHO keterbacaan yang lebih baik. purrr menggantikan lapply dengan keluarga map () yang lebih fleksibel, tidyr menawarkan metode super-intuitif add_row - lakukan saja apa yang dikatakan :)

map_df(1:1000, function(x) { df %>% add_row(x = x, y = toString(x)) })

Solusi ini singkat dan intuitif untuk dibaca, dan relatif cepat:

system.time(
   map_df(1:1000, function(x) { df %>% add_row(x = x, y = toString(x)) })
)
   user  system elapsed 
   0.756   0.006   0.766

Ini berskala hampir linier, jadi untuk 1e5 baris, kinerjanya adalah:

system.time(
  map_df(1:100000, function(x) { df %>% add_row(x = x, y = toString(x)) })
)
   user  system elapsed 
 76.035   0.259  76.489 

yang akan membuatnya berada di peringkat kedua setelah data.table (jika Anda mengabaikan plasebo) dalam tolok ukur oleh @Adam Ryczkowski:

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

Mari kita ambil 'titik' vektor yang memiliki angka dari 1 sampai 5

point = c(1,2,3,4,5)

jika kita ingin menambahkan angka 6 di mana saja di dalam vektor maka perintah di bawah ini mungkin berguna

i) Vektor

new_var = append(point, 6 ,after = length(point))

ii) kolom tabel

new_var = append(point, 6 ,after = length(mtcars$mpg))

Perintah tersebut appendmembutuhkan tiga argumen:

1. vektor / kolom yang akan diubah.
2. nilai untuk dimasukkan dalam vektor yang dimodifikasi.
3. subskrip, setelah itu nilainya akan ditambahkan.

sederhana...!! Permintaan maaf jika terjadi ...!

Solusi yang lebih umum untuk mungkin adalah sebagai berikut.

    extendDf <- function (df, n) {
    withFactors <- sum(sapply (df, function(X) (is.factor(X)) )) > 0
    nr          <- nrow (df)
    colNames    <- names(df)
    for (c in 1:length(colNames)) {
        if (is.factor(df[,c])) {
            col         <- vector (mode='character', length = nr+n) 
            col[1:nr]   <- as.character(df[,c])
            col[(nr+1):(n+nr)]<- rep(col[1], n)  # to avoid extra levels
            col         <- as.factor(col)
        } else {
            col         <- vector (mode=mode(df[1,c]), length = nr+n)
            class(col)  <- class (df[1,c])
            col[1:nr]   <- df[,c] 
        }
        if (c==1) {
            newDf       <- data.frame (col ,stringsAsFactors=withFactors)
        } else {
            newDf[,c]   <- col 
        }
    }
    names(newDf) <- colNames
    newDf
}

Fungsi extensionDf () memperluas bingkai data dengan n baris.

Sebagai contoh:

aDf <- data.frame (l=TRUE, i=1L, n=1, c='a', t=Sys.time(), stringsAsFactors = TRUE)
extendDf (aDf, 2)
#      l i n c                   t
# 1  TRUE 1 1 a 2016-07-06 17:12:30
# 2 FALSE 0 0 a 1970-01-01 01:00:00
# 3 FALSE 0 0 a 1970-01-01 01:00:00

system.time (eDf <- extendDf (aDf, 100000))
#    user  system elapsed 
#   0.009   0.002   0.010
system.time (eDf <- extendDf (eDf, 100000))
#    user  system elapsed 
#   0.068   0.002   0.070

Solusi saya hampir sama dengan jawaban asli tetapi tidak berhasil untuk saya.

Jadi, saya memberi nama untuk kolom dan berhasil:

painel <- rbind(painel, data.frame("col1" = xtweets$created_at,
                                   "col2" = xtweets$text))