Python教程：拆分多级目录的方法

刘卡瓦

实现多级目录差分，举例说明如下：
假设现有的目录结构如下：1、2、2.1、2.2、2.3、2.4、3、4、5、6、6.1、6.1.1、6.1.2、6.1.3、6.1.4、6.2、6.3、6.4、7、8、9、10。
经过差分后，得到的各级目录为：

• 一级目录：1、2、3、4、5、6、7、8、9、10
  
• 二级目录：2.1、2.2、2.3、2.4和6.1、6.2、6.3、6.4
  
• 三级目录：6.1.1、6.1.2、6.1.3、6.1.4
  

各级目录的名字假设以字符串的方式存放，且最后拆分出的各级目录单独存放。
实现原理

假设目录等级最多三级，那么我们如何实现呢？
我们可以通过给各级目录赋一个权重，然后计算出各个目录对应的权重值，进行比较之后，就可以得到各级目录的分类。
假设各级目录最多有1000个。
（1）一级目录的权重就为1，则一级目录的1到1000对应的权重就是1到1000。

1. 1 ~ 1000 ==> 1 ~ 1000

复制代码

一级目录所占的数值范围：1 ~ 1000
（2）二级目录的权重赋值如下：

1. 1.1 ~ 1.100 ==> 1*1000+1 ~ 1*1000+100
3. 2.1 ~ 2.100 ==> 2*1000+1 ~ 2*1000+100
5. '''''' ''''''
7. 100.1 ~ 100.100 ==> 100*1000+1 ~ 100*1000+100
9. 1000.1 ~ 1000.1000 ==> 1000*1000+1 ~ 1000*1000 + 1000

复制代码

二级目录所占的数值范围：1000 ~ 1001000
（3） 三级目录的权重赋值如下：

1. 1.1.1 ~ 1.1.100 ==> 1*1000000+1*1000+1 ~ 1*1000000+1*1000+100
3. 1.1000.1 ~ 1.1000.1000 ==> 1*1000000+1000*1000+1~ 1*1000000+1000*1000+1000
5. 1.2.1 ~ 1.2.1000 ==> 1*1000000+2*1000+1 ~ 1*1000000+2*1000+1000

复制代码

最后，我们只需要将目录按照上述的公式计算出权重，就可以根据权重获得目录所在的目录结构是什么。
代码实现

测试数据：

1. ["1", "2", "2.1", "2.2", "2.3", "2.4", "3", "4", "5", "6", "6.1", "6.1.1", "6.1.2", "6.1.3", "6.1.4", "6.2", "6.3", "6.4", "7", "8", "9", "10"]

复制代码

1. # encoding: utf-8
2. import os
3. import sys
4. import logging
5. #学习中遇到问题没人解答？小编创建了一个Python学习交流群：153708845
6. # 设置logging.basicConfig()方法的参数和配置logging.basicConfig函数
7. FORMAT = '[%(funcName)s: %(lineno)d]: %(message)s'
8. LEVEL = logging.INFO
9. logging.basicConfig(level = LEVEL, format=FORMAT)
12. '''
13. * 获取二级标题所在目录名
14. * 返回值：二级目录标题名
15. 目录与数值对应关系：
16. 1.1 ~ 1.100 ==>  1*1000+1 ~ 1*1000+100
17. 2.1 ~ 2.100 ==>  2*1000+1 ~ 2*1000+100
18. '''
19. def judge_second_directory(get_num):
20.     for i in range(1, 1001, 1):
21.         if get_num > i * 1000 and get_num < (i+1)*1000:
22.             return str(i) + ".1"
23.     return None
26. '''
27. * 获取三级标题所在目录名
28. * 返回值：三级目录标题名
29. 目录与数值对应关系：
30. 1.1.1 ~ 1.1.100  ==> 1*1000000+1*1000+1 ~ 1*1000000+1*1000+100
31. 1.2.1 ~ 1.2.1000 ==> 1*1000000+2*1000+1 ~ 1*1000000+2*1000+1000
32. '''
33. def judge_three_directory(get_num):
34.     ret_str = None
35.     for i in range(1, 1001, 1):
36.         # 判断二级标题
37.         if get_num > i * 1000000 and get_num < (i+1)*1000000:
38.             ret_str = str(i) + "."
39.         for j in range(1, 1001, 1):
40.             # 判断三级标题
41.             if get_num > i*1000000 + j*1000 and get_num < i*1000000 + (j+1)*1000:
42.                 ret_str += str(j) + '.1'
43.                 return ret_str
44.     return None
47. '''
48. 按目录进行分类：
49. 分类原理：
50. (1) 一级目录：
51. 1 ~ 1000     ==>  1 ~ 1000
52. 一级目录所占的数字范围：1 ~ 1000
53. (2) 二级目录：
54. 1.1 ~ 1.100 ==>  1*1000+1 ~ 1*1000+100
55. 2.1 ~ 2.100 ==>  2*1000+1 ~ 2*1000+100
56. ''''''
57. ''''''
58. 100.1 ~ 100.100    ==> 100*1000+1 ~ 100*1000+100
59. 1000.1 ~ 1000.1000 ==> 1000*1000+1 ~ 1000*1000 + 1000
60. 二级目录所占的数字范围：1000 ~ 1001000
61. (3) 三级目录：
62. 1.1.1 ~ 1.1.100        ==> 1*1000000+1*1000+1 ~ 1*1000000+1*1000+100
63. 1.1000.1 ~ 1.1000.1000 ==> 1*1000000+1000*1000+1000
64. 1.2.1 ~ 1.2.1000 ==> 1*1000000+2*1000+1 ~ 1*1000000+2*1000+1000
65. '''
66. def dirctory_classify(directory_list):
67.     parent_directory = []
68.     second_directory = {}
69.     three_directory  = {}
70.     for directory_item in directory_list:
71.         num_list = directory_item.split(".")
72.         # 开始按目录进行分类
73.         if len(num_list) == 1:   # 一级目录
74.             parent_directory.append(directory_item)
75.         elif len(num_list) == 2: # 二级目录
76.             # 例：1.1 ==> 1*1000+1
77.             get_num = int(num_list[0]) * 1000 + int(num_list[1])
78.             dir_tmp = judge_second_directory(get_num)
79.             if dir_tmp == None:
80.                 continue
81.             if dir_tmp not in second_directory:
82.                 second_directory[dir_tmp] = [directory_item]
83.             else:
84.                 tmp_list = second_directory[dir_tmp]
85.                 tmp_list.append(directory_item)
86.                 second_directory[dir_tmp] = tmp_list
87.         elif len(num_list) == 3: # 三级目录
88.             # 例：1.1.100 ==> 1*1000000+1*1000+100
89.             get_num = int(num_list[0])*1000000 + int(num_list[1])*1000 + int(num_list[2])
90.             dir_tmp = judge_three_directory(get_num)
91.             if dir_tmp == None:
92.                 continue
93.             if dir_tmp not in three_directory:
94.                 three_directory[dir_tmp] = [directory_item]
95.             else:
96.                 tmp_list = three_directory[dir_tmp]
97.                 tmp_list.append(directory_item)
98.                 three_directory[dir_tmp] = tmp_list
99.         else:
100.             logging.error("这是一个超过三级目录的条目!!!!")
101.             logging.error("num: %s" % directory_item)
102.     return [parent_directory, second_directory, three_directory]
105. if __name__ == '__main__':
106.     original_data = ["1", "2", "2.1", "2.2", "2.3", "2.4", "3", "4", "5", "6", "6.1", "6.1.1", "6.1.2", "6.1.3", "6.1.4", "6.2", "6.3", "6.4", "7", "8", "9", "10"]
107.     directory = dirctory_classify(original_data)
109.     parent_directory = directory[0]
110.     second_directory = directory[1]
111.     three_directory  = directory[2]
113.     print ("一级目录：", parent_directory)
114.     print ("二级目录：", second_directory)
115.     print ("三级目录：", three_directory)

复制代码

运行测试：

可以看出，测试结果符合预期，一共有三级目录。各级目录中的目录结构也划分了出来。

来源:https://www.cnblogs.com/djdjdj123/p/18204395
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！