Crea un data.frame vuoto

Sto provando a inizializzare un data.frame senza alcuna riga. Fondamentalmente, voglio specificare i tipi di dati per ogni colonna e nominarli, ma non ho creato alcuna riga come risultato.

Il meglio che sono stato in grado di fare finora è qualcosa di simile:

df <- data.frame(Date=as.Date("01/01/2000", format="%m/%d/%Y"), 
                 File="", User="", stringsAsFactors=FALSE)
df <- df[-1,]

Il che crea un data.frame con una singola riga contenente tutti i tipi di dati e i nomi di colonna desiderati, ma crea anche una riga inutile che deve quindi essere rimossa.

C'è un modo migliore per farlo?

Basta inizializzarlo con vettori vuoti:

df <- data.frame(Date=as.Date(character()),
                 File=character(), 
                 User=character(), 
                 stringsAsFactors=FALSE) 

Ecco un altro esempio con diversi tipi di colonna:

df <- data.frame(Doubles=double(),
                 Ints=integer(),
                 Factors=factor(),
                 Logicals=logical(),
                 Characters=character(),
                 stringsAsFactors=FALSE)

str(df)
> str(df)
'data.frame':   0 obs. of  5 variables:
 $ Doubles   : num 
 $ Ints      : int 
 $ Factors   : Factor w/ 0 levels: 
 $ Logicals  : logi 
 $ Characters: chr 

NB:

L'inizializzazione di a data.framecon una colonna vuota di tipo errato non impedisce ulteriori aggiunte di righe con colonne di tipo diverso.
Questo metodo è solo un po ' più sicuro, nel senso che avrai i tipi di colonna corretti dall'inizio, quindi se il tuo codice si basa su un controllo del tipo di colonna, funzionerà anche con un data.framecon zero righe.

Se hai già un frame di dati esistente , supponiamo dfche abbia le colonne che desideri, quindi puoi semplicemente creare un frame di dati vuoto rimuovendo tutte le righe:

empty_df = df[FALSE,]

Si noti che dfcontiene ancora i dati, ma empty_dfnon lo è.

Ho trovato questa domanda cercando come creare una nuova istanza con righe vuote, quindi penso che potrebbe essere utile per alcune persone.

Puoi farlo senza specificare i tipi di colonna

df = data.frame(matrix(vector(), 0, 3,
                dimnames=list(c(), c("Date", "File", "User"))),
                stringsAsFactors=F)

È possibile utilizzare read.tablecon una stringa vuota per l'input textcome segue:

colClasses = c("Date", "character", "character")
col.names = c("Date", "File", "User")

df <- read.table(text = "",
                 colClasses = colClasses,
                 col.names = col.names)

In alternativa, specificare col.namescome stringa:

df <- read.csv(text="Date,File,User", colClasses = colClasses)

Grazie a Richard Scriven per il miglioramento

Il modo più efficiente per farlo è utilizzare structureper creare un elenco che ha la classe "data.frame":

structure(list(Date = as.Date(character()), File = character(), User = character()), 
          class = "data.frame")
# [1] Date File User
# <0 rows> (or 0-length row.names)

Per mettere questo in prospettiva rispetto alla risposta attualmente accettata, ecco un semplice benchmark:

s <- function() structure(list(Date = as.Date(character()), 
                               File = character(), 
                               User = character()), 
                          class = "data.frame")
d <- function() data.frame(Date = as.Date(character()),
                           File = character(), 
                           User = character(), 
                           stringsAsFactors = FALSE) 
library("microbenchmark")
microbenchmark(s(), d())
# Unit: microseconds
#  expr     min       lq     mean   median      uq      max neval
#   s()  58.503  66.5860  90.7682  82.1735 101.803  469.560   100
#   d() 370.644 382.5755 523.3397 420.1025 604.654 1565.711   100

Dichiara e basta

table = data.frame()

quando provi alla rbindprima riga creerà le colonne

Se stai cercando mancanza:

read.csv(text="col1,col2")

quindi non è necessario specificare i nomi delle colonne separatamente. Ottieni il tipo di colonna predefinito logico finché non riempi il frame di dati.

Ho creato un frame di dati vuoto usando il seguente codice

df = data.frame(id = numeric(0), jobs = numeric(0));

e ho provato a legare alcune righe per popolare lo stesso come segue.

newrow = c(3, 4)
df <- rbind(df, newrow)

ma ha iniziato a dare nomi di colonna errati come segue

  X3 X4
1  3  4

La soluzione a questo è convertire Newrow nel tipo df come segue

newrow = data.frame(id=3, jobs=4)
df <- rbind(df, newrow)

ora fornisce il frame di dati corretto quando viene visualizzato con i nomi di colonna come segue

  id nobs
1  3   4 

Per creare un frame di dati vuoto , passare il numero di righe e colonne necessarie nella seguente funzione:

create_empty_table <- function(num_rows, num_cols) {
    frame <- data.frame(matrix(NA, nrow = num_rows, ncol = num_cols))
    return(frame)
}

Per creare una cornice vuota specificando la classe di ogni colonna , è sufficiente passare un vettore dei tipi di dati desiderati nella seguente funzione:

create_empty_table <- function(num_rows, num_cols, type_vec) {
  frame <- data.frame(matrix(NA, nrow = num_rows, ncol = num_cols))
  for(i in 1:ncol(frame)) {
    print(type_vec[i])
    if(type_vec[i] == 'numeric') {frame[,i] <- as.numeric(frame[,i])}
    if(type_vec[i] == 'character') {frame[,i] <- as.character(frame[,i])}
    if(type_vec[i] == 'logical') {frame[,i] <- as.logical(frame[,i])}
    if(type_vec[i] == 'factor') {frame[,i] <- as.factor(frame[,i])}
  }
  return(frame)
}

Utilizzare come segue:

df <- create_empty_table(3, 3, c('character','logical','numeric'))

Che dà:

   X1  X2 X3
1 <NA> NA NA
2 <NA> NA NA
3 <NA> NA NA

Per confermare le scelte, eseguire quanto segue:

lapply(df, class)

#output
$X1
[1] "character"

$X2
[1] "logical"

$X3
[1] "numeric"

Se vuoi creare un data.frame vuoto con nomi dinamici (nomi di colonne in una variabile), questo può aiutare:

names <- c("v","u","w")
df <- data.frame()
for (k in names) df[[k]]<-as.numeric()

Puoi cambiare anche i tipi se ne hai bisogno. piace:

names <- c("u", "v")
df <- data.frame()
df[[names[1]]] <- as.numeric()
df[[names[2]]] <- as.character()

Se non ti dispiace non specificare esplicitamente i tipi di dati, puoi farlo in questo modo:

headers<-c("Date","File","User")
df <- as.data.frame(matrix(,ncol=3,nrow=0))
names(df)<-headers

#then bind incoming data frame with col types to set data types
df<-rbind(df, new_df)

Usando data.tablepossiamo specificare i tipi di dati per ogni colonna.

library(data.table)    
data=data.table(a=numeric(), b=numeric(), c=numeric())

Se vuoi dichiarare un tale data.framecon molte colonne, probabilmente sarà una seccatura digitare tutte le classi di colonne a mano. Soprattutto se puoi usarlo rep, questo approccio è facile e veloce (circa il 15% più veloce dell'altra soluzione che può essere generalizzata in questo modo):

Se le classi di colonne desiderate si trovano in un vettore colClasses, è possibile effettuare le seguenti operazioni:

library(data.table)
setnames(setDF(lapply(colClasses, function(x) eval(call(x)))), col.names)

lapplycomporterà un elenco della lunghezza desiderata, ogni elemento del quale è semplicemente un vettore tipizzato vuoto come numeric()o integer().

setDFconverte questo listin riferimento a data.frame.

setnames aggiunge i nomi desiderati per riferimento.

Confronto della velocità:

classes <- c("character", "numeric", "factor",
             "integer", "logical","raw", "complex")

NN <- 300
colClasses <- sample(classes, NN, replace = TRUE)
col.names <- paste0("V", 1:NN)

setDF(lapply(colClasses, function(x) eval(call(x))))

library(microbenchmark)
microbenchmark(times = 1000,
               read = read.table(text = "", colClasses = colClasses,
                                 col.names = col.names),
               DT = setnames(setDF(lapply(colClasses, function(x)
                 eval(call(x)))), col.names))
# Unit: milliseconds
#  expr      min       lq     mean   median       uq      max neval cld
#  read 2.598226 2.707445 3.247340 2.747835 2.800134 22.46545  1000   b
#    DT 2.257448 2.357754 2.895453 2.401408 2.453778 17.20883  1000  a 

È anche più veloce dell'utilizzo structurein modo simile:

microbenchmark(times = 1000,
               DT = setnames(setDF(lapply(colClasses, function(x)
                 eval(call(x)))), col.names),
               struct = eval(parse(text=paste0(
                 "structure(list(", 
                 paste(paste0(col.names, "=", 
                              colClasses, "()"), collapse = ","),
                 "), class = \"data.frame\")"))))
#Unit: milliseconds
#   expr      min       lq     mean   median       uq       max neval cld
#     DT 2.068121 2.167180 2.821868 2.211214 2.268569 143.70901  1000  a 
# struct 2.613944 2.723053 3.177748 2.767746 2.831422  21.44862  1000   b

Supponi che i nomi delle colonne siano dinamici, puoi creare una matrice vuota con nome di riga e trasformarla in un frame di dati.

nms <- sample(LETTERS,sample(1:10))
as.data.frame(t(matrix(nrow=length(nms),ncol=0,dimnames=list(nms))))

Questa domanda non ha affrontato in modo specifico le mie preoccupazioni (delineate qui ) ma nel caso qualcuno voglia farlo con un numero parametrizzato di colonne e nessuna coercizione:

> require(dplyr)
> dbNames <- c('a','b','c','d')
> emptyTableOut <- 
    data.frame(
        character(), 
        matrix(integer(), ncol = 3, nrow = 0), stringsAsFactors = FALSE
    ) %>% 
    setNames(nm = c(dbNames))
> glimpse(emptyTableOut)
Observations: 0
Variables: 4
$ a <chr> 
$ b <int> 
$ c <int> 
$ d <int>

Come afferma divibisan sulla questione collegata,

... il motivo per cui [la coercizione] si verifica [quando si collegano le matrici e i loro tipi costituenti] è che una matrice può avere un solo tipo di dati. Quando si collegano 2 matrici, il risultato è ancora una matrice e quindi le variabili vengono tutte forzate in un singolo tipo prima di convertirle in un data.frame

Se disponi già di un frame di dati, puoi estrarre i metadati (nomi e tipi di colonne) da un frame di dati (ad esempio se stai controllando un BUG che viene attivato solo con determinati input e hai bisogno di un frame di dati fittizio vuoto):

colums_and_types <- sapply(df, class)

# prints: "c('col1', 'col2')"
print(dput(as.character(names(colums_and_types))))

# prints: "c('integer', 'factor')"
dput(as.character(as.vector(colums_and_types)))

Quindi utilizzare il read.tableper creare il frame di dati vuoto

read.table(text = "",
   colClasses = c('integer', 'factor'),
   col.names = c('col1', 'col2'))