Как импортировать сразу несколько CSV файлов?

Ответ 1

Что-то вроде следующего должно привести к тому, что каждый кадр данных будет отдельным элементом в одном списке:

temp = list.files(pattern="*.csv")
myfiles = lapply(temp, read.delim)

Это предполагает, что у вас есть эти CSV в одном каталоге - вашем текущем рабочем каталоге - и что все они имеют расширение в нижнем регистре .csv.

Если вы хотите объединить эти кадры данных в один кадр данных, см. Решения в других ответах, используя такие вещи, как do.call(rbind,...), dplyr::bind_rows() или data.table::rbindlist(),

Если вам действительно нужен каждый кадр данных в отдельном объекте, хотя это часто нецелесообразно, вы можете сделать следующее с assign:

temp = list.files(pattern="*.csv")
for (i in 1:length(temp)) assign(temp[i], read.csv(temp[i]))

Или, не assign, и продемонстрировать (1), как очистить имя файла и (2) показать, как использовать list2env, вы можете попробовать следующее:

temp = list.files(pattern="*.csv")
list2env(
  lapply(setNames(temp, make.names(gsub("*.csv$", "", temp))), 
         read.csv), envir = .GlobalEnv)

Но опять же, часто лучше оставить их в одном списке.

Ответ 2

Быстрое и емкое решение tidyverse: (более чем в два раза быстрее, чем Base R read.csv)

tbl <-
    list.files(pattern = "*.csv") %>% 
    map_df(~read_csv(.))

и data.table fread() могут даже сократить время загрузки вдвое. (для 1/4 базового R раз)

library(data.table)

tbl_fread <- 
    list.files(pattern = "*.csv") %>% 
    map_df(~fread(.))

Аргумент stringsAsFactors = FALSE сохраняет фактор фактического кадра свободным (и, как указывает marbel, это значение по умолчанию для fread)

Если приведение типов является нахальным, вы можете сделать так, чтобы все столбцы были символами с аргументом col_types.

tbl <-
    list.files(pattern = "*.csv") %>% 
    map_df(~read_csv(., col_types = cols(.default = "c")))

Если вы хотите заглянуть в подкаталоги, чтобы составить список файлов для последующей привязки, обязательно укажите путь, а также зарегистрируйте файлы с их полными именами в списке. Это позволит связыванию продолжаться за пределами текущего каталога. (Думая о полных путевых именах, действующих как паспорта, чтобы разрешить перемещение через границы каталога.)

tbl <-
    list.files(path = "./subdirectory/",
               pattern = "*.csv", 
               full.names = T) %>% 
    map_df(~read_csv(., col_types = cols(.default = "c"))) 

Как описывает Хэдли здесь (примерно на полпути):

map_df(x, f) фактически совпадает с do.call("rbind", lapply(x, f))....

Бонусная функция - добавление имен файлов в записи по запросу функции Никса в комментариях ниже:
* Добавить оригинал filename к каждой записи.

Объясненный код: создайте функцию для добавления имени файла к каждой записи во время первоначального чтения таблиц. Затем используйте эту функцию вместо простой функции read_csv().

read_plus <- function(flnm) {
    read_csv(flnm) %>% 
        mutate(filename = flnm)
}

tbl_with_sources <-
    list.files(pattern = "*.csv", 
               full.names = T) %>% 
    map_df(~read_plus(.))

(Подходы к обработке типов и подкаталогов также могут обрабатываться внутри функции read_plus() таким же образом, как показано во втором и третьем вариантах, предложенных выше.)

### Benchmark Code & Results 
library(tidyverse)
library(data.table)
library(microbenchmark)

### Base R Approaches
#### Instead of a dataframe, this approach creates a list of lists
#### removed from analysis as this alone doubled analysis time reqd
# lapply_read.delim <- function(path, pattern = "*.csv") {
#     temp = list.files(path, pattern, full.names = TRUE)
#     myfiles = lapply(temp, read.delim)
# }

#### 'read.csv()'
do.call_rbind_read.csv <- function(path, pattern = "*.csv") {
    files = list.files(path, pattern, full.names = TRUE)
    do.call(rbind, lapply(files, function(x) read.csv(x, stringsAsFactors = FALSE)))
}

map_df_read.csv <- function(path, pattern = "*.csv") {
    list.files(path, pattern, full.names = TRUE) %>% 
    map_df(~read.csv(., stringsAsFactors = FALSE))
}


### *dplyr()*
#### 'read_csv()'
lapply_read_csv_bind_rows <- function(path, pattern = "*.csv") {
    files = list.files(path, pattern, full.names = TRUE)
    lapply(files, read_csv) %>% bind_rows()
}

map_df_read_csv <- function(path, pattern = "*.csv") {
    list.files(path, pattern, full.names = TRUE) %>% 
    map_df(~read_csv(., col_types = cols(.default = "c")))
}

### *data.table* / *purrr* hybrid
map_df_fread <- function(path, pattern = "*.csv") {
    list.files(path, pattern, full.names = TRUE) %>% 
    map_df(~fread(.))
}

### *data.table*
rbindlist_fread <- function(path, pattern = "*.csv") {
    files = list.files(path, pattern, full.names = TRUE)
    rbindlist(lapply(files, function(x) fread(x)))
}

do.call_rbind_fread <- function(path, pattern = "*.csv") {
    files = list.files(path, pattern, full.names = TRUE)
    do.call(rbind, lapply(files, function(x) fread(x, stringsAsFactors = FALSE)))
}


read_results <- function(dir_size){
    microbenchmark(
        # lapply_read.delim = lapply_read.delim(dir_size), # too slow to include in benchmarks
        do.call_rbind_read.csv = do.call_rbind_read.csv(dir_size),
        map_df_read.csv = map_df_read.csv(dir_size),
        lapply_read_csv_bind_rows = lapply_read_csv_bind_rows(dir_size),
        map_df_read_csv = map_df_read_csv(dir_size),
        rbindlist_fread = rbindlist_fread(dir_size),
        do.call_rbind_fread = do.call_rbind_fread(dir_size),
        map_df_fread = map_df_fread(dir_size),
        times = 10L) 
}

read_results_lrg_mid_mid <- read_results('./testFolder/500MB_12.5MB_40files')
print(read_results_lrg_mid_mid, digits = 3)

read_results_sml_mic_mny <- read_results('./testFolder/5MB_5KB_1000files/')
read_results_sml_tny_mod <- read_results('./testFolder/5MB_50KB_100files/')
read_results_sml_sml_few <- read_results('./testFolder/5MB_500KB_10files/')

read_results_med_sml_mny <- read_results('./testFolder/50MB_5OKB_1000files')
read_results_med_sml_mod <- read_results('./testFolder/50MB_5OOKB_100files')
read_results_med_med_few <- read_results('./testFolder/50MB_5MB_10files')

read_results_lrg_sml_mny <- read_results('./testFolder/500MB_500KB_1000files')
read_results_lrg_med_mod <- read_results('./testFolder/500MB_5MB_100files')
read_results_lrg_lrg_few <- read_results('./testFolder/500MB_50MB_10files')

read_results_xlg_lrg_mod <- read_results('./testFolder/5000MB_50MB_100files')


print(read_results_sml_mic_mny, digits = 3)
print(read_results_sml_tny_mod, digits = 3)
print(read_results_sml_sml_few, digits = 3)

print(read_results_med_sml_mny, digits = 3)
print(read_results_med_sml_mod, digits = 3)
print(read_results_med_med_few, digits = 3)

print(read_results_lrg_sml_mny, digits = 3)
print(read_results_lrg_med_mod, digits = 3)
print(read_results_lrg_lrg_few, digits = 3)

print(read_results_xlg_lrg_mod, digits = 3)

# display boxplot of my typical use case results & basic machine max load
par(oma = c(0,0,0,0)) # remove overall margins if present
par(mfcol = c(1,1)) # remove grid if present
par(mar = c(12,5,1,1) + 0.1) # to display just a single boxplot with its complete labels
boxplot(read_results_lrg_mid_mid, las = 2, xlab = "", ylab = "Duration (seconds)", main = "40 files @ 12.5MB (500MB)")
boxplot(read_results_xlg_lrg_mod, las = 2, xlab = "", ylab = "Duration (seconds)", main = "100 files @ 50MB (5GB)")

# generate 3x3 grid boxplots
par(oma = c(12,1,1,1)) # margins for the whole 3 x 3 grid plot
par(mfcol = c(3,3)) # create grid (filling down each column)
par(mar = c(1,4,2,1)) # margins for the individual plots in 3 x 3 grid
boxplot(read_results_sml_mic_mny, las = 2, xlab = "", ylab = "Duration (seconds)", main = "1000 files @ 5KB (5MB)", xaxt = 'n')
boxplot(read_results_sml_tny_mod, las = 2, xlab = "", ylab = "Duration (milliseconds)", main = "100 files @ 50KB (5MB)", xaxt = 'n')
boxplot(read_results_sml_sml_few, las = 2, xlab = "", ylab = "Duration (milliseconds)", main = "10 files @ 500KB (5MB)",)

boxplot(read_results_med_sml_mny, las = 2, xlab = "", ylab = "Duration (microseconds)        ", main = "1000 files @ 50KB (50MB)", xaxt = 'n')
boxplot(read_results_med_sml_mod, las = 2, xlab = "", ylab = "Duration (microseconds)", main = "100 files @ 500KB (50MB)", xaxt = 'n')
boxplot(read_results_med_med_few, las = 2, xlab = "", ylab = "Duration (seconds)", main = "10 files @ 5MB (50MB)")

boxplot(read_results_lrg_sml_mny, las = 2, xlab = "", ylab = "Duration (seconds)", main = "1000 files @ 500KB (500MB)", xaxt = 'n')
boxplot(read_results_lrg_med_mod, las = 2, xlab = "", ylab = "Duration (seconds)", main = "100 files @ 5MB (500MB)", xaxt = 'n')
boxplot(read_results_lrg_lrg_few, las = 2, xlab = "", ylab = "Duration (seconds)", main = "10 files @ 50MB (500MB)")

Середина использования

Большой вариант использования

Разнообразие вариантов использования

Строки: количество файлов (1000, 100, 10)
Столбцы: окончательный размер кадра данных (5 МБ, 50 МБ, 500 МБ)
(нажмите на изображение, чтобы увидеть оригинальный размер)

Базовые результаты R лучше для самых маленьких случаев использования, когда издержки, связанные с переносом библиотек C purrr и dplyr, перевешивают выигрыш в производительности, который наблюдается при выполнении более масштабных задач обработки.

если вы хотите запускать свои собственные тесты, этот скрипт bash может оказаться полезным.

for ((i=1; i<=$2; i++)); do 
  cp "$1" "${1:0:8}_${i}.csv";
done

bash what_you_name_this_script.sh "fileName_you_want_copied" 100 создаст 100 копий вашего файла с последовательной нумерацией (после первых 8 символов имени файла и подчеркивания).

Атрибуты и благодарности

С особой благодарностью:

• Тайлеру Ринкеру и Акруну за демонстрацию микробенчмарка.
• Джейка Кауппа за то, что он познакомил меня с map_df() здесь.
• Дэвида Маклафлина (David McLaughlin) за полезные отзывы об улучшении визуализаций и обсуждении/подтверждении инверсий производительности, наблюдаемых в небольшом файле, результаты анализа небольших данных.
• marbel за указание поведения по умолчанию для fread(). (Мне нужно изучить data.table.)

Ответ 3

Вот еще один вариант преобразования файлов .csv в один файл data.frame. Использование базовых функций R. Это на порядок медленнее, чем варианты ниже.

# Get the files names
files = list.files(pattern="*.csv")
# First apply read.csv, then rbind
myfiles = do.call(rbind, lapply(files, function(x) read.csv(x, stringsAsFactors = FALSE)))

Изменить: - Еще несколько дополнительных вариантов, используя data.table и readr

Версия fread(), которая является функцией пакета data.table. Это, безусловно, самый быстрый вариант в R.

library(data.table)
DT = do.call(rbind, lapply(files, fread))
# The same using 'rbindlist'
DT = rbindlist(lapply(files, fread))

Использование readr, нового пакета Hadley для чтения CSV файлов. Немного медленнее, чем фред, но с другой функциональностью.

library(readr)
library(dplyr)
tbl = lapply(files, read_csv) %>% bind_rows()

Ответ 4

Также, используя lapply или какую-либо другую конструкцию цикла в R, вы можете объединить файлы CSV в один файл.

В Unix, если в файлах нет заголовков, тогда это просто:

cat *.csv > all.csv

или если есть заголовки, и вы можете найти строку, которая соответствует заголовкам и только заголовкам (т.е. предположим, что строки заголовка начинаются с "Возраст" ), вы бы сделали:

cat *.csv | grep -v ^Age > all.csv

Я думаю, что в Windows вы могли бы сделать это с помощью COPY и SEARCH (или FIND или что-то еще) из командной строки DOS, но почему бы не установить cygwin и не получить полномочия командной оболочки Unix?

Ответ 5

Это код, который я разработал для чтения всех файлов csv в R. Он создаст фрейм данных для каждого файла csv по отдельности и заголовку, который будет содержать имя файла с исходным именем файла (удаление пробелов и .csv). Надеюсь, вы сочтете это полезным!

path <- "C:/Users/cfees/My Box Files/Fitness/"
files <- list.files(path=path, pattern="*.csv")
for(file in files)
{
perpos <- which(strsplit(file, "")[[1]]==".")
assign(
gsub(" ","",substr(file, 1, perpos-1)), 
read.csv(paste(path,file,sep="")))
}

Ответ 6

Используя plyr::ldply, увеличение скорости примерно на 50% обеспечивается включением опции .parallel при чтении 400 csv файлов примерно по 30-40 МБ каждый. Пример включает строку выполнения текста.

library(plyr)
library(data.table)
library(doSNOW)

csv.list <- list.files(path="t:/data", pattern=".csv$", full.names=TRUE)

cl <- makeCluster(4)
registerDoSNOW(cl)

pb <- txtProgressBar(max=length(csv.list), style=3)
pbu <- function(i) setTxtProgressBar(pb, i)
dt <- setDT(ldply(csv.list, fread, .parallel=TRUE, .paropts=list(.options.snow=list(progress=pbu))))

stopCluster(cl)

Ответ 7

На мой взгляд, большинство других ответов устарели rio::import_list, который является лаконичным однострочным:

library(rio)
my_data <- import_list(dir("path_to_directory", pattern = ".csv", rbind = TRUE))

Любые дополнительные аргументы передаются в rio::import. rio может заниматься практически любой файл формата R может читать, и он использует data.table fread, где это возможно, поэтому она должна быть слишком быстро.

Ответ 8

На основе комментария dnlbrk назначение может быть значительно быстрее, чем list2env для больших файлов.

library(readr)
library(stringr)

List_of_file_paths <- list.files(path ="C:/Users/Anon/Documents/Folder_with_csv_files/", pattern = ".csv", all.files = TRUE, full.names = TRUE)

Установив для аргумента full.names значение true, вы получите полный путь к каждому файлу в виде отдельной символьной строки в списке файлов, например List_of_file_paths [1] будет выглядеть как "C:/Users/Anon/Documents/Folder_with_csv_files/file1.csv"

for(f in 1:length(List_of_filepaths)) {
  file_name <- str_sub(string = List_of_filepaths[f], start = 46, end = -5)
  file_df <- read_csv(List_of_filepaths[f])  
  assign( x = file_name, value = file_df, envir = .GlobalEnv)
}

Вы можете использовать файл pack.dll.txt.txt вместо read_csv. Шаг file_name позволяет вам убрать имя так, чтобы каждый кадр данных не оставался с полным путем к файлу, как его имя. Вы можете расширить свой цикл, чтобы делать дальнейшие действия в таблице данных, прежде чем переносить его в глобальную среду, например:

for(f in 1:length(List_of_filepaths)) {
  file_name <- str_sub(string = List_of_filepaths[f], start = 46, end = -5)
  file_df <- read_csv(List_of_filepaths[f])  
  file_df <- file_df[,1:3] #if you only need the first three columns
  assign( x = file_name, value = file_df, envir = .GlobalEnv)
}

Ответ 9

Три верхних ответа от @A5C1D2H2I1M1N2O1R2T1, @leerssej и @marbel, по сути, одинаковы: применить fread к каждому файлу, а затем rbind/rbindlist получить результирующие data.tables. Я обычно использую форму rbindlist(lapply(list.files("*.csv"),fread)).

Это лучше, чем другие R-внутренние альтернативы, и хорошо для небольшого числа больших CSV, но не лучше для большого количества маленьких CSV, когда скорость имеет значение. В этом случае может быть намного быстрее сначала использовать cat, как @Spacedman предлагает в 4-м рейтинге ответа. Я добавлю некоторые подробности о том, как это сделать изнутри R:

x = fread(cmd='cat *.csv', header=F)

Однако, что, если у каждого CSV есть заголовок?

x = fread(cmd="awk 'NR==1||FNR!=1' *.csv", header=T)

А что, если у вас так много файлов, что глобус оболочки *.csv не работает?

x = fread(cmd='find . -name "*.csv" | xargs cat', header=F)

А что, если у всех файлов есть заголовок И слишком много файлов?

header = fread(cmd='find . -name "*.csv" | head -n1', header=T)
x = fread(cmd='find . -name "*.csv" | xargs tail -q -n+2', header=F)
names(x) = names(header)

А что если результирующий составной csv слишком велик для системной памяти?

system('find . -name "*.csv" | xargs cat > combined.csv')
x = fread('combined.csv', header=F)

С заголовками?

system('find . -name "*.csv" | head -n1 | xargs head -n1 > combined.csv')
system('find . -name "*.csv" | xargs tail -q -n+2 >> combined.csv')
x = fread('combined.csv', header=T)

Примечание: для data.table pre-v1.11.6 (19 сентября 2018 г.) опустите cmd= из fread(cmd=.

Ответ 10

Моя вилка принятого ответа немного быстрее и удаляет .csv из имени объекта в R.

temp = list.files(pattern="*.csv")
for (i in 1:length(temp)) assign(gsub(".csv", "", temp[i]), read_csv(temp[i]))

Он полагается на пакет readr (т. library(readr)). Вы можете сделать что-то подобное с data.table если хотите.

Ответ 11

Моя вилка принятого ответа немного быстрее и удаляет .csv из имени объекта в R.

temp = list.files(pattern="*.csv")
for (i in 1:length(temp)) assign(gsub(".csv", "", temp[i]), read_csv(temp[i]))

Он полагается на пакет readr (т. library(readr)). Вы можете сделать что-то подобное с data.table если хотите.

Ответ 12

Мне нравится подход, использующий list.files(), lapply() и list2env() (или fs::dir_ls(), purrr::map() и list2env()). Это кажется простым и гибким.

В качестве альтернативы вы можете попробовать небольшой пакет { tor } (to-R): по умолчанию он импортирует файлы из рабочего каталога в список (list_*() вариантов) или в глобальную среду (load_*() варианты).

Например, здесь я читаю все файлы .csv из моего рабочего каталога в список с помощью tor::list_csv():

library(tor)

dir()
#>  [1] "_pkgdown.yml"     "cran-comments.md" "csv1.csv"        
#>  [4] "csv2.csv"         "datasets"         "DESCRIPTION"     
#>  [7] "docs"             "inst"             "LICENSE.md"      
#> [10] "man"              "NAMESPACE"        "NEWS.md"         
#> [13] "R"                "README.md"        "README.Rmd"      
#> [16] "tests"            "tmp.R"            "tor.Rproj"

list_csv()
#> $csv1
#>   x
#> 1 1
#> 2 2
#> 
#> $csv2
#>   y
#> 1 a
#> 2 b

И теперь я загружаю эти файлы в мою глобальную среду с помощью tor::load_csv():

# The working directory contains .csv files
dir()
#>  [1] "_pkgdown.yml"     "cran-comments.md" "CRAN-RELEASE"    
#>  [4] "csv1.csv"         "csv2.csv"         "datasets"        
#>  [7] "DESCRIPTION"      "docs"             "inst"            
#> [10] "LICENSE.md"       "man"              "NAMESPACE"       
#> [13] "NEWS.md"          "R"                "README.md"       
#> [16] "README.Rmd"       "tests"            "tmp.R"           
#> [19] "tor.Rproj"

load_csv()

# Each file is now available as a dataframe in the global environment
csv1
#>   x
#> 1 1
#> 2 2
csv2
#>   y
#> 1 a
#> 2 b

Если вам нужно прочитать определенные файлы, вы можете сопоставить их путь к файлу с помощью regexp, ignore.case и invert.

Для еще большей гибкости используйте list_any(). Это позволяет вам предоставлять функцию чтения через аргумент .f.

(path_csv <- tor_example("csv"))
#> [1] "C:/Users/LeporeM/Documents/R/R-3.5.2/library/tor/extdata/csv"
dir(path_csv)
#> [1] "file1.csv" "file2.csv"

list_any(path_csv, read.csv)
#> $file1
#>   x
#> 1 1
#> 2 2
#> 
#> $file2
#>   y
#> 1 a
#> 2 b

Передайте дополнительные аргументы через... или внутри лямбда-функции.

path_csv %>% 
  list_any(readr::read_csv, skip = 1)
#> Parsed with column specification:
#> cols(
#>   '1' = col_double()
#> )
#> Parsed with column specification:
#> cols(
#>   a = col_character()
#> )
#> $file1
#> # A tibble: 1 x 1
#>     '1'
#>   <dbl>
#> 1     2
#> 
#> $file2
#> # A tibble: 1 x 1
#>   a    
#>   <chr>
#> 1 b

path_csv %>% 
  list_any(~read.csv(., stringsAsFactors = FALSE)) %>% 
  map(as_tibble)
#> $file1
#> # A tibble: 2 x 1
#>       x
#>   <int>
#> 1     1
#> 2     2
#> 
#> $file2
#> # A tibble: 2 x 1
#>   y    
#>   <chr>
#> 1 a    
#> 2 b

Ответ 13

Я использую это успешно:

xlist<-list.files(pattern = "*.csv")

for(i in xlist) { 
  x <- read.csv((i))
  assign(i, x)
    }

Ответ 14

если вы хотите собрать разные файлы csv в один файл data.frame, вы можете использовать следующее. обратите внимание, что "x" data.frame shoud будет создан заранее.

temp <- list.files(pattern="*.csv")
for (i in 1:length(temp)) {
    temp2 = read.csv(temp[i], header = TRUE)
    x <- rbind(x,temp2)
    }

Ответ 15

Для этого можно использовать пакет sparklyr:

# RStudio will help you get set-up with the Spark dependencies
library(sparklyr)
library(dplyr)
sc <- spark_connect(master = "local", version = "2.0.2")

df <- spark_read_csv(sc,
                     "dummy",
                     "file:////Users/bob/dev/data/results/*/*/*-metrics.csv") %>%
  collect()

Ответ 16

Это часть моего script.

#This cycle read the files in a directory and assign the filenames to datasets
files <- list.files(pattern=".csv$")
for(i in files) {
    X <- read.table(i, header=TRUE)
    SN<-X$A/X$B 
    X<-cbind(X,SN)
    ds<-paste("data_",i, sep="")#this add "data_" to the name of file
    ds<-substr(ds, 1, nchar(ds)-4)#remove the last 4 char (.csv)
    assign(ds, X)
}