结构调整25

11 概念认知/流式调用/4 类方法.py

@@ -0,0 +1,29 @@
+from cppy.cp_util import *
+
+class Flow:
+    def extract_file_words(self, filepath):
+        self.data = extract_file_words(filepath)
+        return self
+    
+    def get_frequencies(self):
+        self.data = get_frequencies(self.data)
+        return self
+    
+    def sort_dict(self):
+        self.data = sort_dict(self.data)
+        return self        
+
+    def print_word_freqs(self, n):
+        print_word_freqs(self.data, n)
+        return self
+
+
+# 顺序调用
+Flow().extract_file_words(testfilepath).get_frequencies().sort_dict().print_word_freqs(10)
+
+'''
+连续方法调用，看起来比较舒服
+但是需要假设：
+ - 每一个类方法返回 self  ：否则，没法连续
+ - 类方法默认不写第一个参数，数据都在 .data 里面
+'''

11 概念认知/流式调用/5 类方法.py

@@ -1,29 +1,50 @@
 from cppy.cp_util import *
 
-class Flow:
+# 装饰器改写类
-    def extract_file_words(self, filepath):
+# - 找到以f_开头的方法
-        self.data = extract_file_words(filepath)
+# - 将方法函数的返回值赋值给对象的data属性
-        return self
+# - 返回对象自身 
+def return_self_decorator(cls):
+    def return_self(func):
+        # 定义一个闭包函数，用于接收参数
+        def wrapper(self, *args, **kwargs):            
+            self.data = func(self, *args, **kwargs)            
+            return self # 返回类自身        
+        return wrapper
     
-    def get_frequencies(self):
+    for name, method in cls.__dict__.items():
-        self.data = get_frequencies(self.data)
+        # 判断属性是否可调用，且属性名以f_开头
-        return self
+        if callable(method) and name.startswith('f_'):            
+            # 为类改写属性，将封装后的函数赋值
+            setattr(cls, name, return_self(method))    
+    return cls
 
-    def sort_dict(self):
+@return_self_decorator
-        self.data = sort_dict(self.data)
+class Flow():        
-        return self        
+    def test(self):
+        return 'test'
     
-    def print_word_freqs(self, n):
+    def f_extract_file_words(self, filepath):
+        return extract_file_words(filepath)        
+    
+    def f_get_frequencies(self):
+        return get_frequencies(self.data)        
+    
+    def f_sort_dict(self):
+        return sort_dict(self.data)        
+
+    def f_print_word_freqs(self, n):
         print_word_freqs(self.data, n)        
-        return self
 
 
 # 顺序调用
-Flow().extract_file_words(testfilepath).get_frequencies().sort_dict().print_word_freqs(10)
+Flow().f_extract_file_words(testfilepath).f_get_frequencies().f_sort_dict().f_print_word_freqs(10)
 
 '''
-连续方法调用，看起来比较舒服
+改写后，参与 function flow 功能的方法 
-但是需要假设：
+ - 需要以 'f_' 开头
- - 每一个类方法返回 self  ：否则，没法连续
  - 类方法默认不写第一个参数，数据都在 .data 里面
+
+仍旧需要特殊的方法写法
+所以，还是 1，2种方法比较自然
 '''

11 概念认知/流式调用/6 类方法.py

@@ -1,50 +0,0 @@
-from cppy.cp_util import *
-
-# 装饰器改写类
-# - 找到以f_开头的方法
-# - 将方法函数的返回值赋值给对象的data属性
-# - 返回对象自身 
-def return_self_decorator(cls):
-    def return_self(func):
-        # 定义一个闭包函数，用于接收参数
-        def wrapper(self, *args, **kwargs):            
-            self.data = func(self, *args, **kwargs)            
-            return self # 返回类自身        
-        return wrapper
-    
-    for name, method in cls.__dict__.items():
-        # 判断属性是否可调用，且属性名以f_开头
-        if callable(method) and name.startswith('f_'):            
-            # 为类改写属性，将封装后的函数赋值
-            setattr(cls, name, return_self(method))    
-    return cls
-
-@return_self_decorator
-class Flow():        
-    def test(self):
-        return 'test'
-    
-    def f_extract_file_words(self, filepath):
-        return extract_file_words(filepath)        
-    
-    def f_get_frequencies(self):
-        return get_frequencies(self.data)        
-    
-    def f_sort_dict(self):
-        return sort_dict(self.data)        
-
-    def f_print_word_freqs(self, n):
-        print_word_freqs(self.data, n)        
-
-
-# 顺序调用
-Flow().f_extract_file_words(testfilepath).f_get_frequencies().f_sort_dict().f_print_word_freqs(10)
-
-'''
-改写后，参与 function flow 功能的方法 
- - 需要以 'f_' 开头
- - 类方法默认不写第一个参数，数据都在 .data 里面
-
-仍旧需要特殊的方法写法
-所以，还是 1，2种方法比较自然
-'''

12 语言特性/1 类生成器/元类.py

@@ -0,0 +1,26 @@
+from cppy.cp_util import *
+from collections import Counter
+
+# 定义一个带计数器的元类
+class CounterMetaclass(type):
+    def __new__(mcs, name, bases, attrs):         
+        attrs['_counter'] =  Counter()
+        return super().__new__(mcs, name, bases, attrs)
+
+# 基于元类创建类
+class Word( metaclass=CounterMetaclass ):
+    def __init__(self, word):
+        self.word = word
+        self._counter[self.word] += 1
+
+    @classmethod
+    def get_word_freqs(cls,n) -> Counter:
+        return cls._counter.most_common(n)
+    
+
+for word in  extract_file_words ( testfilepath ) :  Word(word)
+print_word_freqs(Word.get_word_freqs(10))
+
+'''
+常用于将依赖项（如服务或配置）自动注入到类中。
+'''