调整

语言特性/尾调用_类方法/t26c。py

@@ -1,65 +0,0 @@
-from cppy.cp_util import *
-from collections import Counter  
-from heapq import nlargest  
-import re  
-  
-  
-class Pipeline:  
-    def __init__(self):  
-        pass  
-  
-    def __or__(self, other):  
-        class PipelineComposition(Pipeline):  
-            def __init__(self, first, second):  
-                self.first = first  
-                self.second = second  
-  
-            def process(self, data):  
-                return self.second.process(self.first.process(data))  
-  
-        return PipelineComposition(self, other)  
-  
-    def process(self, data):  
-        raise NotImplementedError  
-  
-  
-class FileReader(Pipeline):  
-    def __init__(self, filename):  
-        super().__init__()  
-        self.filename = filename  
-  
-    def process(self):  
-        with open(self.filename, 'r', encoding='utf-8') as file:  
-            content = file.read()  
-        return content  
-  
-  
-class WordFrequencyCounter(Pipeline):  
-    def process(self, text):  
-        words = re.findall(r'\w+', text.lower())  
-        word_freq = Counter(words)  
-        return word_freq  
-  
-  
-class TopNFilter(Pipeline):  
-    def __init__(self, n):  
-        super().__init__()  
-        self.n = n  
-  
-    def process(self, word_freq):  
-        return nlargest(self.n, word_freq.items(), key=lambda item: item[1])  
-  
-  
-# 假设有一个文本文件"text.txt"，其内容是需要分析的文本  
-filename = testfilepath
-n = 5  # 求取最高5个词频  
-  
-# 创建管道  
-pipeline = FileReader(filename) | WordFrequencyCounter() | TopNFilter(n)  
-  
-# 执行管道  
-top_n_words = pipeline.process()  
-  
-# 打印结果  
-for word, freq in top_n_words:  
-    print(f"{word}: {freq}")

语言特性/尾调用_类方法/tf-26.py

@@ -1,42 +1,21 @@
-from collections import Counter
 from cppy.cp_util import *
-import re
 
+# 如果有连续的对数据加工操作，而且总是把共同加工数据对象当第一个参数，可以用一个管道框架来封装
+# 注意：最后还要调用一次对象call方法，才能执行最后一个函数
 class Pipe:
     def __init__(self, func, *args, **kwargs):        
-        # print( self, func, *args, **kwargs )
         self.func = func
         self.args = args
         self.kwargs = kwargs
 
     def __or__(self, other):
-        return Pipe(lambda x: self.func(x) or other.func(x))
+        data = self.func(*self.args, **self.kwargs)                     
-        # print(self.func.__name__, other.func.__name__ )
+        return Pipe( other.func,data,*other.args,**other.kwargs)
-        def composed_func():
-            print( other.func(self.func(self.args, self.kwargs), other.args, other.kwargs) ) 
-            return other.func(self.func(self.args, self.kwargs), other.args, other.kwargs)
-        return Pipe(composed_func)
 
-    # def __call__(self, *args, **kwargs):
+    def __call__(self):
-    #     print( *args, **kwargs )
+        return self.func(*self.args, **self.kwargs)
-    #     return self.func(*args, **kwargs)
-    def __call__(self, data):        
-        return self.func(data)    
 
-def read_file(filename):
-    with open(filename, 'r',encoding='utf-8') as f:
-        return f.read()
 
-def split_words(text):
+# 模仿管道
-    return re.findall(r'\b\w+\b', text.lower())
+pipe = Pipe(extract_file_words,testfilepath) | Pipe(get_frequencies) | Pipe(sort_dict) | Pipe(print_word_freqs, 10)
-
+pipe()
-def count_words(words):
-    return Counter(words)
-
-def top_n_words(word_counts, n):
-    return word_counts.most_common(n)
-
-# 使用管道
-pipe = Pipe(read_file) | Pipe(split_words) | Pipe(count_words) | Pipe(top_n_words, 10)
-result = pipe(testfilepath)
-print(result)

语言特性/尾调用_类方法/tf-26B.py

@@ -1,49 +1,25 @@
-import re
-from collections import Counter
-from functools import reduce
 from cppy.cp_util import *
 
-class Pipeline:
+# 这种连续方法调用，看起来也比较舒服
-    def __init__(self, function):
+# 每一个类方法返回 self ，另外最后一个方法注意是否有返回值
-        self.function = function
 
-    def __or__(self, other):
+class Flow:
-        if isinstance(other, Pipeline):
+    def extract_file_words(self, filepath):
-            return Pipeline(lambda x: self.function(x) or other.function(x))
+        self.data = extract_file_words(filepath)
-        else:
+        return self
-            raise TypeError("The argument must be an instance of Pipeline")
     
-    def process(self, data):
+    def get_frequencies(self):
-        return self.function(data)
+        self.data = get_frequencies(self.data)
+        return self
     
-# 定义处理函数
+    def sort_dict(self):
-def read_file(path):
+        self.data = sort_dict(self.data)
-    with open(path, 'r', encoding='utf-8') as file:
+        return self        
-        return file.read()
 
-def clean_text(text):
+    def print_word_freqs(self, n):
-    return re.sub(r'[^\w\s]', '', text).lower()
+        print_word_freqs(self.data, n)
+        return self
 
-def tokenize(text):
-    return re.findall(r'\b\w+\b', text)
 
-def remove_stop_words(tokens, stop_words):
+# 顺序调用
-    return [token for token in tokens if token not in stop_words]
+Flow().extract_file_words(testfilepath).get_frequencies().sort_dict().print_word_freqs(10)
-
-def count_frequencies(tokens):
-    return Counter(tokens)
-
-def get_top_n_frequencies(counter, n):
-    return counter.most_common(n)
-
-# 定义停用词列表
-stop_words = set(['the', 'and', 'a', 'to', 'of', 'in', 'for', 'on', 'is', 'it', 'with', 'that', 'as', 'by', 'this', 'at', 'be', 'which', 'from', 'or', 'are', 'an', 'but', 'not', 'you', 'have', 'your', 'can', 'will', 'all', 'any', 'if', 'their', 'would', 'what', 'there', 'when', 'which', 'who', 'whom', 'whose', 'where', 'why'])
-
-# 创建管道
-pipeline = (Pipeline(read_file) | clean_text | tokenize
-             | remove_stop_words | count_frequencies
-             | get_top_n_frequencies(n=10))
-
-# 执行管道并打印结果
-top_n_word_frequencies = pipeline.process( testfilepath )
-print(top_n_word_frequencies)