Cree un marco de datos vacío.

Estoy tratando de inicializar un data.frame sin filas. Básicamente, quiero especificar los tipos de datos para cada columna y nombrarlos, pero no tener ninguna fila creada como resultado.

Lo mejor que he podido hacer hasta ahora es algo como:

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

Lo que crea un data.frame con una sola fila que contiene todos los tipos de datos y nombres de columnas que quería, pero también crea una fila inútil que luego debe eliminarse.

¿Hay una mejor manera de hacer esto?

Solo inicialízalo con vectores vacíos:

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

Aquí hay otro ejemplo con diferentes tipos de columna:

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:

La inicialización de a data.framecon una columna vacía del tipo incorrecto no impide nuevas adiciones de filas que tienen columnas de diferentes tipos.
Este método es un poco más seguro en el sentido de que tendrá los tipos de columna correctos desde el principio, por lo tanto, si su código se basa en alguna verificación de tipo de columna, funcionará incluso con una data.framefila cero.

Si ya tiene un marco de datos existente , digamos dfque tiene las columnas que desea, puede crear un marco de datos vacío eliminando todas las filas:

empty_df = df[FALSE,]

Tenga en cuenta que dftodavía contiene los datos, pero empty_dfno los contiene .

Encontré esta pregunta buscando cómo crear una nueva instancia con filas vacías, por lo que creo que podría ser útil para algunas personas.

Puede hacerlo sin especificar tipos de columna.

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

Puede usar read.tableuna cadena vacía para la entrada de la textsiguiente manera:

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

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

Alternativamente, especificando col.namescomo una cadena:

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

Gracias a Richard Scriven por la mejora.

La forma más eficiente de hacer esto es usar structurepara crear una lista que tenga la clase "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)

Para poner esto en perspectiva en comparación con la respuesta actualmente aceptada, aquí hay un punto de referencia simple:

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

Solo declara

table = data.frame()

cuando intentes con rbindla primera línea creará las columnas

Si buscas escasez:

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

por lo que no necesita especificar los nombres de columna por separado. Obtiene el tipo de columna predeterminado lógico hasta que complete el marco de datos.

Creé un marco de datos vacío usando el siguiente código

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

e intenté vincular algunas filas para llenar el mismo de la siguiente manera.

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

pero comenzó a dar nombres de columna incorrectos de la siguiente manera

  X3 X4
1  3  4

La solución a esto es convertir newrow para escribir df de la siguiente manera

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

ahora proporciona el marco de datos correcto cuando se muestra con los nombres de columna de la siguiente manera

  id nobs
1  3   4 

Para crear un marco de datos vacío , pase el número de filas y columnas necesarias en la siguiente función:

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

Para crear un marco vacío mientras especifica la clase de cada columna , simplemente pase un vector de los tipos de datos deseados a la siguiente función:

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

Use de la siguiente manera:

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

Lo que da:

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

Para confirmar sus elecciones, ejecute lo siguiente:

lapply(df, class)

#output
$X1
[1] "character"

$X2
[1] "logical"

$X3
[1] "numeric"

Si desea crear un data.frame vacío con nombres dinámicos (colnames en una variable), esto puede ayudar:

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

También puede cambiar los tipos si lo necesita. me gusta:

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

Si no le importa no especificar los tipos de datos explícitamente, puede hacerlo de esta manera:

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)

Al usar data.tablepodemos especificar los tipos de datos para cada columna.

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

Si desea declarar tal data.framecon muchas columnas, probablemente será difícil escribir a mano todas las clases de columnas. Especialmente si puede utilizarlo rep, este enfoque es fácil y rápido (aproximadamente un 15% más rápido que la otra solución que se puede generalizar así):

Si sus clases de columna deseadas están en un vector colClasses, puede hacer lo siguiente:

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

lapplydará como resultado una lista de la longitud deseada, cada elemento del cual es simplemente un vector tipeado vacío como numeric()o integer().

setDFconvierte esto listpor referencia a a data.frame.

setnames agrega los nombres deseados por referencia.

Comparación de velocidad:

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 

También es más rápido que usarlo structurede manera similar:

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

Digamos que los nombres de sus columnas son dinámicos, puede crear una matriz vacía con nombre de fila y transformarla en un marco de datos.

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

Esta pregunta no abordó específicamente mis inquietudes (descritas aquí ), pero en caso de que alguien quiera hacer esto con un número parametrizado de columnas y sin coerción:

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

Como dice divibisan sobre la pregunta vinculada,

... la razón [coerción] ocurre [cuando se unen matrices y sus tipos constituyentes] es que una matriz solo puede tener un único tipo de datos. Cuando se unen 2 matrices, el resultado sigue siendo una matriz y, por lo tanto, todas las variables se convierten en un solo tipo antes de convertirlas en un marco de datos.

Si ya tiene un marco de datos, puede extraer los metadatos (nombres y tipos de columna) de un marco de datos (por ejemplo, si está controlando un ERROR que solo se activa con ciertas entradas y necesita un marco de datos ficticio vacío):

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

Y luego use el read.tablepara crear el marco de datos vacío

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