案例一：对指定路径下的文件按照时间排序，并对文件重名：

        注意：

        1.获取文件时间的方法os模块下的 .getatime（‘文件路径’）得到一个时间值

        2.排序通过匿名函数，对时间进行排序

        3.重命名文件使用os模块下的 .rename('旧文件路径'，‘新文件路径’)，拆分文件路径然后再组装路径。源码如下：

import os
path='文件'
def get_time(path):
    return os.path.getatime(path)

# 遍历文件夹下的所有文件，然后调用上边的方法获取所有文件的修改时间
# for x in os.listdir(path):
#     print(path+'\\'+x)
#改写为列表推导式
files=[path+'\\'+x for x in os.listdir(path)]

# 排序按照关键字排序，对时间方法排序，调用时间方法，x指传入的文件路径
files.sort(key=lambda x:get_time(x))
# print(files)

# 计数器，文件前加序号
seq=1
for x in files:
    # print(x.split('.'))
    sp=x.split('.')
    # .join()传入两个参数，原路径，新路径
    os.rename(x,os.path.join(path , str(seq) +'-'+ sp[0].replace(path+'\\','') + '.'  + sp[-1]))
    seq += 1

实现结果展示：

python如何使用当前时间作为文件名_python

案例二：向 .txt 文本文档中读取、写入内容

        注意：写入txt的内容只能是字符串，或bytes类型，写入前注意转换。源码如下：

def is_prime(num):
    '''定义一个判断素数的方法，方便后续调用'''
    for i in range(2,int(num**0.5)+1):
        if num % i !=0 and num != 1:
            return num

def main1():
    '''读取文档中所有的素数'''
    with open('text1.txt','r',encoding='utf-8') as fp:
        for x in fp.readlines():
            if is_prime(int(x)):
                print(x)

def main2():
    '''读取文档中每一行的内容，内容有非整数，找出所有的素数'''
    with open('text2.txt','r',encoding='utf-8') as fp:
        for x in fp.readlines():
            # 异常调试
            try:
                if is_prime(int(x)):
                    print(x,end=' ')
            except ValueError:
                pass

def main3():
    '''向文件中写入指定范围素数'''
    with open('text3.txt', 'w+', encoding='utf-8') as fp:
        for x in range(1,10000):
            if is_prime(int(x)):
                fp.write(f'{x}\n')    # txt只能写入字符串str 和二进制字符串bytes

if __name__ == '__main__':
    main1()
    main2()
    main3()

案例三：以json的格式将数据写入文本文档

        注意：从python中写入到文本文档中，用 json.dumps() 序列化；

                   从文本中读取数据，json.loads() 反序列化。源码如下：

import json
### 将1-9999之间的素数写入到一个文本文件中，每行一个数字。
def is_sushu(num):
    for i in range(2,int((num)**0.5)+1):
        if num % i == 0:
            return False
    return True

def writefile():
    with open('tes.txt','w+',encoding='utf-8') as fp:
        for x in range(1,10000):
            if is_sushu(x):
                fp.write(str(x)+'\n')

### 将1-9999之间的素数放到一个列表中，将列表写入文件。
list1=[num1 for num1 in range(1,10000) if is_sushu(num1)]
with open('tes1.txt','w',encoding='utf-8') as fp:
    # 从python中写入文本，用json序列化
    fp.write(json.dumps(list1))

### 读取练习3或练习4中生成的文件获得素数的列表，将列表变成一个字典，字典中的键是列表中的元素，值是该元素的平方。
with open('tes1.txt','r',encoding='utf-8') as fp:
    # 从文本中读取数据，json反序列化
    data=json.loads(fp.read())
    dict1={i:i**2 for i in data}
    print(dict1)

案例四：递归删除文件夹(可能包含子文件或子文件夹)

        需求：要先将文件夹中的所有子文件删除再删除本文件夹【温馨提示：创建一个文件夹，不要直接操作已有的文件夹】

        注意：remove( ): 删除文件；rmdir( )： 删除空目录（空文件夹）。源码如下：

import os
def remove_dir(path):
    try:
        # 遍历路径
        for x in os.listdir(path):
            #拼接文件的路径
            path1 = os.path.join(path, x)
            if os.path.isdir(path1):
                #递归调用原函数
                remove_dir(path1)
            elif os.path.isfile(path1):
                # 删除指定路径的文件
                os.remove(path1)
        else:
            # 当文件中没有任何文件时执行这一步，删除空文件夹
            os.rmdir(path)
    # 对异常进行处理
    except FileNotFoundError:
        print('系统找不到指定的路径!!')

if __name__ == '__main__':
    remove_dir('newdir/dir1')

案例五：复制目录，考虑拷贝所有子文件，完全复制一个文件到指定文件路径下

        提示：遍历sourcePath下的所有子目录和子文件

                1，如果是子文件，则复制文件

                2，如果是子目录，在目标目录创建相同的目录名称，递归调用 

        注意：子文件或子目录的绝对路径。源码如下：

import os
def copyPath(sourcePath, targetPath):
    # 判断原目录是否存在
    if not os.path.exists(sourcePath):
        return "目录不存在"
    try:
        # 判断目标目录是否存在，如果不存在则创建
        if not os.path.exists(targetPath):
            os.mkdir(targetPath)

        for x in os.listdir(sourcePath):
            path1=os.path.join(sourcePath,x)
            if os.path.isdir(path1):
                # 如果是文件夹则在新文件夹中创建一个同名的文件夹，实现完全复制一个一模一样文件的功能
                os.mkdir(targetPath+'\\'+x)
                # 调用原函数，传入路径进行自动更新
                copyPath(path1,targetPath+'\\'+x)
            else:
                file = open(path1, 'r', encoding='utf-8')
                new_path=targetPath+'\\'+x
                fp = open(new_path, 'w', encoding='utf-8')
                # 写入文件,以指定大小1024字节读取、写入
                while True:
                    data=file.read(1024)
                    fp.write(data)
                    if data:
                        break
                file.close()
                fp.close()
    # 异常处理
    except FileExistsError:
        print('当文件已存在时，无法创建该文件')

if __name__ == "__main__":
    # 将sourcePath目录的所有内容拷贝到targetPath目录下
    sourcePath = r"XXXXXXXXXX\homework\newdir"
    targetPath = r"XXXXXXXXXXX\homework\dir4"
    copyPath(sourcePath, targetPath)

案例六：统计当前目录下的文件数量和文件夹数量；使用函数递归，分别统计文件夹中文件和文件夹的个数。

   提示：1.如果碰到文件，则文件数量+1；

             2.如果是文件夹，则文件夹数量+1，递归调用fn()传入当前子文件夹路径,访问内部的文件

   注意：此处容易踩坑，在函数外部定义一个计数器，在函数内部进行修改时，声明全局变量

             源码如下：

import os
dir_count=0
file_count=0
def fn(dirPath):
    # 在外部定义一个计数器，在函数内部进行修改，设置为全局变量
    # 如果在函数内部定义计数器，只会返回循环体最后一次出现的值
    global dir_count,file_count

    for x in os.listdir(dirPath):
        path1=os.path.join(dirPath,x)
        if os.path.isdir(path1):
            dir_count+=1
            fn(path1)
        else:
            file_count+=1
    return dir_count,file_count

if __name__ == '__main__':
    path=r'XXXXXXXXX\newdir\dir3'
    print(fn(path))