词频对象设计模式修订

16 其它/对象设计模式/注册回调/tf-15.py

@@ -1,4 +1,3 @@
-import operator, string
 from collections import defaultdict
 from cppy.cp_util import *
 

16 其它/对象设计模式/观察者.py

@@ -0,0 +1,56 @@
+import collections  
+from abc import ABC, abstractmethod  
+from cppy.cp_util import *
+
+# 定义观察者接口 ，在 Pyhon中并不是必须
+class Observer(ABC):  
+    @abstractmethod  
+    def update(self, word):  
+        pass  
+  
+# 定义具体观察者类，用于统计词频  
+class WordFrequencyObserver(Observer):  
+    def __init__(self):  
+        self.word_count = collections.Counter()          
+  
+    def update(self, word):  
+        self.word_count[word] += 1  
+  
+    def get_top_n(self,n):  
+        return self.word_count.most_common(n)  
+  
+# 定义主题类  
+class WordSubject:  
+    def __init__(self):  
+        self.observers = []  
+  
+    def attach(self, observer):  
+        self.observers.append(observer)  
+  
+    def notify(self, word):  
+        for observer in self.observers:  
+            observer.update(word)  
+  
+  
+# 主函数  
+def main(testfilepath, top_n = 10 ):  
+    stopwords = get_stopwords()  
+    subject = WordSubject()  
+  
+    # 创建一个观察者并附加到主题  
+    observer = WordFrequencyObserver()  
+    subject.attach(observer)  
+  
+    # 处理文件      
+    wordlist = re_split( read_file(testfilepath) )
+    for word in wordlist:  
+        if word not in stopwords:  
+            subject.notify(word)  
+  
+    # 打印最高的N个词频  
+    top_words = observer.get_top_n(top_n)  
+    print_word_freqs(top_words)
+    
+  
+if __name__ == "__main__":          
+    main( testfilepath )

16 其它/对象设计模式/观察者模式/Observer.py

@@ -1,77 +0,0 @@
-import os,re,string,operator
-from collections import Counter
-
-# TextProcessor 类负责处理文本并计算词频。当文本处理完成后，它会通过 notify 方法通知所有注册的观察者。
-# WordFrequencyObserver 类是一个具体的观察者，它实现了 update 方法来接收词频更新并打印前10个最常见的单词。
-class Subject:
-    def __init__(self):
-        self._observers = []
-    # 不能随意改变，所以肯定是私有
-    def attach(self, observer):
-        self._observers.append(observer)
-
-    def detach(self, observer):
-        self._observers.remove(observer)
-
-    def notify(self, word_freqs):
-        for observer in self._observers:
-            observer.update(word_freqs)
-# 关注，取消关注，通知有更新,Subject类是用来创建一个类，对订阅者（即观察者）列表进行维护
-
-class Observer:
-    def update(self, word_freqs):
-        pass
-# 定义一个抽象的Observer
-# 而下面的是一个具体的Observer类
-class WordFrequencyObserver(Observer):
-    def update(self, word_freqs):
-        print("词频已经被更新:")
-        self.print_word_freqs(word_freqs)
-
-    def print_word_freqs(self, word_freqs):
-        sorted_freqs = sorted(word_freqs.items(), key=operator.itemgetter(1), reverse=True)
-        for (w, c) in sorted_freqs[:10]:
-            print(f"{w}: {c}")
-
-# 对文本进行分析
-class TextProcessor:
-    def __init__(self, subject: Subject):
-#subject是Subject的子类，类型注解，单独写也可以
-        self._subject = subject
-        self._stop_words:str = set()
-#是一个集合（其实这里需要表明是str）
-    def load_stop_words(self, path_to_file):
-        with open(path_to_file, encoding='utf-8') as f:
-            self._stop_words = set(line.strip().lower() for line in f)
-
-    def process_text(self, path_to_file):
-        with open(path_to_file, encoding='utf-8') as f:
-            data = f.read()
-            word_list = self.re_split(data)
-            filtered_words = self.filter_words(word_list)
-            word_freqs = self.count_frequencies(filtered_words)
-            self._subject.notify(word_freqs)
-
-    def re_split(self, data):
-        pattern = re.compile('[\W_]+')
-        return pattern.sub(' ', data).lower().split()
-
-    def filter_words(self, word_list):
-        return [w for w in word_list if w not in self._stop_words and len(w) >= 3]
-
-    def count_frequencies(self, word_list):
-        return Counter(word_list)
-
-# 开始测试
-if __name__ == "__main__":
-    stopwordfilepath = r'C:\Users\asus\Desktop\cppy余悦批注\cppy\data\stop_words.txt'
-    testfilepath = r'C:\Users\asus\Desktop\cppy余悦批注\cppy\data\pride-and-prejudice.txt'
-
-    # 调用实例
-    subject = Subject()
-    observer = WordFrequencyObserver()
-    subject.attach(observer)
-
-    text_processor = TextProcessor(subject)
-    text_processor.load_stop_words(stopwordfilepath)
-    text_processor.process_text(testfilepath)

20 高性能模式/readme.md

@@ -1,6 +1,9 @@
 
+
 # 目标
 本节使用一个爬虫任务来展示如何追求代码的性能 。
+充分理解线程、协程、进程、同步、异步、阻塞、非阻塞等概念，并能够根据具体场景选择合适的并发模型。
+主线问题：如何解决IO和计算速度不匹配、如何任务分解、分发和协作 。
 
 # 任务
 

30 对象设计模式/readme.md

@@ -3,22 +3,27 @@
 # 目标
 本节使用一个书城的各种业务环节来展示面向对象的各种设计模式 。
 
+
 # 任务
-背景假设为一个综合书城，提供线上线下购买，还经营一个书吧、一个报告厅
+背景假设为一个综合书城，提供线上线下购买，还经营一个书吧、一个报告厅。
+
 
 # 说明
+面向对象的模式把编程过程中的一些思路固定化，并给一个名字方便理解 。
+它是软件工程中一组经过验证的、可重复使用的代码写法 。
+所以，模式不是语法，而是编程思路 。
+这样做的好处是，统一大家的代码形式，提高代码可读性、可维护性、可扩展性 。
+那为啥，面向过程没有这么做 ？
+是因为这个思维提炼过程，充分利用了面向对象语言的特性：封装、继承、多态 。
+面向过程语言，没有这些特性，所以，面向过程语言没有面向对象模式 。
+
 因为 Python 对象协议的机制，多态、接口概念发生了根本变化 。
-很多模式中，类的继承关系没必要了。下面示例中很多依旧保持了基类
-一是致敬经典，二是起到一个工程上更工整强注释的作用
+很多模式中，类的继承关系没必要了。下面示例中很多依旧保持了基类 。
+一是致敬经典，二是起到一个工程上更工整和强注释的作用 。
 
 另外,Python的动态语言的特性 。使得一些C++、Java 的模式没用了 。
 比如 “ 原型模式（Prototype）” ，可以使用copy.deepcopy()非常简便来创建 。
 
-面向对象设计模式是软件工程中一组经过验证的、可重复使用的解决方案，
-用于解决在设计和实现面向对象系统时经常遇到的设计问题。
-面向对象的模式把编程过程中的一些思路套路固定化，并给一个名字方便理解 。
-所以，模式不是语法，而是编程思路。
-那为啥，面向过程没有这么做？
-是因为这个思维提炼过程，充分利用了面向对象语言的特性：封装、继承、多态。
 
+# 应用场景
 面向对象设计模式在管理信息系统和图形用户界面系统应用比较广泛 。