文件目录操作实例1——遍历
本实例可用的实际操作：制作文件、目录管理程序，磁盘占用管理程序等。
基础实现将get到递归和os.walk的用途；拓展实现将get到os.stat对文件状态的获取。
基础实现：遍历一个目录，把所有文件和目录的归属表示出来。
示例：
操作对象：a文件夹里有b文件夹和c文件，b文件夹里有d文件夹和e文件。
操作结果：{‘files’: [], ‘a’: {‘files’: [‘c’], ‘b’: {‘files’: [‘e’], ‘d’: {‘files’: []}}}}。
- 思路1：获取所有文件和所有目录，进行路径分割，递归路径添加目录与文件。（四步操作）
- 获取所有子目录路径
- 获取所有文件路径
- 根据子目录路径创建所有子目录
- 根据子文件路径将所有子文件按路径放进子目录里
- 思路2：递归遍历目录，判断路径是目录还是文件，是目录则再次递归目录。（递归操作）
拓展实现：获取文件、目录的大小等属性。
示例：
操作对象：a文件夹里有b文件夹和c文件，b文件夹里有d文件夹和e文件。
操作结果：{‘inode保护模式’: “【所有者】拥有的权限有：[‘读’, ‘写’, ‘执行’]；【用户组】拥有的权限有：[‘读’, ‘写’, ‘执行’]；【其他用户】拥有的权限有：[‘读’, ‘写’, ‘执行’]；”, ‘inode节点号’: 1111111111111111, ‘inode驻留的设备’: 1111111111, ‘inode的链接数’: 1, ‘所有者的用户ID’: 0, ‘所有者的组ID’: 0, ‘分配单元大小’: ‘0.000 b’, ‘上次访问的时间’: ‘2021-11-11 11:11:11’, ‘最后一次修改的时间’: ‘2021-11-11 11:11:11’, ‘创建时间’: ‘2021-11-11 11:11:11’, ‘文件夹个数’: 3, ‘文件个数’: 2, ‘目录总大小’: ‘0.000 b’}。
- 思路：通过基础实现递归获取文件大小和数目即可成为目录的属性；先构造获取单文件的函数，再构造获取目录的函数。
基础实现——思路一
基础准备
首先导入相关库：
import os # 系统库之一，此处用来处理文件、目录以及路径操作
import json # json库，此处用来格式化打印字典
import time # 时间库，此处用来处理时间对象
os.walk(top, topdown=True, onerror=None, followlinks=False)- 遍历指定目录，包括所有子目录，必选参数为top（需要遍历的目录路径）。
topdown=True从根目录开始遍历，topdown=False从最深层子目录往根目录遍历。onerror：需要一个 callable 对象，当需要异常时，会调用。followlinks=True会遍历目录下的快捷方式（linux下是软连接）实际所指的目录，followlinks=False则忽略快捷方式。- 返回结构：( 当前子目录路径 , 当前目录内含有的文件夹列表 , 当前目录内含有的文件列表 )。
- 补充说明：指定目录为绝对路径时，返回的当前目录也是绝对路径；指定目录为相对路径时，返回的当前目录也是相对路径。
- 按示例示范相对目录遍历：
-
>>> import os >>> for a in os.walk('test'): ... print(a) ('test', ['a'], []) ('test\\a', ['b'], ['c']) ('test\\a\\b', ['d'], ['e']) ('test\\a\\b\\d', [], []) - 按示例示范绝对目录遍历：
-
>>> import os >>> path = os.path.abspath('test') # E:\Python\DEMO\Study\test >>> for a in os.walk(path): ... print(a) ('E:\\Python\\DEMO\\Study\\test', ['a'], []) ('E:\\Python\\DEMO\\Study\\test\\a', ['b'], ['c']) ('E:\\Python\\DEMO\\Study\\test\\a\\b', ['d'], ['e']) ('E:\\Python\\DEMO\\Study\\test\\a\\b\\d', [], [])
实际操作
首先先要定义存放数据的字典，否则数据昙花一现，刚获得就消失了。
path = os.path.abspath('practise') # 获取待遍历的文件夹的完整路径，在本电脑上为 E:\Python\DEMO\Study\practise
dirs = [] # 存放所有路径
files = [] # 存放所有文件
paths = {'files': []} # 目录树字典
第一和第二步骤比较简单这里就直接给出了：
# 获取所有子目录路径
for a in os.walk(path):
dirs.append(a[0])
# 获取所有文件路径
for a in os.walk(path):
if a[2]:
for f in a[2]:
files.append(f'{a[0]}\\{f}')
接下来根据子目录路径创建所有子目录，只有创建好了所有目录，才能保证所有子文件能有地方安放。
由于获取的路径可能是绝对路径，也可能是相对路径，在这里要把原本的路径前缀去除，方便进行路径分割进去子目录字典。
for d in dirs[1:]:
temp = d.replace(f'{path}\\', '').split('\\')
由于上方 os.walk() 默认使用 topdown=True 从根目录开始遍历，所以每个子目录的父目录会被前一个出现的子目录创建，此处为了获取最深层字典。
for p in range(len(temp)):
temp2 = paths
for t in temp[:p]:
temp2 = temp2[t]
如果子目录不在字典里，则添加新的子目录字典。
if temp[p] not in temp2:
temp2.update({temp[p]: {'files': []}})
当然添加子目录也可以使用eval函数快速完成，eval(f'paths{temp[:p] or ""}'.replace(', ', '][')) 就完成了路径分割进去子目录字典的操作。上方不用 temp2[temp[p]] = {'files': []} 是因为会有黄色背景警告，为了好看用 dict.update() 方法：
if temp[p] not in eval(f'paths{temp[:p] or ""}'.replace(', ', '][')): # 如果子目录不在字典里，则添加
eval(f'paths{temp[:p] or ""}'.replace(', ', ']['))[temp[p]] = {'files': []}
接下来就是根据子文件路径将所有子文件按路径放进子目录里了。
同样由于获取的路径可能是绝对路径，也可能是相对路径，在这里要把原本的路径前缀去除。
for f in files:
temp = f.replace(f'{path}\\', '').split('\\')
当路径分割后列表只剩一个时，表明这是在根目录，所以直接添加 files 的键值。
if len(temp) == 1:
paths['files'].append(temp[0])
剩余的和上一步骤一致，获取最深层字典。
else:
temp2 = paths
for t in temp[:-1]:
temp2 = temp2[t]
temp2['files'].append(temp[-1])
同样，添加文件也可以使用eval函数快速完成：
else:
eval(f'paths{temp[:-1] or ""}'.replace(', ', ']['))['files'].append(temp[-1])
这就是思路一，每步分工明确，依赖 os.walk() 自身独特的返回方式获取到了整个目录。
格式化打印整个 目录树 ：
print(json.dumps(paths, indent=4, ensure_ascii=False))
基础实现——思路二
基础准备
os.listdir(path)- 遍历指定目录，获取该目录下所有文件和目录。
- 返回结构：文件和目录列表，可以通过相关方法判断目标是文件还是文件夹。
- 补充说明：不管传入参数是不是绝对路径，返回的只会是文件或文件夹本身的名字而非路径。
- 按示例示范相对目录遍历：
-
>>> import os >>> path = os.path.abspath('test/a') >>> for a in os.listdir(path): ... print(a) b c
os.path.exists()- 判断目标是否存在，如果文件不存在则返回
False，否则返回True。
- 判断目标是否存在，如果文件不存在则返回
os.path.isfile()- 判断目标是否为文件，如果文件不存在或不是文件则返回
False，否则返回True。
- 判断目标是否为文件，如果文件不存在或不是文件则返回
os.path.isdir()- 判断目标是否为文件夹，如果文件夹不存在或不是文件夹则返回
False，否则返回True。
- 判断目标是否为文件夹，如果文件夹不存在或不是文件夹则返回
实际操作
依旧首先先要定义存放数据的字典，由于是递归获取，所以变量只需要一个 paths ，感觉挺节约内存的哈。
path = os.path.abspath('practise') # 获取待遍历的文件夹的完整路径，在本电脑上为 E:\Python\DEMO\Study\practise
paths = {'files': []} # 目录树字典
然后要确定递归的时候要递归什么，这里可以看到，zp 就是 子paths 的简称，是子目录字典；lj 就是 路径 的拼音结合，代表了当恰尼子目录路径，这样不递归的话，这个函数的作用就是遍历子目录，把子目录里的文件放进子目录字典内，这里默认值设置 path，就表示从根目录开始。
def loop(zp: dict, lj: str = path):
for i in os.listdir(lj):
if os.path.isfile(f'{lj}\\{i}'):
zp['files'].append(i)
elif os.path.isdir(f'{lj}\\{i}'):
zp[i] = {'files': []}
确定好了单路径添加文件的方式，接下来在识别为文件夹的 else 的最后加上一行 loop(zp[i], f'{lj}\\{i}') ，传入子目录字典与子目录路径，即可开始递归子目录。递归函数如下：
def loop(zp: dict, lj: str = path):
for i in os.listdir(lj):
if os.path.isfile(f'{lj}\\{i}'):
zp['files'].append(i)
elif os.path.isdir(f'{lj}\\{i}'):
zp[i] = {'files': []}
loop(zp[i], f'{lj}\\{i}')
这里由于简单，我顺便把 loop 函数写成了我喜欢的lambda函数形式，这里采用用 exec() 函数来添加子目录：
loop = lambda _, __ = path: [os.path.isdir(f'{__}\\{___}') and (exec("_[___] = {'files': []}") or loop(_[___], f'{__}\\{___}')) or _['files'].append(___) for ___ in os.listdir(__)]
接下来调用函数，填充 paths 变量，当前路径默认为 path 变量，所以不用添加。
loop(paths)
这就是思路二，用一个递归函数边获取文件边添加到子目录中。
格式化打印整个 目录树 ：
print(json.dumps(paths, indent=4, ensure_ascii=False))
拓展实现——思路
基础准备
os.stat(path, follow_symlinks)- 本质上调用 Linux 系统的 stat ，用于返回文件或文件夹本身信息。
followlinks=True会遍历目录下的快捷方式（linux下是软连接）实际所指的目录，followlinks=False则忽略快捷方式。- 返回结构：
os.stat_result(...)对象，含有如下属性：stat.st_mode：inode保护模式stat.st_ino：inode节点号stat.st_dev：inode驻留的设备stat.st_nlink：inode的链接数stat.st_uid：所有者的用户IDstat.st_gid：所有者的组IDstat.st_size：文件大小（对目录是不含子目录与文件的大小）【普通文件以字节为单位的大小】stat.st_atime：上次访问的时间stat.st_mtime：最后一次修改的时间stat.st_ctime：创建时间
os.path.getsize(filename)- 本质上调用
os.stat(filename).st_size，用于获取文件大小（对目录是不含子目录与文件的大小）。
- 本质上调用
time.strftime(format, struct_time)- 时间日期格式化
format为时间格式化格式struct_time为时间元组，可用time.localtime(时间戳浮点数)来获取本地时间元组- 各个字母含义如下：
- %y：两位数的年份表示（00-99）
- %Y：四位数的年份表示（0000-9999）
- %m：月份（01-12）
- %d：月中某天（01-31）
- %H：24小时制小时数（00-23）
- %I：12小时制小时数（01-12）
- %M：分钟数（00-59）
- %S：秒（00-59）
- %a：本地简化星期名称
- %A：本地完整星期名称
- %b：本地简化月份名称
- %B：本地完整月份名称
- %c：本地相应的日期表示和时间表示
- %j：年中某天（001-366）
- %p：本地A.M或P.M的等价符
- %U：一年中的星期数（01-53），星期天为星期的开始
- %w：每周星期（0-6），星期天为星期的开始
- %W：一年中的星期数（01-53），星期一为星期的开始
- %x：本地相应的日期表示
- %X：本地相应的时间表示
- %Z：当前时区的名称
- %%：%本身
实际操作
直接获取信息简单，现在来针对获取到的数据，做出相应的转变，变得更加人性化吧。
首先先要将inode保护模式（权限）转换成一般人看得懂的东西，stat.st_mode实际上是15位二进制转换成的十进制。
所以用如下所示函数获取权限部分：
def permission_detail(permission: int):
result = ''
for name, per in zip(['所有者', '用户组', '其他用户'], map(lambda p_: bin(permission)[2 + p_ * 3: 2 + p_ * 3 + 3], range(2, 5))):
per_ = []
for n_, p__ in zip(['读', '写', '执行'], map(int, list(per))):
if p__:
per_.append(n_)
result += f'【{name}】拥有的权限有：{per_}；'
return result
然后由于获得的文件大小单位默认是字节，太不人性化了，这里我们对他改良输出，让他能够输出我们想要的单位或自动适应合适数字大小的单位，其中 size_unit 来着函数 get_info 的局部变量：
def unit_size(size: int):
size_list = iter(['b', 'kb', 'mb', 'gb', 'tb'])
unit = next(size_list)
if size_unit == 'auto':
while size / 1024 > 1:
try:
size /= 1024
unit = next(size_list)
except StopIteration:
break
return f'{size:.3f} {unit}'
elif size_unit == 'bit':
return f'{size * 8} Bit'
elif size_unit == 'b':
return f'{size} Bytes'
elif size_unit == 'kb':
return f'{size / 1024:.3f} KB'
elif size_unit == 'mb':
return f'{size / 1024 / 1024:.3f} MB'
elif size_unit == 'gb':
return f'{size / 1024 / 1024 / 1024:.3f} GB'
elif size_unit == 'tb':
return f'{size / 1024 / 1024 / 1024 / 1024:.3f} TB'
return size
时间戳应该没有人陌生，但是个人看这一串字符串也看不出什么，所以我们用 time.strftime 来格式化一下时间对象，其中 str_time 来着函数 get_info 的局部变量：
def time_str(time_object: float):
if str_time:
return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time_object))
return time_object
最后整合一下获取信息的骨架，其中 是路径，size_unit 是单位，str_time 是是否格式化字符串的控制变量：
def get_info(lj: str, size_unit: str = 'auto', str_time: bool = True):
size_unit = size_unit.strip().lower()
if os.path.exists(lj):
stat = os.stat(lj)
if os.path.isfile(lj):
return {
'inode保护模式': permission_detail(stat.st_mode),
'inode节点号': stat.st_ino,
'inode驻留的设备': stat.st_dev,
'inode的链接数': stat.st_nlink,
'所有者的用户ID': stat.st_uid,
'所有者的组ID': stat.st_gid,
'文件大小': unit_size(stat.st_size),
'上次访问的时间': time_str(stat.st_atime),
'最后一次修改的时间': time_str(stat.st_mtime),
'创建时间': time_str(stat.st_ctime)
}
elif os.path.isdir(lj):
directories = [di[0] for di in os.walk(lj) if di[0] != lj]
file_total = eval('+'.join([str([f'{di[0]}\\{fi}' for fi in di[2]]) for di in os.walk(lj) if di[2]]))
stat = os.stat(lj)
return {
'inode保护模式': permission_detail(stat.st_mode),
'inode节点号': stat.st_ino,
'inode驻留的设备': stat.st_dev,
'inode的链接数': stat.st_nlink,
'所有者的用户ID': stat.st_uid,
'所有者的组ID': stat.st_gid,
'分配单元大小': unit_size(stat.st_size),
'上次访问的时间': time_str(stat.st_atime),
'最后一次修改的时间': time_str(stat.st_mtime),
'创建时间': time_str(stat.st_ctime),
'文件夹个数': len(directories),
'文件个数': len(file_total),
'目录总大小': unit_size(sum([os.path.getsize(fi) for fi in file_total]))
}
return '对象不存在！'
结束语
第一次投入了点时间编写实例解剖，憋字实在不是我的强项；原计划一周一更，仓促的话可能找的素材会比较随缘，希望各位喜欢~
1031
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
