Utwórz pustą ramkę danych

Próbuję zainicjować ramkę data.frame bez żadnych wierszy. Zasadniczo chcę określić typy danych dla każdej kolumny i nazwać je, ale nie chcę tworzyć żadnych wierszy.

Do tej pory najlepsze, co udało mi się zrobić, to:

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

Który tworzy ramkę danych z pojedynczym wierszem zawierającym wszystkie typy danych i nazwy kolumn, które chciałem, ale także tworzy bezużyteczny wiersz, który następnie należy usunąć.

Czy jest na to lepszy sposób?

Wystarczy zainicjować go pustymi wektorami:

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

Oto inny przykład z różnymi typami kolumn:

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:

Inicjowanie data.framez pustą kolumną niewłaściwego typu nie zapobiega dalszym dodawaniu wierszy zawierających kolumny różnych typów.
Ta metoda jest nieco bezpieczniejsza w tym sensie, że będziesz mieć prawidłowe typy kolumn od samego początku, dlatego jeśli twój kod polega na sprawdzeniu typu kolumny, zadziała nawet data.framez zerowymi wierszami.

Jeśli masz już istniejącą ramkę danych , powiedzmy, dfże ma żądane kolumny, możesz po prostu utworzyć pustą ramkę danych, usuwając wszystkie wiersze:

empty_df = df[FALSE,]

Zauważ, że dfnadal zawiera dane, ale empty_dfich nie zawiera.

Znalazłem to pytanie, szukając sposobu utworzenia nowej instancji z pustymi wierszami, więc myślę, że może być pomocne dla niektórych osób.

Możesz to zrobić bez określania typów kolumn

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

Możesz użyć read.tablepustego łańcucha wejściowego textw następujący sposób:

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

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

Alternatywnie, określając col.namesjako ciąg:

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

Dzięki Richardowi Scrivenowi za poprawę

Najskuteczniejszym sposobem na to jest structureutworzenie listy zawierającej klasę "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)

Aby umieścić to w perspektywie w porównaniu z obecnie akceptowaną odpowiedzią, oto prosty punkt odniesienia:

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

Po prostu zadeklaruj

table = data.frame()

próba przejścia do rbindpierwszego wiersza spowoduje utworzenie kolumn

Jeśli szukasz krótkości:

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

więc nie trzeba osobno określać nazw kolumn. Otrzymasz logiczny domyślny typ kolumny, dopóki nie wypełnisz ramki danych.

Utworzyłem pustą ramkę danych za pomocą następującego kodu

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

i próbował powiązać niektóre wiersze, aby wypełnić to samo, co następuje.

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

ale zaczął nadawać niepoprawne nazwy kolumn w następujący sposób

  X3 X4
1  3  4

Rozwiązaniem tego jest konwersja newrow na typ df w następujący sposób

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

teraz wyświetla poprawną ramkę danych, gdy jest wyświetlana z następującymi nazwami kolumn

  id nobs
1  3   4 

Aby utworzyć pustą ramkę danych , wprowadź wymaganą liczbę wierszy i kolumn do następującej funkcji:

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

Aby utworzyć pustą ramkę , określając klasę każdej kolumny , wystarczy przekazać wektor pożądanych typów danych do następującej funkcji:

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

Użyj w następujący sposób:

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

Co daje:

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

Aby potwierdzić wybór, uruchom następujące polecenie:

lapply(df, class)

#output
$X1
[1] "character"

$X2
[1] "logical"

$X3
[1] "numeric"

Jeśli chcesz utworzyć pustą ramkę danych z dynamicznymi nazwami (nazwy zmiennych w zmiennej), może to pomóc:

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

Możesz także zmienić typy, jeśli potrzebujesz. lubić:

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

Jeśli nie masz nic przeciwko jawnemu określaniu typów danych, możesz to zrobić w ten sposób:

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)

Za pomocą data.tablemożemy określić typy danych dla każdej kolumny.

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

Jeśli chcesz zadeklarować taką data.frameliczbę kolumn, prawdopodobnie trudno będzie ręcznie wpisać wszystkie klasy kolumn. Zwłaszcza jeśli możesz skorzystać z reptej metody, jest to łatwe i szybkie (około 15% szybsze niż inne rozwiązanie, które można uogólnić w ten sposób):

Jeśli żądane klasy kolumn są w wektorze colClasses, możesz wykonać następujące czynności:

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

lapplyspowoduje utworzenie listy pożądanej długości, której każdy element jest po prostu pustym wektorem wektorowym, takim jak numeric()lub integer().

setDFkonwertuje to listprzez odniesienie do data.frame.

setnames dodaje żądane nazwy przez odniesienie.

Porównanie prędkości:

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 

Jest także szybszy niż używanie structurew podobny sposób:

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

Załóżmy, że nazwy kolumn są dynamiczne, możesz utworzyć pustą macierz o nazwie wiersza i przekształcić ją w ramkę danych.

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

To pytanie nie dotyczyło w szczególności moich obaw ( tutaj nakreślonych ), ale na wypadek, gdyby ktoś chciał to zrobić ze sparametryzowaną liczbą kolumn i bez przymusu:

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

Jak stwierdza divibisan w powiązanym pytaniu,

... powodem [przymusu] [gdy cbinding macierzy i ich typów składowych] jest to, że macierz może mieć tylko jeden typ danych. Gdy łączysz 2 macierze, wynikiem jest nadal macierz, więc wszystkie zmienne są konwertowane do jednego typu przed konwersją do data.frame

Jeśli masz już ramkę danych, możesz wyodrębnić metadane (nazwy i typy kolumn) z ramki danych (np. Jeśli kontrolujesz BŁĄD, który jest wyzwalany tylko z pewnymi danymi wejściowymi i potrzebujesz pustej obojętnej ramki danych):

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

A następnie użyj read.tabledo utworzenia pustej ramki danych

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