1. import os
    4. os.walk(specify_dir)

    os.walk 返回一个生成器对象，
    返回元素结构为: [完整路径, [当前完整路径下含有的子目录], [当前完整路径下所有的文件]]
    通过不断遍历 os.walk 可以得到当前目录下的所有文件夹，与子文件

    第一个元素打印的是 根目录， 下一个元素即为 根目录+子目录 ， 依此类推，将所有子目录进行一个完整遍历， 不需要使用递归

    错误代码示范

    编写程序usr_max.py, 找出指定的目录(如/etc)文本之最：
    最多行的文件是：
    字符串最多的文件是：
    最多被使用的单词是：
    出现的最长的单词是：

    1. #!/usr/bin/python3
    2. # coding = utf-8
    4. # 该文件写的有问题， 需要进行修改
    7. import os
    8. import re
    9. from collections import Counter
    11. data = []
    15. def get_result(file_name):
    16.     """返回 文件的 字符串的数量 最多被使用的单词 出现最长的单词"""
    17.     try:
    18.         with open(file_name, mode="r", encoding="utf-8") as f:
    19.             file_content = f.read()
    20.     except:
    21.         # 这里报错说明不是文本文件
    22.         return [0, 0, ("", 0), 0]
    23.     # 获取全部字符串列表
    24.     all_ = re.findall('[a-z]+', file_content)
    25.     if len(all_) == 0:
    26.         return [0, 0, ("", 0), 0]
    27.     # 获取出现最多的字符串
    28.     max_string = Counter(all_).most_common(1)
    29.     max_string = max_string[0] if len(max_string) != 0 else ("", 0)
    31.     # 获取最长的字符串
    32.     sort_all = sorted(all_, key=lambda x:len(x), reverse=True)
    33.     max_leng = sort_all[0] if len(sort_all) != 0 else ""
    36.     return [file_content.count('\n'), len(all_), max_string, max_leng]
    42. def recursion(file_path):
    43.     """利用 os walk + 递归 遍历所有文件夹"""
    44.     # 使用全局变量
    45.     global data
    46.     for i in os.walk(file_path):
    48.         # 提取下一级目录
    49.         for next_dir in i[1]:
    50.             recursion(i[0] + '/' +next_dir)
    52.         for cur_file_name in i[2]:
    53.             final_file_name = i[0] + '/' + cur_file_name
    54.             result = get_result(final_file_name)
    55.             if result[1] != 0:
    56.                 # 这里做一下筛选， 没有单词的就不要入库了， 浪费空间
    57.                 data.append([final_file_name, result])
    61. def main():
    62.     file_path = input("请输入目录名称")
    63.     # file_path = '/etc'
    65.     recursion(file_path)
    67.     if len(data) == 0:
    68.         print("发生错误, 该目录下并没有找到任何文本文件")
    69.         return
    71.     # 编写比较代码
    72.     # print(data)
    74.     # 比较行数
    75.     res = sorted(data, key=lambda x:x[1][0], reverse=False)[-1]
    76.     print("最多行的文件是: %s, 共有 %d 行" % (res[0], res[1][0]))
    77.     # 获取单词数量
    78.     res = sorted(data, key=lambda x: x[1][1], reverse=False)[-1]
    79.     print("字符串最多的文件: %s, 共有: %d 个字符串" % (res[0], res[1][1]))
    81.     # print(res)
    82.     # 最多被使用的单词
    83.     max_count = {}
    84.     for i in data:
    85.         if i[1][2][0] in max_count:
    86.             max_count[i[1][2][0]] += i[1][2][1]
    87.         else:
    88.             max_count[i[1][2][0]] = i[1][2][1]
    89.     max_count_list = list(max_count.items())
    90.     max_count_list.sort(key=lambda x:x[1])
    91.     # print(max_count_list)
    92.     print("最多被使用的单词是: %s" % max_count_list[-1][0])
    94.     # 出现的最长单词
    96.     res = sorted(data, key=lambda x:len(x[1][3]), reverse=False)[-1]
    97.     print("出现的最长的单词: %s" % res[1][3])
    102. if __name__ == '__main__':
    103.     main()
    104.     # s = get_result('/etc/pam.conf')
    105.     # print(s)

    错误分析: 因为使用者错误理解 os.walk 的用法 , 导致使用递归 去遍历该文件夹， 性能出现重大延时， 结果也不正确, 因为多遍历了一次文件夹

    正确写法

    1. def recursion(file_path):
    2.     """利用 os walk + 递归 遍历所有文件夹"""
    3.     # 使用全局变量
    4.     global data
    5.     for i in os.walk(file_path):
    8.         for cur_file_name in i[2]:
    9.             final_file_name = i[0] + '/' + cur_file_name
    10.             result = get_result(final_file_name)
    11.             if result[1] != 0:
    12.                 # 这里做一下筛选， 没有单词的就不要入库了， 浪费空间
    13.                 data.append([final_file_name, result])