Python 在R中加载和处理1000个文件

我对R有点陌生，所以请原谅这里的新手色彩

我正在用R编写代码，在脚本中加载1000个保存的数据帧（文件），该脚本对每个文件中的数据运行函数，并将结果值存储在向量中。我必须用不同的功能一遍又一遍地做这件事，目前这需要很长时间

我正在尝试使用多核McLappy并行化进程，但不幸的是，2-8核的任何操作似乎都比在一个核上运行要花费更长的时间

由于磁盘I/O限制，这种想法从根本上是不合理的吗？多核甚至R不是正确的解决方案吗？用Python之类的东西打开文件，然后在内容上运行R函数会比R更好吗

如果您对此有任何指导或想法，我们将不胜感激-

为清晰起见，添加了代码：

    library(multicore)

    project.path = "/pathtodata/"

    #This function reads the file location and name, then loads it and runs a simple statistic
    running_station_stats <- function(nsrdb_stations)
    {
      varname <- "column_name"
      load(file = paste(project.path, "data/",data_set_list[1], sep = ""))
      tempobj <- as.data.frame(coredata(get(data_set_list[2])))
      mean(tempobj[[varname]],na.rm=TRUE)
    }



    options(cores = 2)

    #This file has a list of R data files data_set_list[1] and the names they were created with data_set_list[2]
    load(file = paste(project.path, "data/data_set_list.RData", sep = ""))

    thelist <- list()

    thelist[[1]] <- data_set_list[1:50,]

    thelist[[2]] <- data_set_list[51:100,]

    thelist[[3]] <- data_set_list[101:150,]

    thelist[[4]] <- data_set_list[151:200,]


    #All three of these are about the same speed to run regardless of the num of cores
    system.time(
    {
      apply(nsrdb_stations[which(nsrdb_stations$org_stations==TRUE),][1:200,],1,running_station_stats)
    })

    system.time(
      lapply(thelist, apply, 1, running_station_stats)
     )

    system.time(
      mclapply(thelist, apply, 1, running_station_stats)
    )

库（多核）
project.path=“/pathtodata/”
#此函数读取文件位置和名称，然后加载它并运行简单的统计信息
运行_station_statsPython和R都会尝试使用多个内核来处理数字运算之类的事情。它对读取大量文件没有帮助。多线程也不是答案（re）

一些可能的解决方案（没有一个是简单的）是：


使用类似twisted的东西，您可以（部分）将文件io异步。硬编程，而且不太友好
使用芹菜或其他国产主从式解决方案。你自己的行动有很多
使用Ipython（w/）生成python将为您重新组合的多个进程（最佳解决方案IMO）
我会先尝试用Python进行好的老式多处理。上述选项也都是可能的。下面是一个使用多处理模块执行批处理作业的示例


将多处理作为mp导入
导入时间

def工人（x）：
睡眠时间（0.2）
打印“x=%s，x平方=%s”%（x，x*x）
返回x*x

def apply_async（）：
pool=mp.pool（）
对于范围（100）内的i：
pool.apply_async（worker，args=（i，））
pool.close（）
pool.join（）

如果name='main'：
应用异步


输出如下所示：


x=0，x平方=0
x=1，x的平方=1
x=2，x的平方=4
x=3，x平方=9
x=4，x的平方=16
x=6，x平方=36
x=5，x平方=25
x=7，x平方=49
x=8，x平方=64
x=10，x的平方=100
x=11，x平方=121
x=9，x平方=81
x=12，x平方=144


正如您所看到的，这些数字不是按顺序排列的，因为它们是异步执行的。只需更改上面的worker（）函数即可进行处理，并可能更改mp.Pool（10）或mp.Pool（15）或其他类型的并发进程数。像这样的东西应该是相对比较狭隘的
 除非您向我们展示您的代码在做什么，否则无法知道，其他人只能猜测。您可以自己测试文件访问是限制问题还是其他问题。一旦你把问题归结到它的组成部分，你就可以自己回答这个问题了。如果数据已经在数据帧中，那么通过另一种语言封送R本机格式可能只会减慢速度。但是正如mdsumner所指出的，我们只能根据您所展示的内容进行猜测。mdsumner-如果在这个简化的代码示例中有什么东西让您作为一个性能狗而感到惊讶，请告诉我。如果我发现一些加快处理速度的东西，我会把它贴在这里。谢谢你的评论和建议。如果有任何问题，我会发回。GIL是一个python线程问题。R中的多核包不存在此问题。但是，读取大量文件更受可用磁盘io数量的限制，而不是线程数量的限制。我认为python
多处理库不会受到GIL的影响。这个解决方案类似于lpython。

import multiprocessing as mp
import time


def worker(x):
    time.sleep(0.2)
    print "x= %s, x squared = %s" % (x, x*x)
    return x*x


def apply_async():
    pool = mp.Pool()
    for i in range(100):
        pool.apply_async(worker, args = (i, ))
    pool.close()
    pool.join()


if name == 'main':
    apply_async()




x= 0, x squared = 0
x= 1, x squared = 1
x= 2, x squared = 4
x= 3, x squared = 9
x= 4, x squared = 16
x= 6, x squared = 36
x= 5, x squared = 25
x= 7, x squared = 49
x= 8, x squared = 64
x= 10, x squared = 100
x= 11, x squared = 121
x= 9, x squared = 81
x= 12, x squared = 144