devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于Python的简易文本分析程序_python文本分析代码实现

作者：我家自动化 | 2024-07-13 12:10:51

赞

踩

python文本分析代码实现
"""
项目介绍

情景假设：一位考生根据题目要求写出了一份作文，考生略做修改后提交第二份文档，
        考生将题目、两份作文输入程序后得到一份评分报告。评分报告给出以百分数为形式的数据为考生提供修改建议。
         
实现功能：该项目主要关注以下几点：主题契合度、词汇高级度、查重率与体检报告。
        考生输入文本后，评分报告以pyGUI的形式呈现给用户，显示各类指标、图表和建议。
"""

  1. from tkinter import *
  2. from tkinter import scrolledtext
  3. import nltk
  4. from sklearn.feature_extraction.text import TfidfVectorizer
  5. from tkinter import *
  6. from tkinter import scrolledtext
  7. import nltk
  8. from sklearn.feature_extraction.text import TfidfVectorizer
  9. import matplotlib
  10. matplotlib.use("TkAgg")
  11. import re
  12. import hashlib
  13. import pandas as pds
  14. import numpy as np
  15. import string
  16. import matplotlib.pyplot as plt
  17. import matplotlib.font_manager as fm
  18. import os
  19. import matplotlib.pyplot as plt
  20. import re
  21. import hashlib
  22. import pandas as pds
  23. import numpy as np
  24. import string
  25. import matplotlib.pyplot as plt
  26. import matplotlib.font_manager as fm
  27. import time
  28.  
  29.  
  30.  
  31. """
  32. 项目介绍
  34. 情景假设：一位考生根据题目要求写出了一份作文，考生略做修改后提交第二份文档，
  35.         考生将题目、两份作文输入程序后得到一份评分报告。评分报告给出以百分数为形式的数据为考生提供修改建议。
  36.          
  37. 实现功能：该项目主要关注以下几点：主题契合度、词汇高级度、查重率与体检报告。
  38.         考生输入文本后，评分报告以pyGUI的形式呈现给用户，显示各类指标、图表和建议。
  39. """
  40.  
  41.  
  42.  
  43.  
  44.  
  45. # 数据库输入
  46. word_storage = pds.read_excel('词库.xlsx')
  47. """
  48. 从不同词库中提取单词
  49. 词库有四个，分别为：初中词汇，高中词汇，四六级词汇，托福词
  50. """
  51.  
  52.  
  53. """
  54. TF-IDF计算词频以体现主题契合度，徐铭阳提供
  55. """
  56. def TF_IDF():
  57.     # 函数封装:对词频进行统计
  58.     def word_tfidf_calculating(the_address_of_text):
  59.         # 读取文本
  60.         with open(the_address_of_text) as f:
  61.             text=f.read()
  62.  
  63.         # 提取关键词
  64.         tfidf=TfidfVectorizer(stop_words='english', tokenizer=None)
  65.         tfs=tfidf.fit_transform([text])
  66.  
  67.         # 获取关键词和对应的得分
  68.         feature_names=tfidf.get_feature_names_out()
  69.         scores=tfs.todense().tolist()[0]
  70.  
  71.         # 将关键词和对应的得分组成元组，然后根据得分进行排序
  72.         # 将关键词和对应的得分组成元组，然后根据得分进行排序
  73.         keywords_in_list=sorted(zip(feature_names, scores), key=lambda x: x[1], reverse=True)
  74.         keywords_in_dic=dict(keywords_in_list)
  75.  
  76.         return keywords_in_list
  77.  
  78.     # 调用TF-IDF函数，实现对题目、文本对词频统计
  79.     keyword_topic=word_tfidf_calculating("topic.txt")
  80.     keyword_text1=word_tfidf_calculating("text1.txt")
  81.     keyword_text2=word_tfidf_calculating("text2.txt")
  82.  
  83.  
  84.     # keyword_topic为一个字典，其键为关键词，值为得分，找出得分前十的关键词，以字典形式输出
  85.     # 函数封装：输出得分前十的关键词，以字典形式输出  # 函数封装：输出得分前十的关键词，以字典形式输出
  86.     def the_top_word_output(which_text):
  87.         the_top_word={}
  88.         for item in which_text[:10]:
  89.             the_top_word[item[0]]=item[1]
  90.         return the_top_word
  91.  
  92.     top_word_topic = the_top_word_output(keyword_topic)
  93.     top_word_text1 = the_top_word_output(keyword_text1)
  94.     top_word_topi2 = the_top_word_output(keyword_text2)
  95.  
  96.  
  97.  
  98.     # 函数封装： 关键词词频得分计算
  99.     def the_total_score_of_keyword(which_text):
  100.         set1=set([item[0] for item in keyword_topic])
  101.         set2=set(item[0] for item in which_text)
  102.         keyword_common_elements=list(set1.intersection(set2))
  103.  
  104.         # 函数封装：从列表中抓取元素
  105.         def extract_element1_in_list(the_list, element0):
  106.             global element1
  107.             for item in the_list:
  108.                 if item[0] == element0:
  109.                     element1=item[1]
  110.             return element1
  111.  
  112.         # 利用自定义数学公式计算得分
  113.         the_total_score_of_keyword_in_circle=0
  114.         for marks_of_keys in keyword_common_elements:
  115.             the_total_score_of_keyword_in_circle+=extract_element1_in_list(keyword_topic, marks_of_keys) \
  116.                                                   * extract_element1_in_list(which_text, marks_of_keys)
  117.         return the_total_score_of_keyword_in_circle
  118.  
  119.     # 调用函数：求得text1与text2的得分
  120.  
  121.     score_of_text1=the_total_score_of_keyword(keyword_text1)
  122.     score_of_text2=the_total_score_of_keyword(keyword_text2)
  123.  
  124.     # 得出关键词词频结论
  125.     the_ratio_after_modified=1 - score_of_text2 / score_of_text1
  126.     print("您的文章修改后，关键词复现词频得分提高了{:%}".format(the_ratio_after_modified))
  127.     return [top_word_topic, top_word_text1, top_word_topi2]
  128.  
  129. x = TF_IDF()
  130.  
  131.  
  132. """
  133. SimHash—Hamming算法比较文本相似度，以计算查重率，徐铭阳提供
  134. """
  135. def CALC_repetition(text1_address, text2_address):
  136.     def CALC_SimHash_Hamming(text1_address1, text2_address1):  # 徐铭阳提供
  137.         """
  138.         计算出两个文本的哈希值，返回汉明距离
  139.         """
  140.         global distance_between_texts
  141.         with open(text1_address, 'r') as f:
  142.             text_topic=f.read()
  143.         with open(text2_address, 'r') as f:
  144.             text1=f.read()
  145.  
  146.         class Simhash:
  147.             def __init__(self, text, hashbits=64):
  148.                 self.hashbits=hashbits
  149.                 self.hash=self.simhash(text)
  150.  
  151.             def __str__(self):
  152.                 return str(self.hash)
  153.  
  154.             def simhash(self, tokens):
  155.                 # 初始化一个64位的列表，用于存储特征哈希值
  156.                 v=[0] * self.hashbits
  157.                 # 遍历每一个单词
  158.                 for t in [self._string_hash(x) for x in tokens]:
  159.                     # 对每一个哈希值的每一个位进行更新
  160.                     for i in range(self.hashbits):
  161.                         bitmask=1 << i
  162.                         if t & bitmask:
  163.                             v[i]+=1  # 如果该位为1，则该位的计数器加1
  164.                         else:
  165.                             v[i]-=1  # 如果该位为0，则该位的计数器减1
  166.                 fingerprint=0
  167.                 for i in range(self.hashbits):
  168.                     if v[i] >= 0:
  169.                         fingerprint|=1 << i  # 如果计数器大于等于0，则该位设为1
  170.                 return fingerprint
  171.  
  172.             def _string_hash(self, v):
  173.                 # 将字符串进行hash，产生一个64位的整数
  174.                 return int(hashlib.md5(v.encode('utf-8')).hexdigest(), 16)
  175.  
  176.             def hamming_distance(self, other):
  177.                 # 计算两个整数二进制表示的汉明距离
  178.                 x=(self.hash ^ other.hash) & ((1 << self.hashbits) - 1)
  179.                 d=0
  180.                 while x:
  181.                     d+=1
  182.                     x&=x - 1
  183.                 return d
  184.  
  185.         def get_words(text):
  186.             # 按照空格进行分词，同时过滤掉长度小于等于1的词语
  187.             words=re.compile('\w+').findall(text.lower())
  188.             return [w for w in words if len(w) > 1]
  189.  
  190.         def get_stopwords():
  191.             # 获取停用词表
  192.             stop_words=set()
  193.             with open("停用词.txt", "r", encoding="utf-8") as f:
  194.                 for line in f:
  195.                     stop_words.add(line.strip())
  196.             return stop_words
  197.  
  198.         if __name__ == '__main__':
  199.             text_a=text_topic
  200.             text_b=text1
  201.  
  202.             words1=get_words(text_a)
  203.             words2=get_words(text_b)
  204.  
  205.             stopwords=get_stopwords()
  206.             words1=[w for w in words1 if w not in stopwords]
  207.             words2=[w for w in words2 if w not in stopwords]
  208.  
  209.             sh1=Simhash(words1)
  210.             sh2=Simhash(words2)
  211.  
  212.             distance_between_texts=sh1.hamming_distance(sh2)
  213.         return distance_between_texts
  214.  
  215.     def text_split(text):
  216.         """
  217.         将文本按句子划分
  218.         """
  219.         with open(text, 'r') as f:
  220.             text_after_split=f.read()
  221.         sentences=text_after_split.split(". ")
  222.         sentences=[s.strip() for s in sentences]
  223.         return sentences
  224.  
  225.     def text_compared_based_on_sentences(list_sentence_of_text1,
  226.                                          list_sentence_of_text2):
  227.         """
  228.         以两个被分割的文本进行比较，返回相同的句子数目、总句子数所组成的列表
  229.         其中text1作为文本库，text2作为待查重的文本
  230.         返回「重复的句子的单词数,待查重的文本的单词数」
  231.         """
  232.  
  233.         def CALC_words_in_sentences(list1):
  234.             word_lst=' '.join(list1).split()
  235.             return len(word_lst)
  236.  
  237.         list1=text_split(list_sentence_of_text1)
  238.         list2=text_split(list_sentence_of_text2)
  239.         the_words_amount_of_list2=CALC_words_in_sentences(list2)
  240.  
  241.         amount_of_words_of_similar_sentence=0  # 双列表遍历后找哈希近似，统计重复的句子数和句子词数
  242.         for element1 in list1:
  243.             for element2 in list2:
  244.                 if CALC_SimHash_Hamming(element1, element2) <= 1000:
  245.                     the_words_amount_similar=CALC_words_in_sentences(element2)
  246.  
  247.                     amount_of_words_of_similar_sentence+=the_words_amount_similar
  248.  
  249.         info_text_compared_based_on_sentences=[amount_of_words_of_similar_sentence, the_words_amount_of_list2]
  250.  
  251.         return info_text_compared_based_on_sentences
  252.  
  253.     a=text_compared_based_on_sentences(text1_address, text2_address)
  254.  
  255.     def CALC_ratio(info_text_compared_based_on_sentences):
  256.         """
  257.         输入被计算后的文本比较信息，其格式为：「重复的句子的单词数,待查重的文本的单词数」
  258.         输出目标文本的重复比例
  259.         其中text1作为文本库，text2作为待查重的文本
  260.         """
  261.         the_amount_of_sentence_in_texts=int(info_text_compared_based_on_sentences[0])
  262.         the_amount_of_sentence_similar=int(info_text_compared_based_on_sentences[1])
  263.         the_ratio_of_repetition=the_amount_of_sentence_similar / the_amount_of_sentence_in_texts
  264.  
  265.         print(f"您这篇文章的重复率为：{the_ratio_of_repetition:.2%}")
  266.         return the_ratio_of_repetition
  267.  
  268.     b=CALC_ratio(a)
  269.     return b
  270.  
  271.  
  272.  
  273.  
  274. rating1_of_repetition = CALC_repetition("topic.txt",
  275.                 "text1.txt")
  276. rating2_of_repetition = CALC_repetition("topic.txt",
  277.                 "text2.txt")
  278.  
  279.  
  280. ratio_of_repetition = rating2_of_repetition/rating1_of_repetition
  281.  
  282.  
  283. """
  284. 高频词汇统计与评分
  285. """
  286. class Storage_level:  # 定义Storage_level类
  287.     def __init__(self, text):
  288.         import string
  289.         with open(text, 'r') as fp:  # 打开目标作文
  290.             self.text = fp.read()  # 读取作文并保存在self.text中
  291.             words = self.text.split()  # 读取作文单词，并保存在一个列表中
  292.             self.words = [word.lower().strip(string.punctuation + string.whitespace) for word in words]
  293.  
  294.     def word_level(self, excel, sheet):  # 定义word_level函数，对词库进行处理
  295.         read = pds.read_excel(excel, sheet_name=sheet)  # 读取词库，将单词储存在列表中
  296.         data = read.values.tolist()
  297.         words_set = set(tuple(i) for i in data)  # 将列表化为集合
  298.         words_level = {str(word[0]).replace(',', '') for word in words_set}
  299.         return words_level
  300.  
  301.     def word_storage(self, storage, junior, high, universe, toefl):  # 定义word_storage函数，将词库划分为四个等级
  302.         # 运用word_level函数处理词库
  303.         words_junior = self.word_level(storage, junior)
  304.         words_high = self.word_level(storage, high)
  305.         words_universe = self.word_level(storage, universe)
  306.         words_toefl = self.word_level(storage, toefl)
  307.         # 用集合的方法将词汇进行分类，共分为四个等级，等级越高，词汇越高级
  308.         word_level1 = words_junior - (words_high | words_universe | words_toefl)
  309.         word_level2 = words_high - words_junior - words_universe - words_toefl
  310.         word_level3 = words_universe - words_high - words_toefl - words_junior
  311.         word_level4 = words_toefl - words_junior - words_universe - words_high
  312.         return [word_level1, word_level2, word_level3, word_level4]
  313.  
  314.     def analysis(self, storage, junior, high, universe, toefl):  # 定义analysis函数分析作文
  315.         level1 = self.word_storage(storage, junior, high, universe, toefl)[0]
  316.         level2 = self.word_storage(storage, junior, high, universe, toefl)[1]
  317.         level3 = self.word_storage(storage, junior, high, universe, toefl)[2]
  318.         level4 = self.word_storage(storage, junior, high, universe, toefl)[3]
  319.         quantity_of_word = len(self.words)
  320.         quantity_of_advanced_word = 0
  321.         total_goals = 0
  322.         quantity_of_level2 = 0
  323.         quantity_of_level3 = 0
  324.         quantity_of_level4 = 0
  325.         for word in self.words:  # 运用循环结构对词汇进行赋分
  326.             if word in level2:
  327.                 quantity_of_level2 += 1
  328.                 quantity_of_advanced_word += 1
  329.                 total_goals += 60
  330.             elif word in level3:
  331.                 quantity_of_level3 += 1
  332.                 quantity_of_advanced_word += 1
  333.                 total_goals += 80
  334.             elif word in level4:
  335.                 quantity_of_level4 += 1
  336.                 quantity_of_advanced_word += 1
  337.                 total_goals += 100
  338.         # 计算普通词汇和四个等级的高级词汇占比
  339.         ordinary_word = 1 - quantity_of_advanced_word/quantity_of_word
  340.         advanced_word = quantity_of_advanced_word/ quantity_of_word
  341.         level2_word = quantity_of_level2/quantity_of_word
  342.         level3_word = quantity_of_level3/quantity_of_word
  343.         level4_word = quantity_of_level4/quantity_of_word
  344.         average_advanced_score = total_goals/quantity_of_advanced_word
  345.         # 返回计算结果
  346.         try:
  347.             return [ordinary_word, advanced_word, level2_word, level3_word, level4_word, average_advanced_score]
  348.         except:
  349.             print('请重新输入数据')
  350.  
  351.  
  352. # 定义get_result函数，输入原文和修改后作文
  353. def get_result(text_name1, text_name2):
  354.     text1 = Storage_level(text_name1)
  355.     text2 = Storage_level(text_name2)
  356.     text1_analysis = text1.analysis("词库.xlsx", 'junior', 'high', 'universe', 'toefl')
  357.     text2_analysis = text2.analysis("词库.xlsx", 'junior', 'high', 'universe', 'toefl')
  358.     # 将分析数据存储在result字典中
  359.     result={'Proportion of Common Words': text1_analysis[0],
  360.             'Proportion of Advanced Words': text1_analysis[1],
  361.             'Proportion of Level 2 Advanced Words': text1_analysis[2],
  362.             'Proportion of Level 3 Advanced Words': text1_analysis[3],
  363.             'Proportion of Level 4 Advanced Words': text1_analysis[4],
  364.             'Average Score of Advanced Words': text1_analysis[5],
  365.             'Proportion of Common Words in Modified Text': text2_analysis[0],
  366.             'Proportion of Advanced Words in Modified Text': text2_analysis[1],
  367.             'Proportion of Level 2 Advanced Words in Modified Text': text2_analysis[2],
  368.             'Proportion of Level 3 Advanced Words in Modified Text': text2_analysis[3],
  369.             'Proportion of Level 4 Advanced Words in Modified Text': text2_analysis[4],
  370.             'Average Score of Advanced Words in Modified Text': text2_analysis[5]}
  371.     return result
  372.  
  373.  
  374. words_level= get_result('text1.txt', 'text2.txt')
  375. selected_keys = ['Proportion of Common Words', 'Proportion of Level 2 Advanced Words', 'Proportion of Level 3 Advanced Words', 'Proportion of Level 4 Advanced Words', 'Proportion of Common Words in Modified Text', 'Proportion of Level 2 Advanced Words in Modified Text', 'Proportion of Level 3 Advanced Words in Modified Text', 'Proportion of Level 4 Advanced Words in Modified Text']
  376. selected_words_level = {k: words_level[k] for k in selected_keys}
  377. words_level = get_result('text1.txt', 'text2.txt')
  378. selected_keys = ['Proportion of Common Words', 'Proportion of Level 2 Advanced Words', 'Proportion of Level 3 Advanced Words', 'Proportion of Level 4 Advanced Words', 'Proportion of Common Words in Modified Text', 'Proportion of Level 2 Advanced Words in Modified Text', 'Proportion of Level 3 Advanced Words in Modified Text', 'Proportion of Level 4 Advanced Words in Modified Text']
  379.  
  380. selected_words_level1 = {k: words_level[k] for k in selected_keys[:4]}
  381.  
  382. words_level = get_result('text1.txt', 'text2.txt')
  383. selected_keys = ['Proportion of Common Words', 'Proportion of Level 2 Advanced Words', 'Proportion of Level 3 Advanced Words', 'Proportion of Level 4 Advanced Words', 'Proportion of Common Words in Modified Text', 'Proportion of Level 2 Advanced Words in Modified Text', 'Proportion of Level 3 Advanced Words in Modified Text', 'Proportion of Level 4 Advanced Words in Modified Text']
  384.  
  385. selected_words_level2 = {k: words_level[k] for k in selected_keys[-4:]}
  386.  
  387.  
  388.  
  389.  
  390.  
  391.  
  392. # 计算原文和修改后作文的'Average Score of Advanced Words'的比值
  393. ratio_of_words_level = words_level['Average Score of Advanced Words in Modified Text']/words_level['Average Score of Advanced Words']
  394. # 输出结果
  395. print(get_result('text1.txt', 'text2.txt'))
  396.  
  397.  
  398. """
  399. 体检报告
  400. """
  401. # 基本的语法修改
  402. def correct_text(text):
  403.     # 将中文标点替换为英文标点
  404.     text=text.replace("，", ",")
  405.     text=text.replace("。", ".")
  406.     text=text.replace("！", "!")
  407.     text=text.replace("？", "?")
  408.     text=text.replace("；", ";")
  409.     text=text.replace("：", ":")
  410.  
  411.     # 如果标点后忘记加空格，则在标点后面补上一个空格
  412.     for i in range(len(text)):
  413.         if text[i] in [",", ".", "!", "?", ";", ":"] and i < len(text) - 1 and text[i + 1] not in [" ", "\n"]:
  414.             text=text[:i + 1] + " " + text[i + 1:]
  415.     return text
  416.  
  417. text1 = correct_text(open("text1.txt", "r").read())
  418. text2 = correct_text(open("text2.txt", "r").read())
  419.  
  420. # 体检报告
  421. def get_info(text):
  422.     # 段落数初始化为1
  423.     num_paragraphs=1
  424.     # 句子数初始化为0
  425.     num_sentences=0
  426.  
  427.     for i in range(len(text)):
  428.         if text[i] == "\n":
  429.             num_paragraphs+=1
  430.         if text[i] in [".", "?", "!"]:
  431.             num_sentences+=1
  432.     # 获取词汇列表
  433.     totalwords=text.split()
  434.     word_list=[word.lower().strip(string.punctuation + string.whitespace) for word in totalwords]
  435.     # 统计形符数（词数）
  436.     num_of_words=len(word_list)
  437.     # 统计类符数（不重复出现的形符数）
  438.     num_of_nonrep_words=len(set(word_list))
  439.     # 统计平均词长
  440.     avg_length=sum(map(len, word_list)) / len(word_list)
  441.     # 统计词长标准差
  442.     standard_diviation=sum(map(lambda x: (x - avg_length) ** 2, map(len, word_list))) / len(word_list)
  443.  
  444.     return num_paragraphs, num_sentences, num_of_words, num_of_nonrep_words, avg_length, standard_diviation
  445.  
  446.  
  447. """
  448. 可视化输出
  449. """
  450. my_dict = {"key1": 0.25, "key2": 0.25, "key3": 0.25, "key4": 0.25}
  451. workDir = os.getcwd()
  452.  
  453.  
  454. def zhifangtu(a_dict):
  455.     import matplotlib.pyplot as plt
  456.     import matplotlib.font_manager as fm
  457.     plt.rcParams['font.sans-serif']=['Times New Roman']
  458.     keys=list(a_dict.keys())
  459.     values=list(a_dict.values())
  460.     # 设置直方图边界和颜色等属性
  461.     plt.bar(keys, values, align='center', alpha=0.5, edgecolor='black', linewidth=1.2)
  462.     for i, v in enumerate(values):
  463.         plt.text(i, v + 1, str(v), ha='center', va='bottom', fontweight='bold')
  464.     # 设置标题和标签等属性
  465.     title_font={'fontsize': 50, 'fontweight': 'bold', 'fontstyle': 'italic', 'color': 'blue'}
  466.     title_font1={'fontsize': 40}
  467.     plt.title('TF–IDF Word Frequency Chart', fontdict=title_font)
  468.     plt.xlabel('Words', fontdict=title_font1)
  469.     plt.ylabel('TF–IDF Word Frequency', fontdict=title_font1)
  470.     fig=plt.gcf()
  471.     fig.set_size_inches(20, 30)
  472.     fontprop=fm.FontProperties(size=20)
  473.     fontprop1=fm.FontProperties(size=30)
  474.     plt.xticks(rotation=45, ha='right', fontproperties=fontprop)
  475.     plt.yticks(ha='right', fontproperties=fontprop1)
  476.     # 显示图像
  477.     plt.savefig('TF–IDF Word Frequency Chart 1')
  478.  
  479.  
  480.  
  481. def zhifangtu1(a_dict):
  482.     import matplotlib.pyplot as plt
  483.     import matplotlib.font_manager as fm
  484.     plt.rcParams['font.sans-serif']=['Times New Roman']
  485.     keys=list(a_dict.keys())
  486.     values=list(a_dict.values())
  487.     # 设置直方图边界和颜色等属性
  488.     plt.bar(keys, values, align='center', alpha=0.5, edgecolor='black', linewidth=1.2)
  489.     for i, v in enumerate(values):
  490.         plt.text(i, v + 1, str(v), ha='center', va='bottom', fontweight='bold')
  491.     # 设置标题和标签等属性
  492.     title_font={'fontsize': 50, 'fontweight': 'bold', 'fontstyle': 'italic', 'color': 'blue'}
  493.     title_font1={'fontsize': 40}
  494.     plt.title('TF–IDF Word Frequency Chart', fontdict=title_font)
  495.     plt.xlabel('Words', fontdict=title_font1)
  496.     plt.ylabel('TF–IDF Word Frequency', fontdict=title_font1)
  497.     fig=plt.gcf()
  498.     fig.set_size_inches(20, 30)
  499.     fontprop=fm.FontProperties(size=20)
  500.     fontprop1=fm.FontProperties(size    =30)
  501.     plt.xticks(rotation=45, ha='right', fontproperties=fontprop)
  502.     plt.yticks(ha='right', fontproperties=fontprop1)
  503.     # 显示图像
  504.     plt.savefig('TF–IDF Word Frequency Chart 2')
  505.  
  506.  
  507. '''fic_of_TFIDF1 = zhifangtu(x[0])
  508. fic_of_TFIDF2 = zhifangtu(x[1])
  509. fic_of_TFIDF3 = zhifangtu(x[2])'''
  510.  
  511.  
  512. def bing(b):
  513.     import matplotlib.pyplot as plt
  514.     plt.rcParams['font.sans-serif']=['Times New Roman']
  515.     keys=list(b.keys())[:4]  # 仅选择前四个键
  516.     values=list(b.values())[:4]  # 仅选择前四个值
  517.     colors=['pink', 'red', 'red', 'purple', 'blue']
  518.     alpha=[0.3, 0.3, 0.9, 0.8]
  519.     title_font1={'fontsize': 15, 'color': 'black'}
  520.     plt.title('Chart of Advanced Words1', fontdict=title_font1)
  521.     pie_chart=plt.pie(values, labels=keys, autopct='%1.1f%%', startangle=90, counterclock=False)
  522.     for i in range(len(pie_chart[0])):
  523.         pie_chart[0][i].set_color(colors[i])
  524.         pie_chart[0][i].set_alpha(alpha[i])
  525.         plt.savefig(os.path.join(workDir, 'Chart_of_Advanced_Words1''.png'))
  526.     fig=plt.gcf()
  527.     fig.set_size_inches(5, 5)
  528.     fontprop=fm.FontProperties(size=16)
  529.     plt.legend(prop=fontprop)
  530.  
  531. bing(selected_words_level1)
  532.  
  533.  
  534. def bing1(b):
  535.     import matplotlib.pyplot as plt
  536.     plt.rcParams['font.sans-serif']=['Times New Roman']
  537.     keys=list(b.keys())[:4]  # 仅选择前四个键
  538.     values=list(b.values())[:4]  # 仅选择前四个值
  539.     colors=['pink', 'red', 'red', 'purple', 'blue']
  540.     alpha=[0.3, 0.3, 0.9, 0.8]
  541.     title_font1={'fontsize': 15, 'color': 'black'}
  542.     plt.title('Chart of Advanced Words2', fontdict=title_font1)
  543.     pie_chart=plt.pie(values, labels=keys, autopct='%1.1f%%', startangle=90, counterclock=False)
  544.     for i in range(len(pie_chart[0])):
  545.         pie_chart[0][i].set_color(colors[i])
  546.         pie_chart[0][i].set_alpha(alpha[i])
  547.         plt.savefig(os.path.join(workDir, 'Chart_of_Advanced_Words2'+'.png'))
  548.     fig.set_size_inches(5, 5)
  549.     fontprop=fm.FontProperties(size=16)
  550.     plt.legend(prop=fontprop)
  551.  
  552. bing(selected_words_level2)
  553.  
  554.  
  555.  
  556.  
  557.  
  558.  
  559. def get_info(text):
  560.     # 段落数初始化为1
  561.     num_paragraphs=1
  562.     # 句子数初始化为0
  563.     num_sentences=0
  564.  
  565.     for i in range(len(text)):
  566.         if text[i] == "\n":
  567.             num_paragraphs+=1
  568.         if text[i] in [".", "?", "!"]:
  569.             num_sentences+=1
  570.     # 获取词汇列表
  571.     totalwords=text.split()
  572.     word_list=[word.lower().strip(string.punctuation + string.whitespace) for word in totalwords]
  573.     # 统计形符数（词数）
  574.     num_of_words=len(word_list)
  575.     # 统计类符数（不重复出现的形符数）
  576.     num_of_nonrep_words=len(set(word_list))
  577.     # 统计平均词长
  578.     avg_length=sum(map(len, word_list)) / len(word_list)
  579.     # 统计词长标准差
  580.     standard_diviation=sum(map(lambda x: (x - avg_length) ** 2, map(len, word_list))) / len(word_list)
  581.  
  582.     return [[num_paragraphs], [num_sentences], [num_of_words], [num_of_nonrep_words], [round(avg_length, 2)],
  583.             [round(standard_diviation, 2)]]
  584.  
  585.  
  586. def blocki(f):
  587.     import matplotlib.pyplot as plt
  588.     headers=['Result']
  589.     table=plt.table(cellText=f, colLabels=headers,
  590.                     rowLabels=['Paragraph Num', 'Sentence Num', 'Word Num', 'Nonrep word Num', 'Average word Length',
  591.                                'Word Standard Divation'], colWidths=[0.2], cellLoc='center', loc='center')
  592.     plt.axis('off')
  593.     plt.savefig(os.path.join(workDir, 'ff.png'))
  594.  
  595.  
  596. blocki(get_info(text1))
  597.  
  598.  
  599.  
  600. def calculate_time(func):
  601.     def wrapper(*args, **kwargs):
  602.         start_time = time.time()
  603.         result = func(*args, **kwargs)
  604.         end_time = time.time()
  605.         print(f"程序运行时间为 {end_time - start_time} 秒")
  606.         return result
  607.     return wrapper
  608.  
  609.  
  610. @calculate_time
  611. def my_function():
  612.     # 这里放你要计算时间的代码
  613.     pass
  614.  
  615. my_function() # 程序运行时间为 X 秒 ··
  616.  
  617.  
  618.  
  619. from tkinter import *
  620. from tkinter import scrolledtext
  621.  
  622. from PIL import Image, ImageTk
  623. Img1Open = Image.open(os.path.join(workDir, 'Chart_of_Advanced_Words1.png'))
  624. Img2Open = Image.open(os.path.join(workDir, 'Chart_of_Advanced_Words1.png'))
  625. Img3Open = Image.open(os.path.join(workDir, 'Chart_of_Advanced_Words1.png'))
  626. Img4Open = Image.open(os.path.join(workDir, 'Chart_of_Advanced_Words1.png'))
  627. Img5Open = Image.open(os.path.join(workDir, 'Chart_of_Advanced_Words1.png'))
  628. checkReportPng = Image.open(os.path.join(workDir, 'ff.png'))
  629.  
  630.  
  631.  
  632. windowTitle = "作文评分系统"
  633. # 用format方法给windowPrompt1和windowPrompt2传入参数text1、2
  634. windowPrompt1 = str.format("文本1：{}", text1)
  635. windowPrompt2 = str.format("文本2（已为您纠正基本的标点与空格错误）：{}", text2)
  636. similarityDecPercent = str(ratio_of_repetition * 100) + "%"
  637. wordLevelIncPercent = str(ratio_of_words_level * 100) + "%"
  638. themeFitIncPercent = ""
  639. # 用format方法给requirementText数据：打开题目文件，读取题目文件内容
  640. requirementText =  "题目：\n" + str.format("{}", open("text1.txt", "r").read())
  641.  
  642.  
  643. img1Png = None
  644. img2Png = None
  645. img3Png = None
  646. img4Png = None
  647. img5Png = None
  648. checkReportPng = None
  649.  
  650. # 窗口参数
  651.  
  652. # 窗口宽度
  653. windowWidth = 1200
  654. # 窗口高度
  655. windowHeight = 600
  656. # 子窗口百分比宽度
  657. subWindowWidth = 0.3
  658. # 子窗口百分比高度
  659. subWindowHeight = 0.8
  660. # 按钮百分比宽度
  661. buttonWidth = 0.25
  662. # 按钮百分比高度
  663. buttonHeight = 0.2
  664.  
  665. # 控件类
  666.  
  667. class mainWindow(Frame):
  668.  
  669.     def __init__(self, master = None):
  670.         super().__init__(master)
  671.         # 创建窗口
  672.         self.rootFrame = Frame(root, width = windowWidth, height = windowHeight)
  673.         self.rootFrame.pack(side = "top", fill = "both", expand = 1)
  674.         self.createMainWindow(self.rootFrame)
  675.  
  676.     # 创建主窗体
  677.     def createMainWindow(self, mainFrame):
  678.         # 创建左子窗体
  679.         mainFrame.leftSubWindow = scrolledtext.ScrolledText(mainFrame)
  680.         mainFrame.leftSubWindow.insert(END,windowPrompt1)
  681.         mainFrame.leftSubWindow.place(relheight = subWindowHeight, relwidth = subWindowWidth, relx = 0.1, rely = 0.05)
  682.         # 创建中子窗体
  683.         mainFrame.midSubWindow = scrolledtext.ScrolledText(mainFrame)
  684.         mainFrame.midSubWindow.insert(END,windowPrompt2)
  685.         mainFrame.midSubWindow.place(relheight = subWindowHeight, relwidth = subWindowWidth, relx = 0.4, rely = 0.05)
  686.         # 创建右子窗体
  687.         mainFrame.rightSubWindow = Frame(mainFrame)
  688.         self.createRightWindow(mainFrame.rightSubWindow)
  689.         mainFrame.rightSubWindow.place(relheight = subWindowHeight, relwidth = subWindowWidth, relx = 0.7, rely = 0.05)
  690.         # 创建退出按钮
  691.         mainFrame.quit = Button(mainFrame, text = "退出", bg = "red", command = self.master.destroy)
  692.         mainFrame.quit.place(anchor = S, relheight = 0.05, relwidth = 0.2, relx = 0.5, rely = 0.95)
  693.  
  694.     # 填充右子窗体内容
  695.     def createRightWindow(self, rightWindow):
  696.         # 创建显示子窗体
  697.         rightWindow.showWindow = Frame(rightWindow)
  698.         rightWindow.showWindow.place(relheight = 0.7, relwidth = 0.8, relx = 0.1, rely = 0.25)
  699.         # 创建评分比较按钮
  700.         rightWindow.scoreCompare = Button(rightWindow, text = "评分比较", command = lambda : self.showScore(rightWindow.showWindow))
  701.         rightWindow.scoreCompare.place(relheight = buttonHeight, relwidth = buttonWidth, relx = 0.1, rely = 0)
  702.         # 创建检测报告按钮
  703.         rightWindow.checkReport = Button(rightWindow, text = "检测报告", command = lambda : self.showCheckReport(rightWindow.showWindow))
  704.         rightWindow.checkReport.place(relheight = buttonHeight, relwidth = buttonWidth, relx = 0.4, rely = 0)
  705.         # 创建题目要求按钮
  706.         rightWindow.requirement = Button(rightWindow, text = "题目要求", command = lambda : self.showRequirement(rightWindow.showWindow))
  707.         rightWindow.requirement.place(relheight = buttonHeight, relwidth = buttonWidth, relx = 0.7, rely = 0)
  708.  
  709.     # 显示评分
  710.     def showScore(self, subWindow):
  711.         # 清空子窗体内控件
  712.         for widget in subWindow.winfo_children() :
  713.             widget.destroy()
  714.         # 将子窗体分为两部分
  715.         subWindow.rightUpSubWindow = Frame(subWindow)
  716.         subWindow.rightUpSubWindow.place(relheight = 0.5, relwidth = 1, relx = 0, rely = 0)
  717.         subWindow.rightDownSubWindow = Frame(subWindow)
  718.         subWindow.rightDownSubWindow.place(relheight = 0.5, relwidth = 1, relx = 0, rely = 0.5)
  719.         # 初始化要显示的图片
  720.         global img1Png
  721.         img1Png = ImageTk.PhotoImage(Img1Open,master = subWindow.rightUpSubWindow)
  722.         global img2Png
  723.         img2Png = ImageTk.PhotoImage(Img2Open,master = subWindow.rightUpSubWindow)
  724.         global img3Png
  725.         img3Png = ImageTk.PhotoImage(Img3Open,  master = subWindow.rightDownSubWindow)
  726.         global img4Png
  727.         img4Png = ImageTk.PhotoImage(Img4Open,  master = subWindow.rightDownSubWindow)
  728.         global img5Png
  729.         img5Png = ImageTk.PhotoImage(Img5Open,  master = subWindow.rightDownSubWindow)
  730.         # 显示相似度降低值
  731.         subWindow.rightUpSubWindow.similarityDec = Label(subWindow.rightUpSubWindow, text = "您的文章相似度降低了:" + similarityDecPercent)
  732.         subWindow.rightUpSubWindow.similarityDec.place(relheight = 0.1, relwidth = 0.9, relx = 0.05, rely = 0.05)
  733.         # 显示高级度提升值
  734.         subWindow.rightUpSubWindow.wordLevelInc = Label(subWindow.rightUpSubWindow, text = "您的文章词汇高级度提升了:" + wordLevelIncPercent)
  735.         subWindow.rightUpSubWindow.wordLevelInc.place(relheight = 0.1, relwidth = 0.9, relx = 0.05, rely = 0.2)
  736.         # 显示fig1
  737.         subWindow.rightUpSubWindow.fig1 = Label(subWindow.rightUpSubWindow, image = img1Png)
  738.         subWindow.rightUpSubWindow.fig1.place(relheight = 0.4, relwidth = 0.4, relx = 0.05, rely = 0.5)
  739.         # 显示fig2
  740.         subWindow.rightUpSubWindow.fig2 = Label(subWindow.rightUpSubWindow, image = img2Png)
  741.         subWindow.rightUpSubWindow.fig2.place(relheight = 0.4, relwidth = 0.4, relx = 0.55, rely = 0.5)
  742.         # 显示文章主题契合度提升值
  743.         subWindow.rightDownSubWindow.themeFit = Label(subWindow.rightDownSubWindow, text = "您的文章主题契合度提升了:" + themeFitIncPercent)
  744.         subWindow.rightDownSubWindow.themeFit.place(relheight = 0.1, relwidth = 0.9, relx = 0.05, rely = 0.05)
  745.         # 显示关键词分布
  746.         subWindow.rightDownSubWindow.keyword = Label(subWindow.rightDownSubWindow, text = "具体关键词分布如下:")
  747.         subWindow.rightDownSubWindow.keyword.place(relheight = 0.1, relwidth = 0.9, relx = 0.05, rely = 0.2)
  748.         # 显示fig3
  749.         subWindow.rightDownSubWindow.fig3 = Label(subWindow.rightDownSubWindow, image = img3Png)
  750.         subWindow.rightDownSubWindow.fig3.place(relheight = 0.4, relwidth = 0.3, relx = 0, rely = 0.5)
  751.         # 显示fig4
  752.         subWindow.rightDownSubWindow.fig4 = Label(subWindow.rightDownSubWindow, image = img4Png)
  753.         subWindow.rightDownSubWindow.fig4.place(relheight = 0.4, relwidth = 0.3, relx = 0.35, rely = 0.5)
  754.         # 显示fig5
  755.         subWindow.rightDownSubWindow.fig5 = Label(subWindow.rightDownSubWindow, image = img5Png)
  756.         subWindow.rightDownSubWindow.fig5.place(relheight = 0.4, relwidth = 0.3, relx = 0.7, rely = 0.5)
  757.  
  758.     # 显示检测报告
  759.     def showCheckReport(self, subWindow) :
  760.         # 清空子窗体内控件
  761.         for widget in subWindow.winfo_children() :
  762.             widget.destroy()
  763.         # 初始化报告图片
  764.         global checkReportPng
  765.         checkReportPng = ImageTk.PhotoImage(Img1Open,master = subWindow)
  766.         # 显示报告
  767.         subWindow.checkReport = Label(subWindow, image = checkReportPng)
  768.         subWindow.checkReport.place(relheight = 0.9, relwidth = 0.9, relx = 0.05, rely = 0.05)
  769.  
  770.  
  771.     # 显示题目要求
  772.     def showRequirement(self, subWindow) :
  773.         # 清空子窗体内控件
  774.         for widget in subWindow.winfo_children() :
  775.             widget.destroy()
  776.         # 显示题目要求
  777.         subWindow.requirementTextBox = scrolledtext.ScrolledText(subWindow)
  778.         subWindow.requirementTextBox.insert(END,requirementText)
  779.         subWindow.requirementTextBox.place(relheight = 0.9, relwidth = 0.9, relx = 0.05, rely = 0.05)
  780.  
  781.  
  782.  
  783. root = Tk()
  784. root.title(windowTitle)
  785. window1 = mainWindow(master = root)
  786. window1.mainloop()
'
运行

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/819369
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号