Question

我使用python来neardupe文件的大量列表（超过20000）。总计大约300 MB

目前的方法是使用difflib的SequenceMatcher进行近乎重复的检查并使用QuickRatio获取结果。

使用4个工作流程完成工作需要25个小时，这很慢。

我还尝试了Livenstheine，它提供了C base近双重检查，但它比difflib更慢，更准确。

需要以这种方式进行检查：一个文件夹中有20000个文件。每个文件需要在每次迭代时与文件夹中的20000个文件进行比较。所以会有20000 * 20000次迭代。

我想到的是索引所有文件并比较索引但我不熟悉索引，我不确定它是否会起作用。如果那样的话，最好的索引选项是什么？

感谢。

以下是代码：

import os,sys,chardet, csv,operator,time,subprocess
from difflib import SequenceMatcher
import threading
#from threading import Timer
import multiprocessing
from multiprocessing import Pool

OrgFile = ""
mark = int(sys.argv[2])

def init_logger():
    print "Starting %s" % multiprocessing.current_process().name

#----Get_Near_DupeStatus--------#
def Get_Near_DupeStatus(score):
    if score > 30 and score <= 50:
        return "Low Inclusive"
    elif score > 50 and score <= 75:
        return "Inclusive"
    elif score > 75 and score <= 85:
        return "Most Inclusive"
    elif score > 85 and score <= 99:
        return "Near-Dupe"
    elif score == 100:
        return "Unique"
    else: return "No Inclusive"

#----Write_To_CSV --- ALL-------#
def Write_To_CSV_All(List):
    writer = csv.writer(open('./TableList.csv','wb'),delimiter=';', quotechar=' ', quoting=csv.QUOTE_MINIMAL)
    writer.writerow(['Path/FileName(Source);'+'ID;'+'NearDupeID;'+'Similarity Score;'+'Near_DupeStatus;'+'NearDupeProcess(Y/N);'+'Encoding'])
    for i,li in enumerate(sorted(List, key=operator.itemgetter("NearDupeID"))):
        writer.writerow([li['Path/FileName(Source)']+";"+'ID00'+str(i+1)+";"+str(li['NearDupeID'])+";"+str(li['Similarity Score'])+";"+li['Near_DupeStatus']+";"+li['NearDupeProcess(Y/N)']+";"+li['Encoding']])

#Get Finish File List
def Finish_Files(List,count,id):
    finish_files = []
    for i,li in enumerate(sorted(List, key=operator.itemgetter("Similarity Score"), reverse=True)):
        if i < count:
            li['NearDupeID'] = id
            finish_files.append(li)
        if count == 0:
            li['NearDupeID'] = id
#            if li['Similarity Score'] > 50:
            finish_files.append(li)
    return finish_files

#----Search Files in Dir--------#
def GetFileListFrom_Dir(dir):
    FileList = []
    for root,dirs,filenames in os.walk(dir):
        for filename in filenames:
            realpath = os.path.join(root, filename)
            FileList.append(realpath)
    return FileList

#----Matcher--------#
def Matcher(realpath):
    junk = ["\t","\n","\r"]
    score = 0
    dict = {}
    MatchFile = ""
    dupe_Process = 'N'
    if os.path.isfile(realpath):
        MatchFile =  open(realpath).read()
        matcher = SequenceMatcher(lambda x: x in junk,OrgFile, MatchFile)
        score = int(matcher.ratio()*100)
        if score >= mark:
            encoding = chardet.detect(MatchFile)['encoding']
            if encoding == None: encoding = 'None'
            if score > 85: dupe_Process = 'Y'
            dict = {'Path/FileName(Source)':realpath,'Similarity Score':score,'Near_DupeStatus':Get_Near_DupeStatus(score),'NearDupeProcess(Y/N)':dupe_Process,'Encoding':encoding}
            return dict

#-------------Pooling--------------------#
def MatcherPooling(FileList,orgFile,process):
    global OrgFile
    OrgFile = open(orgFile).read()
    pool_obj = Pool(processes=process)
    #pool_obj = Pool(processes=process,initializer=init_logger)
    dict = {}
    DictList = []
    dict = pool_obj.map(Matcher,FileList)
    DictList.append(dict)
    pool_obj.close()
    pool_obj.join()
    return DictList

def Progress():
    p = "/-\\|"
#    global t
    for s in p:
        time.sleep(0.1)
        sys.stdout.write("%c" % s)
        sys.stdout.flush()
        sys.stdout.write('\b')
    t2 = threading.Timer(0.1,Progress).start()
#    t.start()


#----Main--------#
def Main():
    Mainls = []
    dictList = []
    finish_List = []
    BLINK = '\033[05m'
    NOBLINK = '\033[25m'
    dir = sys.argv[1]
    process = int(sys.argv[3])
    Top_rec = int(sys.argv[4])
    Mainls = GetFileListFrom_Dir(dir)
    bar = "*"
    # setup toolbar
    sys.stdout.write("%s" % BLINK+"Processing...."+ NOBLINK + "With "+ str(process) + " Multi Process...")#+" \n")
    if Top_rec != 0:
        charwidth = len(Mainls)/Top_rec
    elif Top_rec == 0: charwidth = len(Mainls)
    t = threading.Timer(0.1,Progress)
    t.start()
#    sys.stdout.write("[%s]" % ("-" * charwidth))
#    sys.stdout.flush()
#    sys.stdout.write("\b" * (charwidth+1)) # return to start of line, after '['

    #----------------------------------------------------------#
    for id,orgFile in enumerate(sorted(Mainls)):
        for dl in MatcherPooling(sorted(Mainls),orgFile,process):
            for dict in dl:
                if dict != None:
                    dictList.append(dict)

            #Append Finish Files List For CSV ALL(Write Once)
            fl = Finish_Files(dictList,Top_rec,id+1)
            if Top_rec != 0:
                for del_List in fl:
                    Mainls.remove(del_List['Path/FileName(Source)'])
                    Mainls.sort()

            finish_List.extend(fl)
            dictList = []

        sys.stdout.write("%s" % bar)
        sys.stdout.flush()

        #Exit Loop
        if len(Mainls) == 0:
            break
    #----------------------------------------------------------#
    Write_To_CSV_All(finish_List)
    #print os.system('clear')
    sys.stdout.write("%s" % " ")
    print "Finished!"
    t.cancel()
    print os._exit(99)

if __name__ == '__main__':
    Main()

Answer 1

部分答案，但一个明显的优化是仅比较大小相同的文件。同时比较文件a和文件b与比较b和a相同：20000个文件给出20000 *（20000-1）/ 2个比较。 300 MB不是那么大，你可以尝试先读入所有文件。

在索引编制方面，它只是用一个或多个数字来描述每个文件。大小是一个。非白色空格或空格或新行字符的数量可以是其他字符。如果文件都包含相同类型的数据，则可以解释数据以创建更多有用的数字。此外，完全相同的文件将具有相同的SHA-256哈希。这只有在大部分文件完全相同时才有用。

import hashlib
m = hashlib.sha256()
m.update(file_contents)
this_files_hash_value=m.digest()

不幸的是，我认为没有方法可以完全准确地和正确地分解difflib.SequenceMatcher所做的事情（部分），因为它动态地比较输入文件的所有可能块。

Answer 2

如前所述，我会首先仅比较MIME类型中大小相近或类似的文件。

然后我会继续比较一小部分数据以立即排除大多数情况。一个不错的算法将从一小块文件开始，比较它，如果它足够相似，将大小增加2倍（或更多，如果你想要），等等，直到你完成比较所有内容，或直到任何阶段相似因子太低了。

这意味着可能前1-2次迭代将排除大多数文件。

Answer 3

首先，您应该知道您的程序是否尽可能快。

计算比较2个文件所需的平均执行时间。只是比较它们，不要使用多处理，不要索引什么，不要写csv什么。
乘以20000 x 10000 / 4（因为你有4名工人）
将您获得的结果与当前的25小时进行比较。

我认为这是一项非常重要的测试，因为它会显示您目前的比较算法是否还有改进的余地。

如果还有改进的余地，那就开始了！因为一旦你有了optimezied程序，你就可以继续前进并开始寻找更好的比较解决方案。

如果你想询问如何做到这一点的帮助，你必须提供一个更易读的代码示例（简称），因为你现在无法处理它。

Answer 4

如果您使用大型集合，并且您不仅希望找到重复项，而且还希望在基于文本的文件（PDF，DOC，HTML等）中找到重复项，那么您可能需要考虑以下内容： http://softcorporation.com/products/neardup/ 它基于Java，因此可以在不同的平台上运行，您可以免费下载。

对大量文件列表进行重复检查的最佳方法或算法？

4 个答案: