Part 1、理论基础

1.1 关于理论

其实这次不应该叫“理论基础”了，应该叫“基础理论”，本着简单明了一看就懂的原则，就着这张越来越厚枪打不透的脸皮，我就“勉为其难”来讲一讲。

如果你之前没听说过TF-IDF，那我估计你现在看到TF-IDF也不会觉得特别陌生，你一定会感觉在哪见过，但又不是特别确切，那我再估计一下，你这模糊的记忆一定是TF-BOYS，那么TF-IDF和TF-BOYS到底是什么关系呢？我也不用跟你慢慢道来了，因为他俩的关系太简单了，不，应该是他四个的关系太简单了，还不对，应该是它一个和他三个的关系太简单了，简单到可以用一句话来总结，那就是：没有半毛钱关系，没有！没有！没有！哈，扯了半天，下面正式开讲。

首先来引用一下百度百科的解释：

TF-IDF(term frequency–inverse document frequency，词频-逆向文件频率)是一种用于信息检索与数据挖掘的常用加权技术。

TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。

TF-IDF的主要思想是：如果某个词或短语在一篇文章中出现的频率TF高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。

再简单一点讲，它就是一种利用统计方法为词加权的技术，权值大小由两部分决定，一是这个词在这篇文档中出现的频率，频率越高，权值越大，也就是词频（TF）；二是整个文档集中出现该词的文档数量，数量越多权值越小，也就是逆文件频率（IDF）。写成式子就是这样：

加1是防止分母为0，这里的计算都已经是最简单的形式了，有兴趣的可以对公式进行优化，那么基础理论也就讲完了。

如果还不清楚，那就举个简单的例子：说文档集一共有100篇文章，其中有一篇有1000个词，并且“中国”、“北京”这两个词分别出现5次和10次，又知道出现过“中国”这个词的文档有50个，出现过“北京”这个词的文档有25个，那么有了以上信息我们就可以计算这篇文档中的“中国”、“北京”两个词的TF-IDF值了，过程如下：

这个结果就是“中国”和“北京”在这篇文档中的权重，从数值上来看，“北京”比“中国”更能代表这篇文档的中心内容，如果简单的用“北京”和“中国”作为标签来对文档进行分类，那么“北京”即可以作为这篇文档的标签。

1.2 关于算法

有了上面的分析，设计算法就比较简单了，只要清楚我们所需要的统计量，一切就好办了，这里就简单说明一下会用到统计量。
（1）输入的文档集。这里我使用的约900篇文章，每篇500字左右，每篇单独一个txt文档。
（2）每篇文章详细的统计量。这里我使用的是一个嵌套的字典，在程序中命名为oneFileInfo，它形式是这样的：

（3）包含某词的文档的数量。还是用一个字典来实现，命名allFileInfo，形式：

（4）总的文档数量。
（5）每篇文档中词的数量。

清楚了这几个统计量，其他就是程序实现的问题了，如果说还有其他什么需要注意的，在我看来就是中文文档的编码问题了，这里我使用的输入文档都是“utf-8”编码的，程序中也会有相应的decode和encode转换函数

Part 2、算法实现

from __future__ import division
import re
import jieba
import math
import os
import sys
reload(sys)
sys.setdefaultencoding('utf8')

# part 1
# 一些可能用到的函数

OutTypeList = ['utf-8'] 
InTypeList = ['utf-8'] 
stopWord=[]
                
def toDecode(str1,type1):       #自定义一个异常
    try:
        str1.decode(type1)
    except UnicodeDecodeError:
        return False
    else:
        return True
   
def beDecode(str1, *typeList):    #decode函数
#星号表示收集参数，即除了第一参数，其余都认为是typeList带来的的参数
    if not typeList:
        if toDecode(str1,'utf_8'):
            return str1.decode('utf-8')
        else:
            print "输入的原文本格式不是utf-8"
    else:
        for type2 in typeList:
            if toDecode(str1, type2):
                return str1.decode(type2)
            else:
                if type2 == typeList[-1]:
                    print "输入的源文件的编码格式不在您提供的格式列表中"

def toEecode(str1,type1):          #自定义一个异常
    try:
        str1.encode(type1)
    except LookupError:
        return False
    else:
        return True
    
def beEncode(str1, *outType):       #encode函数
    if not outType:
        return str1.encode('utf-8')
    else:
        for type2 in outType:
            if toEncode(str1, type2):
                return str1.encode(type2)
            else:
                if type2 == outType[-1]:
                    print "输入的目标编码格式不正确"

def ReplaceWord(SourceDocument,char,*words):  #替换SourceDocument中的某些字符
    DocAftReplace = SourceDocument
    for word in words:
        DocAftReplace = DocAftReplace.replace(word,char)
    return DocAftReplace

# part 2
# 分词函数

def fullcut(document):    #分词函数，这里使用的是jieba分词
    WordList = []
    DocumentAfterCut = jieba.cut(document, cut_all=False)     #精确模式进行分词
    toWordList = list(DocumentAfterCut)      #分词结果转为list（列表）类型    
    if not stopWord:
        temp = '/'.join(toWordList)
        r = r'[^/]{2,}' 
        WordList = re.findall(r, temp)
    else:                                                     #如果stopWord不为空
        for word in toWordList:
            if word not in stopWord:
                WordList.append(word)
    return WordList

# part3
# 因为我的输入文档集中每个文档是单独的txt
# 所以这里使用一个函数将各文档分词后合并到一个文档中。

def toGroupFile(FileFrom, resultDoc, *WordToDel):           
    FileUrl = FileFrom.replace('\\','/')                #待处理文件目录
    resultUrl = resultDoc.replace('\\','/')             #存放处理结果的文件的目录
    fileDic = os.listdir(FileUrl)                       #获取所有待处理文件的文件名
    openResult = open(resultUrl,'w')
    
    i = 0
    for files in fileDic:         #遍历fileDic（其实就是FileFrom）中的每个文件
        i += 1
        
        fileUrl = FileFrom + '/' + files                  #合成每个文档的路径
        if os.path.isfile(fileUrl):                       #判断该路径是否为文件        
             #以下为对每个文件预处理，获得预处理结果cutResult
            afile = open(fileUrl,'r')
            readyDoc = "".join(afile.readlines())
            if not WordToDel:                     #如果WordToDel为空                
                document = ReplaceWord(readyDoc,"","\t","\n"," ") 
                #删除某些特殊字符，如\t,\n以保证成为一行                
            else:
                document = ReplaceWord(readyDoc,'',*WordToDel)
            unicodeDoc = beDecode(document,*InTypeList)           
            cutResult = fullcut(unicodeDoc) 
            #以下为对每个文件进行处理，获得处理结果lastResult    
            fileName = beEecode(files, *OutTypeList)
            openResult.write(fileName + '\t')
            
            keyWords = []
            for everyWord in cutResult:
                everyWord = beEecode(everyWord,*OutTypeList)
                keyWords.append(everyWord)           
            lastResult = ','.join(keyWords)            
            #将结果写入输出文件中
            openResult.write(lastResult)
            openResult.write('\n')

# part4
# 计算TF-IDF值

def toTFIDF(fileFrom):    #fileFrom就是待处理文档的文件名字，也就是toGroupFile（）函数处理的结果
    oneFileInfo = {}     
    allFileInfo = {}      
    TFIDFInfo = []
    fileNum = 0
    
    #以下主要计算三个信息，oneFileInfo、allFileInfo、fileNum  
    fileUrl = fileFrom.replace('\\', '/')            
    openFile = open(fileUrl, 'r')
    data = openFile.readline()  #每次读一行就是一个完整的文档        
    while (data != ""):   
        wordInfo = {}           #记录每个文档中出现的词，不重复统计
        wordInfo.clear()
        
        DataStep1 = data.strip("\n").split("\t")  
        fileName = DataStep1[0]
        DataStep2 = DataStep1[1].split(",")          
        fileLen = len(DataStep2)
        fileNum += 1
        
        for word in DataStep2:
            if word not in allFileInfo:
                allFileInfo[word] = 1
                wordInfo[word] = 1
            else:
                if word not in wordInfo:  # 如果这个单词在这个文件中之前没有出现过
                    allFileInfo[word] += 1
                    wordInfo[word] = 1
            if not oneFileInfo.has_key(fileName):
                oneFileInfo[fileName] = {}
            if not oneFileInfo[fileName].has_key(word):
                oneFileInfo[fileName][word] = []
                oneFileInfo[fileName][word].append(DataStep2.count(word))
                oneFileInfo[fileName][word].append(fileLen)
        data = openFile.readline()
    openFile.close()
    
    #以下计算TFIDF值
    if (oneFileInfo) and (allFileInfo) and (fileNum != 0):
        for filenames in oneFileInfo.keys():
            TFIDFstep1 = {}
            TFIDFstep1.clear()
            for word in oneFileInfo[filenames].keys():
                wordNum = oneFileInfo[filenames][word][0]
                wordSum = oneFileInfo[filenames][word][1]
                filesNumOfWord = allFileInfo[word]
                TFIDFstep1[word] = ((wordNum / wordSum)) * (math.log10(fileNum / filesNumOfWord))
            
            # 将结果添加到TFIDFInfo
            TFIDFstep2 = sorted(TFIDFstep1.iteritems(), key=lambda x: x[1], reverse=True)  #按TF-IDF值降序排列
            TFIDFInfo.append(filenames)         #首先把文件名加入
            TFIDFInfo.extend(TFIDFstep2[0:10])  #这里每个文档只记录了top10的数据
            TFIDFInfo.append('\n')

    #将最终结果写入results.txt中
    f = open("results.txt", "a+")
    for infos in TFIDFInfo:
        for i in infos:
            f.write(str(i))
        f.write("\n")
    f.close()