Merge pull request '002' (#9) from master into dev

基本结构/041 插件/tf-20.py

@@ -16,6 +16,4 @@ def load_plugins():
 load_plugins()
 word_freqs = tffreqs.top25(tfwords.extract_words( testfilepath ))
 
-for (w, c) in word_freqs:
+print_word_freqs(word_freqs)
-    print(w, '-', c)
-

基本结构/享元模式/tf-38.py

@@ -1,18 +1,13 @@
-# -*- encoding:utf-8 -*-
-from cppy.cp_util import *
 '''
-享元模式  享元模式是一种结构型设计模式，在享元模式中，对象被设计为可共享的，可以被多个上下文使用，而不必在每个上下文中都创建新的对象。
+享元模式中，对象被设计为可共享的，被多个上下文使用，而不必在每个上下文中都创建新的对象。
 如果我们有大量不同的词频分析需求，有时需要词频前10的单词，有时需要词频前20的单词，有时还需要限定词汇的长度，那就需要创建多个词频统计器，每个词频统
-计器都独立创建并存储其内部状态，那么系统的内存占用可能会很大，在这种情况下，享元模式共享相同类型的词频统计器对象，每种类型的词频统计器只需创建一个
+计器都独立创建并存储其内部状态，在这种情况下，享元模式共享相同类型的词频统计器对象，只需创建一个共享实例，然后通过设置不同的参数个性化每个对象，通过共享相同的内部状态，降低了对象的创建和内存占用成本。
-共享实例，然后通过设置不同的参数个性化每个对象，通过共享相同的内部状态，降低了对象的创建和内存占用成本。
 例如，我需要对3个文件获取词频前十的单词，对另外3个文件获取词频前二十的单词，那么我只需要创建2个词频统计器对象，每个对象存储相同的内部状态，一个对象
 获取前十的单词，一个对象获取前二十的单词，而不用创建6个对象
 '''
-#以需要的词频数量分类
+
-# class Type(number):
+from cppy.cp_util import *
-def get_number():
+
-    number = int(input("请输入需要显示词频前几的单词"))
-    return number
 
 #定义享元接口
 class WordFrequencyController():
@@ -22,7 +17,7 @@ class WordFrequencyController():
 #定义具体的享元类
 class ConcreteWordFrequencyController(WordFrequencyController):
     def __init__(self, controllertype,filepath):
-        self.word_list = extract_words(filepath)
+        self.word_list = extract_file_words(filepath)
         self.word_freq = get_frequencies(self.word_list)
         self.word_freq = sort_dict(self.word_freq)
     def print_word_freqs(self, number):
@@ -37,8 +32,7 @@ class WordFrequencyControllerFactory():
     def get_WordFrequencyController(self, controller_type,testfilepath):
         if controller_type not in self.types:
             self.types[controller_type] = ConcreteWordFrequencyController(controller_type,testfilepath)
-            #创建新的享元对象
+            #创建新的享元对象        
-        print(self.types)#显示已存在的享元对象
         return self.types[controller_type]#重复使用已存在的享元对象
 
 def process_command(factory: WordFrequencyControllerFactory, number: str):
@@ -51,7 +45,7 @@ if __name__ == "__main__":
     factory = WordFrequencyControllerFactory()
     while True:
         try:
-            number = input("请输入需要显示词频前几的单词")
+            number = input("请输入需要显示词频前几的单词: ")
             process_command(factory, number)
         except EOFError:
             break

异常/1 软件不能挂掉/tf-21.py

@@ -1,4 +1,4 @@
-import sys, re, operator, string, inspect
+import re, operator, string
 from cppy.cp_util import *
 
 #
@@ -30,12 +30,7 @@ def remove_stop_words(word_list):
 def frequencies(word_list):
     if type(word_list) is not list or word_list == []:  return {}
 
-    word_freqs = {}
+    word_freqs = get_frequencies( word_list )    
-    for w in word_list:
-        if w in word_freqs:
-            word_freqs[w] += 1
-        else:
-            word_freqs[w] = 1
     return word_freqs
 
 def sort(word_freq):

计算设备/map-reduce/tf_92.py

@@ -6,9 +6,8 @@ from cppy.cp_util import *
 stopwords = get_stopwords()
 
 def process_chunk(chunk):  
-    # 切词并过滤停用词  
+    # 切词并过滤停用词       
-    words = re.findall(r'\w+', chunk.lower())  
+    words = extract_str_words( chunk.lower() )
-    words = [ word for word in words if word not in stopwords and len(word) > 2]  
     return Counter(words)  
   
 def merge_counts(counts_list):  

计算设备/缓存/84.py

@@ -20,8 +20,7 @@ def calculate_word_frequency(file_path):
 
 # 测试函数
 top_10_words = calculate_word_frequency(testfilepath)
-for word, freq in top_10_words:
+print_word_freqs(top_10_words)
-    print(f"{word}: {freq}")
 
 '''
 python 提供了一种缓存调用函数的机制

语言特性/异步/tf_91.py

@@ -40,6 +40,5 @@ if __name__ == '__main__':
     total_count = Counter()
     for result in results:  total_count += result
 
-    # 打印词频最高的10个单词
+    # 打印词频最高的10个单词    
-    for w,c in total_count.most_common(10):
+    print_word_freqs( total_count.most_common(10) )     
-        print(w, '--',c)

语言特性/装饰/tf-19A.py

@@ -15,9 +15,9 @@ def word_frequency( top_n=10 ):
                 word_counts[word] += 1            
             
             # 输出所有词的频率最高的n个词            
-            most_common = word_counts.most_common(top_n)            
+            most_common = word_counts.most_common(top_n)    
-            for w, count in most_common:
+            util.print_word_freqs( most_common )                    
-                print(f"{w} - {count}")
+            
             return result
         
         return wrapper