Comment importer plusieurs fichiers .csv à la fois?

Supposons que nous ayons un dossier contenant plusieurs fichiers data.csv, chacun contenant le même nombre de variables mais chacun à des moments différents. Existe-t-il un moyen dans R de les importer tous simultanément plutôt que d'avoir à les importer tous individuellement?

Mon problème est que j'ai environ 2000 fichiers de données à importer et que je dois les importer individuellement simplement en utilisant le code:

read.delim(file="filename", header=TRUE, sep="\t")

n'est pas très efficace.

Quelque chose comme ce qui suit devrait se traduire par chaque bloc de données comme un élément distinct dans une seule liste:

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

Cela suppose que vous avez ces CSV dans un seul répertoire - votre répertoire de travail actuel - et que tous ont l'extension en minuscule .csv.

Si vous souhaitez ensuite combiner ces trames de données en une seule trame de données, voir les solutions dans d'autres réponses en utilisant des choses comme do.call(rbind,...), dplyr::bind_rows()ou data.table::rbindlist().

Si vous voulez vraiment chaque bloc de données dans un objet séparé, même si cela est souvent déconseillé, vous pouvez effectuer les opérations suivantes avec assign:

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

Ou, sans assign, et pour montrer (1) comment nettoyer le nom du fichier et (2) montrer comment l'utiliser list2env, vous pouvez essayer ce qui suit:

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

Mais encore une fois, il est souvent préférable de les laisser dans une seule liste.

Une tidyversesolution rapide et succincte : (plus de deux fois plus rapide que les Base R read.csv )

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

et data.table « s fread()peuvent même réduire les temps de chargement de moitié à nouveau. (pour 1/4 des temps Base R )

library(data.table)

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

L' stringsAsFactors = FALSEargument maintient le facteur de trame de données libre (et comme le souligne Marbel, est le paramètre par défaut pourfread )

Si le transtypage est effronté, vous pouvez forcer toutes les colonnes à être en tant que caractères avec l' col_typesargument.

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

Si vous souhaitez vous plonger dans des sous-répertoires pour construire votre liste de fichiers à lier, assurez-vous d'inclure le nom du chemin et d'enregistrer les fichiers avec leurs noms complets dans votre liste. Cela permettra au travail de liaison de se poursuivre en dehors du répertoire actuel. (En pensant aux chemins d'accès complets comme fonctionnant comme des passeports pour permettre le retour à travers les «frontières» du répertoire.)

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

Comme Hadley le décrit ici (à mi-chemin environ):

map_df(x, f)est effectivement le même que do.call("rbind", lapply(x, f))....

Bonus - ajout de noms de fichiers aux enregistrements par demande de fonctionnalité Niks dans les commentaires ci-dessous:
* Ajouter l'originalfilename à chaque enregistrement.

Explication du code: créer une fonction pour ajouter le nom de fichier à chaque enregistrement lors de la lecture initiale des tableaux. Utilisez ensuite cette fonction au lieu de la read_csv()fonction simple .

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

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

(Les approches de transtypage et de gestion des sous-répertoires peuvent également être gérées à l'intérieur de la read_plus()fonction de la même manière que celle illustrée dans les deuxième et troisième variantes suggérées ci-dessus.)

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

Cas d'utilisation de Middling

Cas d'utilisation plus grand

Variété de cas d'utilisation

Lignes: nombre de fichiers (1000, 100, 10)
Colonnes: taille finale de la trame de données (5 Mo, 50 Mo, 500 Mo)
(cliquez sur l'image pour voir la taille d'origine)

Les résultats R de base sont meilleurs pour les cas d'utilisation les plus petits où la surcharge liée à l'utilisation des bibliothèques C de purrr et dplyr l'emporte sur les gains de performances observés lors de l'exécution de tâches de traitement à plus grande échelle.

si vous souhaitez exécuter vos propres tests, ce script bash peut vous être utile.

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 créera 100 copies de votre fichier numérotées séquentiellement (après les 8 premiers caractères du nom de fichier et un trait de soulignement).

Attributions et appréciations

Un merci spécial à:

• Tyler Rinker et Akrun pour avoir fait la démonstration de microbenchmark.
• Jake Kaupp pour m'avoir présenté map_df() ici .
• David McLaughlin pour des commentaires utiles sur l'amélioration des visualisations et la discussion / confirmation des inversions de performances observées dans le petit fichier, les résultats de l'analyse de la petite trame de données.
• marbel pour avoir souligné le comportement par défaut de fread(). (J'ai besoin d'étudier data.table.)

Voici quelques options pour convertir les fichiers .csv en un data.frame en utilisant la base R et certains des packages disponibles pour lire les fichiers en R.

C'est plus lent que les options ci-dessous.

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

Modifier: - Quelques choix supplémentaires en utilisant data.tableetreadr

Une fread()version, qui est une fonction du data.tablepackage. Ceci est de loin l'option la plus rapide en R .

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

Utilisation de readr , qui est un autre package pour lire les fichiers csv. Il est plus lent que fread, plus rapide que la base R mais a des fonctionnalités différentes.

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

En plus d'utiliser lapply ou d'une autre construction en boucle dans R, vous pouvez fusionner vos fichiers CSV en un seul fichier.

Sous Unix, si les fichiers n'ont pas d'en-tête, c'est aussi simple que:

cat *.csv > all.csv

ou s'il y a des en-têtes et que vous pouvez trouver une chaîne qui correspond aux en-têtes et uniquement aux en-têtes (par exemple, supposons que les lignes d'en-tête commencent toutes par "Age"), vous feriez:

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

Je pense que dans Windows, vous pouvez le faire avec COPYet SEARCH(ou FINDquelque chose) à partir de la boîte de commande DOS, mais pourquoi ne pas installer cygwinet obtenir la puissance du shell de commande Unix?

Ceci est le code que j'ai développé pour lire tous les fichiers csv dans R. Il créera un cadre de données pour chaque fichier csv individuellement et titre ce cadre de données le nom d'origine du fichier (en supprimant les espaces et le .csv) J'espère que vous le trouverez utile!

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

Les trois premières réponses de @ A5C1D2H2I1M1N2O1R2T1, @leerssej et @marbel et sont toutes essentiellement les mêmes: appliquez une frayeur à chaque fichier, puis rbind / rbindlist les données.tables résultantes. J'utilise habituellement lerbindlist(lapply(list.files("*.csv"),fread)) formulaire.

C'est mieux que les autres alternatives internes à R, et c'est bien pour un petit nombre de grands csv, mais pas le meilleur pour un grand nombre de petits csv lorsque la vitesse compte. Dans ce cas, la première utilisation peut être beaucoup plus rapide cat, comme le suggère @Spacedman dans la réponse au 4e rang. Je vais ajouter quelques détails sur la façon de procéder à partir de R:

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

Cependant, que se passe-t-il si chaque csv a un en-tête?

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

Et si vous avez tellement de fichiers que le *.csvglob de shell échoue?

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

Et si tous les fichiers ont un en-tête ET qu'il y a trop de fichiers?

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

Et si le csv concaténé résultant est trop grand pour la mémoire système?

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

Avec des en-têtes?

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)

Enfin, que se passe-t-il si vous ne voulez pas tous les .csv dans un répertoire, mais plutôt un ensemble spécifique de fichiers? (En outre, ils ont tous des en-têtes.) (Ceci est mon cas d'utilisation.)

fread(text=paste0(system("xargs cat|awk 'NR==1||$1!=\"<column one name>\"'",input=paths,intern=T),collapse="\n"),header=T,sep="\t")

et ceci est à peu près la même vitesse que le chat xargs à effroi :)

Remarque: pour data.table pré-v1.11.6 (19 septembre 2018), omettez le cmd=from fread(cmd=.

Addendum: l'utilisation de mclapply de la bibliothèque parallèle à la place de lapply série, par exemple, rbindlist(lapply(list.files("*.csv"),fread))est également beaucoup plus rapide que rbindlist lapply fread.

Temps de lecture des csvs 121401 dans une seule table de données. Chaque csv comporte 3 colonnes, une ligne d'en-tête et, en moyenne, 4 510 lignes. La machine est une machine virtuelle GCP avec 96 cœurs:

rbindlist lapply fread   234.172s 247.513s 256.349s
rbindlist mclapply fread  15.223s   9.558s   9.292s
fread xargs cat            4.761s   4.259s   5.095s

Pour résumer, si vous êtes intéressé par la vitesse et que vous avez beaucoup de fichiers et de cœurs, fread xargs cat est environ 50 fois plus rapide que la solution la plus rapide dans les 3 meilleures réponses.

À mon avis, la plupart des autres réponses sont obsolètes rio::import_list, ce qui est une ligne succincte:

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

Tous les arguments supplémentaires sont passés à rio::import. riopeut traiter presque tous les formats fichier R peut lire, et il utilise data.tableest la freadmesure du possible, il devrait donc être rapide aussi.

Son utilisation plyr::ldplyaugmente d'environ 50% la vitesse en activant l' .paralleloption lors de la lecture de 400 fichiers csv d'environ 30 à 40 Mo chacun. L'exemple comprend une barre de progression du texte.

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)

En s'appuyant sur le commentaire de dnlbrk, l'attribution peut être considérablement plus rapide que list2env pour les gros fichiers.

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)

En définissant l'argument full.names sur true, vous obtiendrez le chemin d'accès complet à chaque fichier sous la forme d'une chaîne de caractères distincte dans votre liste de fichiers, par exemple, List_of_file_paths [1] sera quelque chose comme "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)
}

Vous pouvez utiliser fread ou base R read.csv du package data.table au lieu de read_csv. L'étape nom_fichier vous permet de ranger le nom afin que chaque trame de données ne reste pas avec le chemin d'accès complet au fichier tel qu'il est nom. Vous pouvez étendre votre boucle pour faire d'autres choses dans la table de données avant de la transférer dans l'environnement global, par exemple:

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

Voici mon exemple spécifique pour lire plusieurs fichiers et les combiner en 1 bloc de données:

path<- file.path("C:/folder/subfolder")
files <- list.files(path=path, pattern="/*.csv",full.names = T)
library(data.table)
data = do.call(rbind, lapply(files, function(x) read.csv(x, stringsAsFactors = FALSE)))

Les codes suivants devraient vous donner la vitesse la plus rapide pour les mégadonnées tant que vous avez plusieurs cœurs sur votre ordinateur:

if (!require("pacman")) install.packages("pacman")
pacman::p_load(doParallel, data.table, stringr)

# get the file name
dir() %>% str_subset("\\.csv$") -> fn

# use parallel setting
(cl <- detectCores() %>%
  makeCluster()) %>%
  registerDoParallel()

# read and bind all files together
system.time({
  big_df <- foreach(
    i = fn,
    .packages = "data.table"
  ) %dopar%
    {
      fread(i, colClasses = "character")
    } %>%
    rbindlist(fill = TRUE)
})

# end of parallel work
stopImplicitCluster(cl)

Mis à jour en 2020/04/16: Comme je trouve un nouveau package disponible pour le calcul parallèle, une solution alternative est fournie en utilisant les codes suivants.

if (!require("pacman")) install.packages("pacman")
pacman::p_load(future.apply, data.table, stringr)

# get the file name
dir() %>% str_subset("\\.csv$") -> fn

plan(multiprocess)

future_lapply(fn,fread,colClasses = "character") %>% 
  rbindlist(fill = TRUE) -> res

# res is the merged data.table

J'aime l'approche utilisant list.files() , lapply()et list2env()(ou fs::dir_ls(), purrr::map()et list2env()). Cela semble simple et flexible.

Vous pouvez également essayer le petit package { tor } ( to-R ): par défaut, il importe des fichiers du répertoire de travail dans une liste ( list_*()variantes) ou dans l'environnement global (load_*() variantes).

Par exemple, ici, je lis tous les fichiers .csv de mon répertoire de travail dans une liste en utilisant 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

Et maintenant, je charge ces fichiers dans mon environnement mondial avec 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

Si vous avez besoin de lire des fichiers spécifiques, vous pouvez faire correspondre leur chemin de fichier avec regexp , ignore.caseet invert.

Pour encore plus de flexibilité, utilisez list_any() . Il vous permet de fournir la fonction lecteur via l'argument .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

Passez des arguments supplémentaires via ... ou à l'intérieur de la fonction lambda.

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

Il m'a été demandé d'ajouter cette fonctionnalité au package stackoverflow R. Étant donné qu'il s'agit d'un petit paquet inverse (et ne peut pas dépendre de paquets tiers), voici ce que j'ai trouvé:

#' Bulk import data files 
#' 
#' Read in each file at a path and then unnest them. Defaults to csv format.
#' 
#' @param path        a character vector of full path names
#' @param pattern     an optional \link[=regex]{regular expression}. Only file names which match the regular expression will be returned.
#' @param reader      a function that can read data from a file name.
#' @param ...         optional arguments to pass to the reader function (eg \code{stringsAsFactors}).
#' @param reducer     a function to unnest the individual data files. Use I to retain the nested structure. 
#' @param recursive     logical. Should the listing recurse into directories?
#'  
#' @author Neal Fultz
#' @references \url{/programming/11433432/how-to-import-multiple-csv-files-at-once}
#' 
#' @importFrom utils read.csv
#' @export
read.directory <- function(path='.', pattern=NULL, reader=read.csv, ..., 
                           reducer=function(dfs) do.call(rbind.data.frame, dfs), recursive=FALSE) {
  files <- list.files(path, pattern, full.names = TRUE, recursive = recursive)

  reducer(lapply(files, reader, ...))
}

En paramétrant la fonction de lecture et de réduction, les utilisateurs peuvent utiliser data.table ou dplyr s'ils le souhaitent, ou simplement utiliser les fonctions de base R qui conviennent aux petits ensembles de données.