Python：更快地遍历文件夹

【概述】

说起，如何快速地遍历文件夹。或许，某人立刻就想到了线程池，几个worker并行处理遍历任务，总比一个worker的速度更快吧。当然，很多人不以为然。这要看单机性能是否够强悍，使你能够起更多的worker，以加快速度。我们，先来看看Python遍历文件夹的几种方案：

1. 分析MFT，获取目录结构（仅适合NTFS格式）；
2. 使用os.walk或os.path.walk遍历；
3. 使用os.listdir递归遍历；
4. 创建一个shell process交互，使用ls（windows 下dir.exe）遍历；
5. 线程池并行处理遍历，工作线程使用os.listdir。

至于第一种方案，需要读取卷中的$MFT文件，并分析里面的文件记录项，代表作为everything.exe，此处略过。

【walk遍历】

这是最简单施工的一种目录遍历，Python已经把的性能做的很好，应付结构复杂度小的目录，显得性能最佳。

def IterateFiles(directory):
    assert os.path.isdir(directory),'make sure directory argument should be a directory'
    result = []
    for root,dirs,files in os.walk(directory, topdown=True):
        for fl in files:
            result.append(os.path.join(root,fl))

    return result

有一个缺陷，如果子文件夹过深，将导致如下错误：

names = listdir(top)
TypeError: must be (buffer overflow), not st

此时，将参数directory的值使用Unicode对象即可，如：

directory = u”D:\\”

另外，walk函数参数topdown设置为True时，将自顶向下遍历。经检验，这样的遍历速度最优。

【递归遍历】

递归遍历，我最讨厌的一种方案。理论上，它是相当的费时间，同时在这里，还不能使用迭代器，造成内存空间大部分的占用，实不适宜用来应对大文件夹。

def IterateFile_Recursion(directory):
    assert os.path.isdir(directory),'make sure directory argument should be a directory'
    def recuirfunc(dirs,result):
        if not dirs:
            return result

        temp = dirs.pop()
        for item in os.listdir(temp):
            path = os.path.join(temp,item)
            if os.path.isdir(path):
                dirs.append(path)
            else:
                result.append(path)

        recuirfunc(dirs,result)

    dirs = [directory]
    result = []
    recuirfunc(dirs,result)

    return result

另外，如果文件夹的深度过深，会导致以下报错：

RuntimeError: maximum recursion depth exceeded in cmp

另外，python不允许过多的递归次数，所以请弃用。
可是，我的实验数据说明，面对小文件夹，递归调用更是一把利剑，速度比walk还快。

【借用dir.exe】

即是调用subprocess.Popen创建一个dir.exe进程，通过subprocess.PIPE与之进行交互（处理输入输出）。请注意，如果目录结构复杂，包含大量的子文件夹和文件，容易造成通信阻塞。因此，我们需要及时处理输出，使管道畅通。

def IterateFiles_CMD(directory):
    assert os.path.isdir(directory),'make sure directory argument should be a directory'
    cmd = 'dir /s /B /A-D ' + directory
    ret = []
    p = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)

    for line in p.stdout.readlines():
        ret.append(line)

    if p.wait() == 0:
        return ret

我们使用help dir查看dir.exe使用说明，会发现：

/S 显示指定目录和所有子目录中的文件。
/B 使用空格式(没有标题信息或摘要)。
/A 显示具有指定属性的文件 - 表示“否”的前缀

因此，命令【dir /s /B /A-D】即为显示目录下所有的文件，显示格式是文件绝对路径为一行。
面对windows下大文件夹，推荐使用该方案，缺点就是内存占用较大。经检验，面对7W个文件，遍历时间为20min，相对于其他方法，速度提升4倍。面对小文件夹，请弃用，因为这里起个进程都需要时间啦。

【线程池】

如果单机性能够强大，请考虑……
等等，还是不要考虑了。线程池，最严重的问题在于阻塞，这里是相当耗时间的。

def list_dir(directory):
    dirlist = []
    filelist = []

    try:
        for item in os.listdir(directory):
            path = os.path.join(directory,item)
            if os.path.isfile(path):
                filelist.append(path)
            else:
                dirlist.append(path)
    except:
        pass

    return (dirlist,filelist)


class ListWorker(threading.Thread):
    def __init__(self,requestQueue,resultlist):
        threading.Thread.__init__(self)
        self.request_queue = requestQueue
        self.result_list = resultlist
        self.setDaemon(True) 
        self.start()

    def run(self):
        while True:
            try:
                callback,args = self.request_queue.get(block=True,timeout=0.01)
            except Queue.Empty:
                break

            dirlist,filelist = callback(args[0])

            self.request_queue.task_done()#通知系统任务完成

            for item in dirlist:
                self.request_queue.put((callback,(item,)))
            self.result_list += filelist

class ListManager(object):
    def __init__(self,request_queue,threadnum=9):
        self.request_queue = request_queue
        self.result_list = []
        self.threads = []
        self.__init_thread_pool(threadnum)

    def __init_thread_pool(self,threadnum):
        for i in xrange(threadnum):
            self.threads.append(ListWorker(self.request_queue,self.result_list))

    def add_job(self,callback,*args):
        self.request_queue.put((callback,args))

    def complete_all(self):
        while len(self.threads):
            worker = self.threads.pop()
            worker.join()

最后，简单地对比一下他们的速度

    path = ur'D:\working'
    t = time.time()
    list_manager = ListManager(Queue.Queue(-1))
    list_manager.add_job(list_dir,path)
    list_manager.complete_all()
    print len(list_manager.result_list)
    t2 = time.time()
    print t2 -t
    print len(list(IterateFiles_CMD(path)))
    t3 = time.time() 
    print t3 -t2
    print len(list(IterateFiles(path)))
    t4 = time.time()
    print t4-t3
    print len(IterateFile_Recursion(path))
    t5 = time.time()
    print t5-t4

严格意义上来说，以上对比很不科学，这里，仅作为参考。
结果如下：

1551
14.2649998665
1551
0.766000032425
1551
0.0900001525879
1551
0.0799999237061