朴素贝叶斯进行--垃圾邮件分类、新闻分类、个人广告获取区域倾向的解读

import numpy as np
import re
def spamTest():
    docList = []; classList = []; fullText = []
    #遍历25个txt文件
    for i in range(1, 26):
        #读取每个垃圾邮件，大字符串转换成字符列表。
        wordList = textParse(open('email/spam/%d.txt' % i, encoding="ISO-8859-1").read())
        docList.append(wordList)#不展开列表
        fullText.extend(wordList)#展开列表
        #标记垃圾邮件，1表示垃圾邮件
        classList.append(1)
        #读取每个非垃圾邮件，字符串转换为字符列表
        wordList = textParse(open('email/ham/%d.txt' % i, encoding="ISO-8859-1").read())
        docList.append(wordList)
        fullText.extend(wordList)
        #标记每个非垃圾邮件，0表示非垃圾邮件
        classList.append(0)
    #创建词汇表，不重复
    vocabList = createVocabList(docList)
    #创建存储训练集的索引值的列表
    trainingSet =list(range(50)); 
    #创建存储测试集的索引值的列表
    testSet= [] 
    #从50个邮件中，随机挑选出40个作为训练集，10个作为测试集
    for i in range(10):
        #随机选取索引值
        randIndex = int(np.random.uniform(0, len(trainingSet)))
        #添加测试集的索引值
        testSet.append(trainingSet[randIndex])
        #在训练集的列表中删除添加到测试集的索引值
        del(list(trainingSet)[randIndex])
    #创建训练集矩阵和训练集类别标签向量
    trainMat = []; 
    trainClasses = []
    #遍历训练集，目前只有40个训练集
    for docIndex in trainingSet:
        #将生成的词集模型添加到训练矩阵中
        trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))
        #将类别标签添加到训练集的类别标签向量中
        trainClasses.append(classList[docIndex])
    """
    训练朴素贝叶斯模型
    """
    #训练朴素贝叶斯模型
    p0V, p1V, pSpam = trainNB(np.array(trainMat), np.array(trainClasses))
    #错误分类计数
    errorCount = 0
    #遍历测试集
    for docIndex in testSet:    
        #测试集的词集模型
        wordVector = setOfWords2Vec(vocabList, docList[docIndex])
        if classifyNB(np.array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
            errorCount += 1
            print("classification error", docList[docIndex])
    print('the error rate is: ', float(errorCount)/len(testSet))
#将一个大字符串解析为字符列表
def textParse(bigString):    
    import re
    listOfTokens = re.split(r'\W+', bigString)
    return [tok.lower() for tok in listOfTokens if len(tok) > 2] #找出长度大于两个字母的单词
#定义创建不重复的列表函数
"""
createVocabList()函数会创建一个包含在所有文档中出现的不重复词的列表
"""
def createVocabList(dataSet):
    #创建一个空集
    vocabSet = set([])  
    for document in dataSet:
        #再创建一个空集后，将每篇文档返回的新词集合添加到该集合中，再求两个集合的并集
        vocabSet = vocabSet | set(document) 
    return list(vocabSet)
#定义词集模型函数（set-of-words）
def setOfWords2Vec(vocabList, inputSet):
    #函数首先创建一个和词汇表等长的向量，并将其元素都设置为0
    returnVec = [0]*len(vocabList)
    #接着，遍历文档中的所有单词，如果出现了词汇表中的单词，则将输出的文档向量中的对应值设为1。
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] = 1
        else:
            print("the word: %s is not in my Vocabulary!" % word)
    return returnVec   
#定义词袋模型
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec
#定义朴素贝叶斯分类器训练函数
"""
函数说明:朴素贝叶斯分类器训练函数
trainMatrix--训练文档矩阵，即setOfWords2Vec返回的returnVec构成的矩阵；trainCategory--训练类别标签向量
p1Vect--标记为1的类条件概率数组；p0Vect--标记为0的类条件概率数组；pAbusive是标记为1类的先验概率
"""
def trainNB(trainMatrix, trainCategory):
    #计算训练的文档数目
    numTrainDocs = len(trainMatrix)
    #计算每篇文档的词条数 相当于特征数
    numWords = len(trainMatrix[0])
    #标记为1类的先验概率
    pAbusive = sum(trainCategory)/float(numTrainDocs)
    """
    创建numpy数组初始化为1，拉普拉斯平滑。
    创建numpy.zeros数组,词条出现数初始化为0。分母初始化为2
    """
    p0Num = np.ones(numWords); p1Num = np.ones(numWords)      
    p0Denom = 2.0; p1Denom = 2.0  
    #计算类条件概率
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:
            p1Num += trainMatrix[i]#矩阵相加
            p1Denom += 1#表示类1文档个数
           # p1Denom += sum(trainMatrix[i])#有误
        else:
            p0Num += trainMatrix[i]
            p0Denom += 1#表示类0文档个数
            #p0Denom += sum(trainMatrix[i])#有误
    #由于大部分因子都非常小，防止数值下溢得不到正确答案。于是加log计算，可以使得答案不会过小。
    p1Vect = np.log(p1Num/p1Denom)          #change to np.log() 类1 为1 的条件概率
    p0Vect = np.log(p0Num/p0Denom)          #change to np.log() 类0 为0 的条件概率  和后面的计算有一些联系
    return p0Vect, p1Vect, pAbusive   

#函数说明:朴素贝叶斯分类器分类函数
#vec2Classify--待分类的词条数组; p1Vec--标记为类1的类条件概率数组; p0Vec--标记为类0的类条件概率数组; pClass1--标记为1类的先验概率
"""
博客
https://blog.csdn.net/qq_27009517/article/details/80044431
https://blog.csdn.net/lming_08/article/details/37542331
"""
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    """
    1.计算待分类词条数组为1类的概率
    """
    #寻找vec2Classify测试数组中，元素为0时对应的索引值
    index = np.where(vec2Classify==0)#返回一串索引值，相等为true 否则为false 只返回false索引
    #遍历元素为0时的索引值，并从p1Vec--1类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p1Vec0=[]）
    p1Vec0=[]
    for i in index:#index为tuple 取i=0 的tuple 只执行一次
        for m in i:
            p1Vec0.append(p1Vec[m])
    #所有P(vec2Classify=0|1)组成的列表
        x0=np.ones(len(p1Vec0))-p1Vec0##？和训练过程得到的p1Vec有关，p1Vec它表示类1下为1的条件概率
    #寻找vec2Classify测试数组中，元素为1时对应的索引值
    index1= np.where(vec2Classify==1)
    #遍历元素为1时的索引值，并从p1Vec--1类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p1Vec1=[]）
    p1Vec1=[]
    for i in index1:
        for m in i:
            p1Vec1.append(p1Vec[m])
    #所有P(vec2Classify=1|1)组成的列表
    x1=p1Vec1      
    ##对应元素相乘。logA * B = logA + logB，所以这里加上log(pClass1)
    p1 = sum(x0)+sum(x1) +  np.log(pClass1)        
    """
    2.计算待分类词条数组为0类的概率
    """
    #寻找vec2Classify测试数组中，元素为0时对应的索引值
    index2 = np.where(vec2Classify==0)
    #遍历元素为0时的索引值，并从p0Vec--0类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p0Vec0=[]）
    p0Vec0=[]
    for i in index2:
        for m in i:
            p0Vec0.append(p0Vec[m])
    #所有P(vec2Classify=0|0)组成的列表
    w0=np.ones(len(p0Vec0))-p0Vec0
    #寻找vec2Classify测试数组中，元素为1时对应的索引值
    index3= np.where(vec2Classify==1)
    #遍历元素为1时的索引值，并从p0Vec--0类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p0Vec1=[]）
    p0Vec1=[]
    for i in index3:
        for m in i:
            p0Vec1.append(p0Vec[m])
    #所有P(vec2Classify=1|0)组成的列表
    w1=p0Vec1
    ##对应元素相乘。logA * B = logA + logB，所以这里加上log(pClass1)
    p0 = sum(w0)+sum(w1) +  np.log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else:
        return 0

# -*- coding: UTF-8 -*-
from sklearn.naive_bayes import MultinomialNB
import matplotlib.pyplot as plt
import os
import random
import jieba
"""
函数说明:中文文本处理
Parameters:
  folder_path - 文本存放的路径
  test_size - 测试集占比，默认占所有数据集的百分之20
Returns:
  all_words_list - 按词频降序排序的训练集列表
  train_data_list - 训练集列表
  test_data_list - 测试集列表
  train_class_list - 训练集标签列表
  test_class_list - 测试集标签列表
Author:
  Jack Cui
Blog:
  http://blog.csdn.net/c406495762
Modify:
  2017-08-22
"""
def TextProcessing(folder_path, test_size = 0.2):
  folder_list = os.listdir(folder_path)           #查看folder_path下的文件
  data_list = []                        #数据集数据
  class_list = []                       #数据集类别
  #遍历每个子文件夹
  for folder in folder_list:
    new_folder_path = os.path.join(folder_path, folder)   #根据子文件夹，生成新的路径
    files = os.listdir(new_folder_path)           #存放子文件夹下的txt文件的列表
    j = 1
    #遍历每个txt文件
    for file in files:
      if j > 100:                     #每类txt样本数最多100个
        break
      with open(os.path.join(new_folder_path, file), 'r', encoding = 'utf-8') as f: #打开txt文件
        raw = f.read()
      word_cut = jieba.cut(raw, cut_all = False)      #精简模式，返回一个可迭代的generator
      word_list = list(word_cut)              #generator转换为list
      data_list.append(word_list)             #添加数据集数据#  不展开
      class_list.append(folder)             #添加数据集类别
      j += 1
    print(data_list)
    print(class_list)
  data_class_list = list(zip(data_list, class_list))      #zip压缩合并，将数据与标签对应压缩 打包成元组 利用 * 号操作符，可以将元组解压为列表
  #https://www.runoob.com/python/python-func-zip.html
  random.shuffle(data_class_list)               #将data_class_list乱序
  index = int(len(data_class_list) * test_size) + 1     #训练集和测试集切分的索引值
  train_list = data_class_list[index:]            #训练集
  test_list = data_class_list[:index]             #测试集
  train_data_list, train_class_list = zip(*train_list)    #训练集解压缩
  test_data_list, test_class_list = zip(*test_list)     #测试集解压缩
  all_words_dict = {}                     #统计训练集词频
  for word_list in train_data_list:
    for word in word_list:#不重复的统计词频
      if word in all_words_dict.keys():
        all_words_dict[word] += 1
      else:
        all_words_dict[word] = 1
  #根据键的值倒序排序
  all_words_tuple_list = sorted(all_words_dict.items(), key = lambda f:f[1], reverse = True)#True 降序 False 升序
  all_words_list, all_words_nums = zip(*all_words_tuple_list) #解压缩
  all_words_list = list(all_words_list)           #转换成列表
  return all_words_list, train_data_list, test_data_list, train_class_list, test_class_list
  #文本预处理
folder_path = './SogouC/Sample'                #训练集存放地址
TextProcessing(folder_path)
"""
函数说明:读取文件里的内容，并去重
Parameters:
  words_file - 文件路径
Returns:
  words_set - 读取的内容的set集合
Author:
  Jack Cui
Blog:
  http://blog.csdn.net/c406495762
Modify:
  2017-08-22
"""
def MakeWordsSet(words_file):
  words_set = set()                     #创建set集合
  with open(words_file, 'r', encoding = 'utf-8') as f:    #打开文件
    for line in f.readlines():                #一行一行读取
      word = line.strip()                 #去回车
      if len(word) > 0:                 #有文本，则添加到words_set中
        words_set.add(word)               
  return words_set                      #返回处理结果
"""
函数说明:根据feature_words将文本向量化
Parameters:
  train_data_list - 训练集tuple
  test_data_list - 测试集
  feature_words - 特征集
Returns:
  train_feature_list - 训练集向量化列表
  test_feature_list - 测试集向量化列表
Author:
  Jack Cui
Blog:
  http://blog.csdn.net/c406495762
Modify:
  2017-08-22
"""
def TextFeatures(train_data_list, test_data_list, feature_words):
  def text_features(text, feature_words):           #出现在特征集中，则置1                        
    text_words = set(text)
    features = [1 if word in text_words else 0 for word in feature_words]
    return features
  train_feature_list = [text_features(text, feature_words) for text in train_data_list]
  test_feature_list = [text_features(text, feature_words) for text in test_data_list]
  return train_feature_list, test_feature_list        #返回结果
"""
函数说明:文本特征选取
Parameters:
  all_words_list - 训练集所有文本列表
  deleteN - 删除词频最高的deleteN个词
  stopwords_set - 指定的结束语
Returns:
  feature_words - 特征集
Author:
  Jack Cui
Blog:
  http://blog.csdn.net/c406495762
Modify:
  2017-08-22
"""
def words_dict(all_words_list, deleteN, stopwords_set = set()):
  feature_words = []              #特征列表
  n = 1
  for t in range(deleteN, len(all_words_list), 1):
    if n > 1000:              #feature_words的维度为1000
      break               
    #如果这个词不是数字，并且不是指定的结束语，并且单词长度大于1小于5，那么这个词就可以作为特征词
    if not all_words_list[t].isdigit() and all_words_list[t] not in stopwords_set and 1 < len(all_words_list[t]) < 5:
      feature_words.append(all_words_list[t])
    n += 1
  return feature_words
"""
函数说明:新闻分类器
Parameters:
  train_feature_list - 训练集向量化的特征文本
  test_feature_list - 测试集向量化的特征文本
  train_class_list - 训练集分类标签
  test_class_list - 测试集分类标签
Returns:
  test_accuracy - 分类器精度
Author:
  Jack Cui
Blog:
  http://blog.csdn.net/c406495762
Modify:
  2017-08-22
"""
def TextClassifier(train_feature_list, test_feature_list, train_class_list, test_class_list):
  classifier = MultinomialNB().fit(train_feature_list, train_class_list)
  test_accuracy = classifier.score(test_feature_list, test_class_list)
  return test_accuracy
if __name__ == '__main__':
  #文本预处理
  folder_path = './SogouC/Sample'       #训练集存放地址
  all_words_list, train_data_list, test_data_list, train_class_list, test_class_list = TextProcessing(folder_path, test_size=0.2)
  # 生成stopwords_set 目的是去除一些数字  一些特点的词语
  stopwords_file = './stopwords_cn.txt'
  stopwords_set = MakeWordsSet(stopwords_file)
  test_accuracy_list = []
  deleteNs = range(0, 1000, 20)       #0 20 40 60 ... 980
  for deleteN in deleteNs:
    feature_words = words_dict(all_words_list, deleteN, stopwords_set)#词向量列表
    train_feature_list, test_feature_list = TextFeatures(train_data_list, test_data_list, feature_words)
    test_accuracy = TextClassifier(train_feature_list, test_feature_list, train_class_list, test_class_list)
    test_accuracy_list.append(test_accuracy)
  # ave = lambda c: sum(c) / len(c)
  # print(ave(test_accuracy_list))
  plt.figure()
  plt.plot(deleteNs, test_accuracy_list)
  plt.title('Relationship of deleteNs and test_accuracy')
  plt.xlabel('deleteNs')
  plt.ylabel('test_accuracy')
  plt.show()

from numpy import *
import numpy as np
import bayes as ba
#从RSS源获取文档数据 计算分类的错误率    
testRSS()

def testRSS():
    import feedparser
    ny=feedparser.parse('http://www.nasa.gov/rss/dyn/image_of_the_day.rss')#NASA
    sf=feedparser.parse('http://sports.yahoo.com/nba/teams/hou/rss.xml')#Yahoo
    vocabList,pSF,pNY = localWords(ny,sf)

"""
函数说明:根据RSS源进行文档的解析---转换为剔除停用后的不重复词列表--转换为词向量---划分数据集---训练获得先验概率、条件概率和词列表 --测试计算分类错误率
Parameters:
    feed1 - RSS源1
    feed0 - RSS源2
Returns:
    vocabList -不重复的词列表(去掉停用词) 
    p0V - 类0的条件概率
    p1V - 类1的条件概率
Author:
    heda3
Blog:
    https://blog.csdn.net/heda3
Modify:
    2019-09-30
"""
def localWords(feed1,feed0):
    import feedparser
    #引入RSS源，并提取相应的词汇-转换为词列表
    docList=[]; classList = []; fullText =[]
    print('feed1 entries length: ', len(feed1['entries']), '\nfeed0 entries length: ', len(feed0['entries']))
    minLen = min(len(feed1['entries']),len(feed0['entries']))
    print('\nmin Length: ', minLen)
    for i in range(minLen):
        wordList = textParse(feed1['entries'][i]['summary'])#英文分词
        print('\nfeed1\'s entries[',i,']\'s summary - ','parse text:\n',wordList)
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1) #NY is class 1
        wordList = textParse(feed0['entries'][i]['summary'])
        print('\nfeed0\'s entries[',i,']\'s summary - ','parse text:\n',wordList)
        docList.append(wordList)
        fullText.extend(wordList)#展开
        classList.append(0)
    #创建不重复词的列表
    vocabList = createVocabList(docList)#create vocabulary
    print('\nVocabList is ',vocabList)
    #调用停词列表，移除不重复词列表中包含停词列表中的元素
    print('\nRemove Stop Word:')
    stopWordList = stopWords()
    for stopWord in stopWordList:
        if stopWord in vocabList:
            vocabList.remove(stopWord)#去掉停止词后的词列表
            print('Removed: ',stopWord)
    #计算最高频次的词--从不重复的词列表中删除掉高频词 这个和前面的停用词表的重复了
    #vocabList:不重复的词向量 fullText：所有的词展开
    top30Words =  ba.calcMostFreq(vocabList,fullText)   #remove top 30 words
    print('\nTop 30 words: ', top30Words)
    for pairW in top30Words:
        if pairW[0] in vocabList:
            vocabList.remove(pairW[0])
            print('\nRemoved: ',pairW[0])
    #训练集和测试集划分 并将输入词列表转换为词向量
    trainingSet =list(range(2*minLen));#在python3中range返回的是一个range对象，故转换为列表形式
    testSet=[]           #create test set
    print('\n\nBegin to create a test set: \ntrainingSet:',trainingSet,'\ntestSet',testSet)
    for i in range(5):
        randIndex = int(random.uniform(0,len(trainingSet)))#随机选取在0-n之间的实数
        #从trainingSet中随机找出索引值，并将它放置在测试集里，同时删除测试集的值
        testSet.append(trainingSet[randIndex])
        del(trainingSet[randIndex])
    print('random select 5 sets as the testSet:\ntrainingSet:',trainingSet,'\ntestSet',testSet)
    trainMat=[]; trainClasses = []
    for docIndex in trainingSet:#train the classifier (get probs) trainNB0
        #词列表转换为词向量
        trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])
    print('\ntrainMat length:',len(trainMat))
    print('\ntrainClasses',trainClasses)
    print('\n\ntrainNB0:')
    #模型训练
    p0V,p1V,pSpam = trainNB0(array(trainMat),array(trainClasses))
    #print '\np0V:',p0V,'\np1V',p1V,'\npSpam',pSpam
    ##返回 条件概率p0V  p1V，以及标记为1类的先验概率
    #模型测试
    errorCount = 0
    for docIndex in testSet:        #classify the remaining items
        #词列表转换为词向量
        wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
        classifiedClass = classifyNB(array(wordVector),p0V,p1V,pSpam)
        originalClass = classList[docIndex]
        result =  classifiedClass != originalClass
        if result:
            errorCount += 1
        print('\n',docList[docIndex],'\nis classified as: ',classifiedClass,', while the original class is: ',originalClass,'. --',not result)
    print('\nthe error rate is: ',float(errorCount)/len(testSet))
    return vocabList,p0V,p1V

def createVocabList(dataSet):
    vocabSet = set([])  #create empty set
    for document in dataSet:
        vocabSet = vocabSet | set(document) #union of the two sets
    return list(vocabSet)
def bagOfWords2Vec(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
        else: print("the word: %s is not in my Vocabulary!" % word)
    return returnVec
"""
函数说明:词袋模型，依据输入文档是否在词列表中，相应的值累加次数
Parameters:
    vocabList - 所有的词列表（所有文档的并集）
    inputSet -  输入文档（词列表）
Returns:
    returnVec - 输入文档对应的词向量（词频）
Author:
    heda3
Blog:
    https://blog.csdn.net/heda3
Modify:
    2019-10-01
"""    
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

#定义朴素贝叶斯分类器训练函数
"""
函数说明:朴素贝叶斯分类器训练函数
trainMatrix--训练文档矩阵，即setOfWords2Vec返回的returnVec构成的矩阵；trainCategory--训练类别标签向量
p1Vect--标记为1的类条件概率数组；p0Vect--标记为0的类条件概率数组；pAbusive是标记为1类的先验概率
"""
def trainNB(trainMatrix, trainCategory):
    #计算训练的文档数目
    numTrainDocs = len(trainMatrix)
    #计算每篇文档的词条数 相当于特征数
    numWords = len(trainMatrix[0])
    #标记为1类的先验概率
    pAbusive = sum(trainCategory)/float(numTrainDocs)
    """
    创建numpy数组初始化为1，拉普拉斯平滑。
    创建numpy.zeros数组,词条出现数初始化为0。分母初始化为2
    """
    p0Num = np.ones(numWords); p1Num = np.ones(numWords)      
    p0Denom = 2.0; p1Denom = 2.0  
    #计算类条件概率
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:
            p1Num += trainMatrix[i]#矩阵相加
            p1Denom += 1#表示类1文档个数
           # p1Denom += sum(trainMatrix[i])#有误
        else:
            p0Num += trainMatrix[i]
            p0Denom += 1#表示类0文档个数
            #p0Denom += sum(trainMatrix[i])#有误
    #由于大部分因子都非常小，防止数值下溢得不到正确答案。于是加log计算，可以使得答案不会过小。
    p1Vect = np.log(p1Num/p1Denom)          #change to np.log() 类1 为1 的条件概率
    p0Vect = np.log(p0Num/p0Denom)          #change to np.log() 类0 为0 的条件概率  和后面的计算有一些联系
    return p0Vect, p1Vect, pAbusive  

"""
函数说明:朴素贝叶斯分类器预测函数
Parameters:
    vec2Classify - 待分类词向量
    p0Vec -  类0的条件概率
    p1Vec -  类1的条件概率
    pClass1 -  先验概率）
Returns:
    returnVec - 输入文档对应的词向量（词频）
Author:
    heda3
""" #有误
# =============================================================================
# def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
#     p1 = sum(vec2Classify * p1Vec) + log(pClass1)    #element-wise mult
#     p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
#     if p1 > p0:
#         return 1
#     else: 
#         return 0
# =============================================================================
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    """
    1.计算待分类词条数组为1类的概率
    """
    #寻找vec2Classify测试数组中，元素为0时对应的索引值
    index = np.where(vec2Classify==0)#返回一串索引值，相等为true 否则为false 只返回false索引
    #遍历元素为0时的索引值，并从p1Vec--1类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p1Vec0=[]）
    p1Vec0=[]
    for i in index:#index为tuple 取i=0 的tuple 只执行一次
        for m in i:
            p1Vec0.append(p1Vec[m])
    #所有P(vec2Classify=0|1)组成的列表
        x0=np.ones(len(p1Vec0))-p1Vec0##？和训练过程得到的p1Vec有关，p1Vec它表示类1下为1的条件概率
    #寻找vec2Classify测试数组中，元素为1时对应的索引值
    index1= np.where(vec2Classify==1)
    #遍历元素为1时的索引值，并从p1Vec--1类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p1Vec1=[]）
    p1Vec1=[]
    for i in index1:
        for m in i:
            p1Vec1.append(p1Vec[m])
    #所有P(vec2Classify=1|1)组成的列表
    x1=p1Vec1      
    ##对应元素相乘。logA * B = logA + logB，所以这里加上log(pClass1)
    p1 = sum(x0)+sum(x1) +  np.log(pClass1)        
    """
    2.计算待分类词条数组为0类的概率
    """
    #寻找vec2Classify测试数组中，元素为0时对应的索引值
    index2 = np.where(vec2Classify==0)
    #遍历元素为0时的索引值，并从p0Vec--0类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p0Vec0=[]）
    p0Vec0=[]
    for i in index2:
        for m in i:
            p0Vec0.append(p0Vec[m])
    #所有P(vec2Classify=0|0)组成的列表
    w0=np.ones(len(p0Vec0))-p0Vec0
    #寻找vec2Classify测试数组中，元素为1时对应的索引值
    index3= np.where(vec2Classify==1)
    #遍历元素为1时的索引值，并从p0Vec--0类的条件概率数组中取出对应索引的数值，并存储成列表的形式（p0Vec1=[]）
    p0Vec1=[]
    for i in index3:
        for m in i:
            p0Vec1.append(p0Vec[m])
    #所有P(vec2Classify=1|0)组成的列表
    w1=p0Vec1
    ##对应元素相乘。logA * B = logA + logB，所以这里加上log(pClass1)
    p0 = sum(w0)+sum(w1) +  np.log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else:
        return 0

def getTopWords(ny,sf):
    import operator
    #获取训练数据的条件概率 和精选的词列表
    vocabList,p0V,p1V=localWords(ny,sf)
    topNY=[]; topSF=[]
    #返回大于某个阈值（注意概率是取对数后的）的词
    for i in range(len(p0V)):
        if p0V[i] > -6.0 : topSF.append((vocabList[i],p0V[i]))#获得词以及对应的先验概率（类为0，此词出现的概率）
        if p1V[i] > -6.0 : topNY.append((vocabList[i],p1V[i]))
    #输出类0下先验概率超过某个阈值的词
    sortedSF = sorted(topSF, key=lambda pair: pair[1], reverse=True)
    print("SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**")
    for item in sortedSF:
        print(item[0])
    #输出类1下先验概率超过某个阈值的词
    sortedNY = sorted(topNY, key=lambda pair: pair[1], reverse=True)
    print("NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**")
    for item in sortedNY:
        print(item[0])