python 人肉 python rms

1. 文件操作

ls、mk、rm、cp

 

【1】列出文件夹：ls(".")

结果列表 = ls ( 文件全路径, 包含前缀=True, 选项="" )  # 选项="-r" 表示递归列出

 

【2】创建文件 or 文件夹：mk("./a1.txt")

mk ( 文件全路径, 已有跳过_不删除=True, 选项="-p" )  # 选项="-p" 表示递归创建，也可以是-r

 

【3】删除文件 or 文件夹：rm("./a1.txt")

rm ( 文件全路径, 选项="-rf" )  # 选项="-r" 表示递归删除

 

【4】复制文件 or 文件夹：cp("./main.py","./main2.py")

 

 

2. 文件打开模式

（1）三种基本模式：r、w、a

r 只读

w 删除原文，只写

a 保留原文（追加），只写

 

（2）附加后缀

b 表示二进制读写

+ 表示额外赋予读写权限

U 表示读取的换行全部改成\n

 

（3）三种模式的不同

无文件时: r 报错，w、a 新建

是否清除原文：r 、a 否，w 是

初始读取位置：r、w 开头，a 结尾

 

import os
import shutil

from u_工具 import stream


# region fileSystem

def exist(文件全路径):
    return os.path.exists(文件全路径)

def isdir(文件全路径):
    if exist(文件全路径):
        return os.path.isdir(文件全路径)
    else:
        if get文件后缀(文件全路径):
            return False
        else:
            return True

def ls(文件全路径, 包含前缀=True, 选项=""):
    选项 = 选项.lower()
    if not exist(文件全路径):
        return []
    if not isdir(文件全路径):
        return [文件全路径]

    if ("p" in 选项) or ("r" in 选项):
        filePaths = getAllFilePaths(文件全路径, is_deep=True)
        if not 包含前缀:
            filePaths = stream(filePaths).map(lambda i: get文件名(i)).collect()
        return filePaths
    else:
        if 包含前缀:
            return stream(os.listdir(文件全路径)) \
                    .map(lambda i: os.path.join(文件全路径, i)).collect()
        else:
            return os.listdir(文件全路径)

def mkdir(文件全路径, 选项="-p"):
    选项 = 选项.lower()
    if not exist(文件全路径):
        if ("p" in 选项) or ("r" in 选项):
            os.makedirs(文件全路径)
        else:
            os.mkdir(文件全路径)

def mk(文件全路径, 已有跳过_不删除=True, 选项="-p"):
    选项 = 选项.lower()
    if exist(文件全路径):
        if not 已有跳过_不删除:
            rm(文件全路径, "-rf")
        else:
            return

    if isdir(文件全路径):
        mkdir(文件全路径, 选项)
    else:
        所在目录 = get文件所在目录(文件全路径)
        if 所在目录 and (not exist(所在目录)):
            mk(所在目录, 选项)
        with open(文件全路径, "a"):
            pass

def rm(文件全路径, 选项="-rf"):
    if exist(文件全路径):
        if isdir(文件全路径):
            if ("p" in 选项) or ("r" in 选项):
                shutil.rmtree(文件全路径)
            else:
                try:
                    os.rmdir(文件全路径)
                except:
                    stream(ls(文件全路径)).filter(lambda i: not isdir(i)) \
                        .forEach(lambda i: rm(i))
        else:
            os.remove(文件全路径)

def cp(旧文件, 新文件, 不删旧文件=True):
    旧文件类型 = "dir" if isdir(旧文件) else "file"
    新文件类型 = "dir" if isdir(新文件) else "file"
    
    # 确保文件夹存在
    if 新文件类型 == "dir":
        mk(新文件)
    if not exist(get文件所在目录(新文件)):
        mk(get文件所在目录(新文件))

    def file_file():
        # shutil.copyfile(旧文件,新文件)  # 只复制内容
        # 复制内容和权限 新文件不存在：新建，存在：覆盖
        shutil.copy(旧文件, 新文件)

    def file_dir():
        if not exist(新文件):
            mk(新文件)
        shutil.copy(旧文件, 新文件)

    def dir_file():
        if not exist(新文件):
            mk(新文件)
        with open(新文件, "ab") as ff:
            for i in ls(旧文件, 要包含前缀=True):
                with open(i, "rb") as f:
                    ff.write(f.read())

    def dir_dir():
        shutil.copytree(旧文件, 新文件)

    def default():
        raise Exception("复制失败,参数类型未支持")

    switch = {
        "file-file": file_file,
        "file-dir": file_dir,
        "dir-file": dir_file,
        "dir-dir": dir_dir
    }
    switch.get(f"{旧文件类型}-{新文件类型}", default)()

    if not 不删旧文件:
        rm(旧文件, "-rf")


def get文件名(文件全路径):
    return os.path.basename(文件全路径)
def get文件后缀(文件全路径):
    return os.path.splitext(文件全路径)[1]
def get文件所在目录(文件全路径):
    return os.path.dirname(文件全路径)


def getAllFilePaths(baseFilePath, is_deep=True):
    return getDeepFilePaths(baseFilePath, "*", is_deep)
# 递归获取 指定目录下，拥有指定后缀，的文件路径
def getDeepFilePaths(baseFilePath, ext_list="txt", is_deep=True):
    rst_filePaths = []
    _getDeepFilePaths(rst_filePaths, baseFilePath, ext_list, is_deep)
    return rst_filePaths
def _getDeepFilePaths(rst_filePaths, baseFilePath, ext_list="txt", is_deep=True):
    rst_filePaths += getCurrentFilePaths(baseFilePath, ext_list)
    # 递归当前目录下的目录
    if is_deep:
        f_list = stream(os.listdir(baseFilePath)) \
                    .map(lambda fileName: os.path.join(baseFilePath, fileName)) \
                    .collect()
        stream(f_list) \
            .filter(lambda f: os.path.isdir(f)) \
            .forEach(lambda dir: _getDeepFilePaths(rst_filePaths, dir, ext_list, True))
def getCurrentFilePaths(baseFilePath, ext_list="txt"):
    rst_filePaths = []
    if not baseFilePath:
        baseFilePath = "."
    # 处理ext后缀
    is_all_ext = False
    if not isinstance(ext_list, list):
        ext_list = [ext_list]
    selectExt_list = stream(ext_list).map(lambda i: i if (i and i[0]==".") else f".{i}").collect()
    if ("." in selectExt_list) or (".None" in selectExt_list):
        selectExt_list.append("")
    if (".*" in selectExt_list):
        is_all_ext = True
    selectExt_list = stream(selectExt_list).filter(lambda i: i!="." and i!=".None" and i!=".*").collect()

    # 获取当前目录下的所有文件名
    f_list = stream(os.listdir(baseFilePath)) \
                .map(lambda fileName: os.path.join(baseFilePath,fileName)) \
                .collect()

    if is_all_ext:
        rst_filePaths += stream(f_list) \
                            .filter(lambda f: not os.path.isdir(f)) \
                            .collect()
    else:
        # 将当前目录下后缀名为指定后缀的文件，放入rst_filePaths列表
        stream(f_list) \
            .filter(lambda f: not os.path.isdir(f)) \
            .filter(lambda f: os.path.splitext(f)[1] in selectExt_list) \
            .forEach(lambda f: rst_filePaths.append(f))
    return rst_filePaths

# endregion fileSystem

from u_工具 import stream 在：