单词统计，top10 问题，没有用正则

统计单词出现次数（不是频率）

基本实现版本：

def cw_words(d = {}):
    def makekey(s: str):
        chars = set(r"""! '"#$%^&*()_+~=-><.,?/\}{][:;""")  # 因为有反斜杠，所以加r，用集合，查找快
        ret = []
        if 'path' in s:
            for i, c in enumerate(s):
                if c in chars:
                    ret.append(' ')  # 遇到特殊字符，就用空格替代
                else:
                    ret.append(c.lower())
        return ''.join(ret).split()

    def makekey1(s: str):
        chars = set(r"""! '"#$%^&*()_+~=-><.,?/\}{][:;""")  # 因为有反斜杠，所以加r
        ret = []
        start = 0
        if 'path' in s:
            for i, c in enumerate(s):  # d..  ..a
                if c in chars:
                    if start == i:  # 如果紧挨着还是特殊字符start一定等于i
                        start += 1  # 加1
                        continue
                    ret.append(s[start:i].lower())
                    start = i + 1  # 加1 是跳过这个不需要的特殊字符c
            else:
                if start < len(s):  # 小于，说明还是有效的字符，而且一直到末尾
                    ret.append(s[start:].lower())
        return ret

    with open('sample.txt', encoding='utf-8') as f:
        for line in f:
            words = line.split()
            for i in words:
                if 'path' not in i or i == []:
                    words.remove(i)
            for wordlist in map(makekey, words):  # 每个都拿上去 映射一次
                for word in wordlist:
                    d[word] = d.get(word, 0) + 1
    new_d =  sorted(d.items(), key=lambda item: item[1], reverse=True)
    print(new_d[0])
    return new_d[0]

cw_words()

 

优化版本：

#   No 2 对之前版本的优化  封装
'''
优化点：
    1、对一些没必要的单词的过滤
    2、没有必要 先把每一行切一遍，在到makekey中再切一遍，直接对每一行切，但是之前的chars中需要添加一个 空格了，
    3、之前是把切割之后的放在列表中，这样导致用到了很大的额外空间，所以这里使用了yield生成器，用一个出一个
    5、因为现在取前10 个，所以排序的时候， 没必要全部打印，所以只选取前10 个即可，
            这里推荐使用的方法：
                    1、计数的方法，出一个+1
                    2、切片取10个，因为之前用了yield，所以这里并不是所有的都取出来，而是只去了10个
    6、封装，尽量将所有的不需要别人看到的数据封装起来，此时，注意传参的问题。


# print('a','\n','------')
# a
#  ------
# print('a','\\n','------') # 转义
# a \n ------
# print('a','/\n','------')
# a /
#  ------
'''
def top10(filename):
    def makekey(s: str):
        chars = set(r"""! '"#$%^&*()_+~=-><.,?/\}{][:;""")  # 因为有反斜杠，所以加r，用集合，查找快
        key = s.lower()
        ret = []
        for i, c in enumerate(key):
            if c in chars:
                ret.append(' ')  # 遇到特殊字符，就用空格替代
            else:
                ret.append(c)
        print(ret)  # ['o', 's', ' ', 'p', 'a', 't', 'h'] ，连起来 ，在空白切开
        return ''.join(ret).split()

    def makekey1(line: str, chars = set("""! '"#$%^&*()_+~=-><.,?/\\}{][:; \n""") ):
         # 因为有反斜杠，所以加r,加一个空格

         # 这块切割是关键点，一个一个字符对应切
         # i 是控制索引，start 是切割的开头
         # 每次遇到特殊字符的时候，从start开始切，并且start要移动到现在i + 1 的位置，作为下次的起点
         # 如果下次还是特殊字符，此时i =  start,不切，继续往下，但是start继续往前，i+ 1
         #如果某次开始都往下都没有在发现特殊字符，就进入else语句，并且，从之前 start开始到最后都是字母，
        start = 0
        for i, c in enumerate(line):# Split the pathname path into a pair (root, ext) such that root + ext == path
            if c in chars:
                if start == i:  # 如果紧挨着还是特殊字符start一定等于i
                    start += 1  # 加1
                    continue
                yield line[start:i]
                start = i + 1  # 加1 是跳过这个不需要的特殊字符c
        else:
            if start < len(line):  # 小于，说明还是有效的字符，而且一直到末尾
                yield line[start:]

    def wordcount(filename, encodiong='utf-8', ingore={'a','to','the'}):
        d = {}
        with open(filename, encoding='utf-8') as f:
            for line in f:
                # words = line.split()
                for word in map(str.lower, makekey1(line)):  # 每一行 都拿去切割，每次需要的时候去取回一个 ，给map
                    # 这里的先后顺序是：word 去map取，map在去makekey取
                    if word not in ingore:
                        d[word] = d.get(word, 0) + 1
        return d
        # no 1  通过 i 控制，和no2 的count是一样的
        # for i, (k, v) in enumerate(sorted(d.items(), key=lambda item: item[1], reverse=True)):
        #     if i == n:break
        #     yield (k, v)
        # no 3
        # yield  from sorted(d.items(), key=lambda item: item[1], reverse=True)[:n] # n通过传参获取
    # no 2
    def _top(d):
        count = 1
        for i in sorted(d.items(), key=lambda item: item[1], reverse=True):
            yield i
            count += 1
            if count > 10:
                break
    return _top(wordcount(filename))

# NO 1 for 循环迭代
# for i in top10('sample.txt'):
#     print(i)
# NO 2list迭代器生成
print(list(top10('sample.txt')))

'''
单词统计：
        1、利用map映射，只是没有用到reduce，大数据的处理，mapreduce
        2、一般按照行处理，是比较合适的。
        3、生成器、装饰器是python的精华，所以要往这个方向考虑，一般一批一批，一个一个都是可以使用生成器的
            思路：返回一个列表，如果直接全部用可以用list，但是不需要可以惰性求值，通过for循环迭代
                  惰性求值：多个惰性求值一起使用，要一个，拿一个。
                  map(str.lower(), makekey(line))：先找map要一个，map 在找makekey要一个
            出现次数 ！= 出现频率

            排序取前几个：
                1、全排，切片
                2、计数，够了就不取了
        4、如果遍历，首选set， dict
        5、stopwords = set（）  专用词，停止词，遇到就停止
'''