python3 实现读写文件（xlsx文件/ini文件/json文件/yaml文件），代码已封装更新

SzetoZeZe

已于 2023-04-19 18:23:39 修改

阅读量465

点赞数

分类专栏：读_写_创建文件内容文章标签： json yaml ini python

于 2021-11-15 10:30:18 首次发布

本文链接：https://blog.csdn.net/weixin_45471729/article/details/121328186

版权

读_写_创建文件内容专栏收录该内容

1 篇文章 0 订阅

订阅专栏

实现向指定的 Excel 文件中写入数据

from pandas.tests.io.excel.test_xlrd import xlrd
from xlutils.copy import copy
from glo import BASE_DIR


def write_xlsx(sheet, row, rank, data):
    """写入xlsx
    :param sheet: 获取表单sheet名称
    :param row: 列
    :param rank: 行
    :param data: 写入的data数据
    :return:

    """
    rb = xlrd.open_workbook(BASE_DIR + r'/TestData/***.xlsx')  # 打开weng.xls文件
    wb = copy(rb)  # 利用xlutils.copy下的copy函数复制
    ws = wb.get_sheet(sheet)  # 获取表单
    ws.write(row, rank, data)  # 改变（0,0）的值
    wb.save(BASE_DIR + r'/TestData/***.xlsx')

# write_xlsx("自选股", 76, 7, str(data))

以上代码的作用是向指定的 Excel 文件中写入数据，其中 `xlrd` 和 `xlutils` 库用于操作 Excel 文件。

可以将该函数进行优化封装，增加一些参数的默认值，使得调用更加方便。以下是优化后的代码：

import xlrd
from xlutils.copy import copy


def write_to_excel(file_path, sheet_name, row, col, data):
    """
    写入excel文件
    :param file_path: excel文件路径
    :param sheet_name: 表单名称
    :param row: 行号
    :param col: 列号
    :param data: 写入的数据
    """
    # 打开excel文件并复制
    rb = xlrd.open_workbook(file_path, formatting_info=True)
    wb = copy(rb)
    # 获取表单
    ws = wb.get_sheet(sheet_name)
    # 写入数据
    ws.write(row, col, data)
    # 保存文件
    wb.save(file_path)

优化后的函数增加了参数的默认值，并且将函数名进行了修改，更加符合函数的作用。函数的参数说明如下：

- `file_path`: 要写入的excel文件路径
- `sheet_name`: 要写入的表单名称
- `row`: 写入数据的行号
- `col`: 写入数据的列号
- `data`: 要写入的数据

使用优化后的函数，可以通过以下方式调用：

file_path = BASE_DIR + r'/TestData/***.xlsx'
sheet_name = "自选股"
row = 76
col = 7
data = "要写入的数据"
write_to_excel(file_path, sheet_name, row, col, data)

这样调用函数更加简洁明了，也可以根据实际需要修改参数。

我们还可以使用 `openpyxl` 库代替了 `xlrd` 和 `xlutils` 库，使用 `os.path` 模块拼接文件路径。

import os
import openpyxl

# 定义文件名和表单名
file_name = "test.xlsx"
sheet_name = "sheet1"

# 定义数据
data = "hello world"

# 拼接文件路径
file_path = os.path.join(BASE_DIR, "TestData", file_name)

# 打开Excel文件
if os.path.exists(file_path):
    wb = openpyxl.load_workbook(file_path)
else:
    wb = openpyxl.Workbook()

# 获取表单
ws = wb[sheet_name]

# 写入数据
row = 1
col = 1
ws.cell(row=row, column=col, value=data)

# 保存文件
wb.save(file_path)

优化后的代码更加简洁易读。另外，如果文件不存在，则新建一个 Excel 文件。然后对其进行二次封装：

import os
import openpyxl

def write_to_excel(file_name, sheet_name, data):
    # 拼接文件路径
    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
    file_path = os.path.join(BASE_DIR, "TestData", file_name)

    # 打开Excel文件
    if os.path.exists(file_path):
        wb = openpyxl.load_workbook(file_path)
    else:
        wb = openpyxl.Workbook()

    # 获取表单
    ws = wb[sheet_name]

    # 写入数据
    row = 1
    col = 1
    ws.cell(row=row, column=col, value=data)

    # 保存文件
    wb.save(file_path)

我们使用write_to_excel这个函数的参数包括文件名（file_name）、表单名（sheet_name）和数据（data），其中文件名和表单名需要自己定义，数据可以根据实际情况传入。在函数内部，根据文件路径打开 Excel 文件，获取表单，然后写入数据并保存文件。使用时，可以直接调用该函数，如下所示：

file_name = "test.xlsx"
sheet_name = "sheet1"
data = "hello world"
write_to_excel(file_name, sheet_name, data)

这样就可以将数据写入到指定的 Excel 文件和表单中了。

读取xlsx文件

import pandas as pd
from glo import BASE_DIR


def shuju(sheet):
    """读取xlsx文件
    :param sheet: 获取表单sheet名称
    :return:
    """
    df = pd.read_excel(BASE_DIR + r'/TestData/***.xlsx', sheet_name=sheet)
    # df = pd.read_excel(r'TestData/***.xlsx', sheet_name=sheet)     #直接copy   ***.xlsx的相对路径
    data = df.values
    # print(data)
    return data


#def zhuorui(sheet, name, info=None):
#    for i in shuju(sheet):
#        if name in i:
#            if info == None:
#                return common(i)
#            else:
#                return common(i, info)

以上代码的功能是读取指定 Excel 文件中的指定 sheet 的数据，并返回一个包含数据的二维数组。

以下是对代码的解析和优化封装：

1. `pd.read_excel()` 函数是 Pandas 库中的读取 Excel 文件的函数，它可以直接读取 Excel 文件中的数据，参数 `sheet_name` 用于指定读取的 sheet 名称，返回的是一个 Pandas DataFrame 对象。
2. `df.values` 将 DataFrame 对象转化为 numpy 数组，该数组包含了 Excel 中的所有数据。
3. `BASE_DIR` 是一个全局变量，用于表示项目根目录的路径，`r` 表示使用原始字符串（raw string）的方式表示路径。
4. 函数名 `shuju` 不够明确，可以改为 `read_excel_data` 等更明确的名称。

开始对以上代码重新优化封装：

#glo.py
import os
from typing import Union

BASE_DIR: Union[bytes, str] = os.path.dirname(os.path.abspath(__file__))

import pandas as pd
from glo import BASE_DIR


def read_excel_data(filename, sheet_name):
    """
    读取指定 Excel 文件中的指定 sheet 的数据
    :param filename: Excel 文件名
    :param sheet_name: sheet 名称
    :return: 数据二维数组
    """
    filepath = BASE_DIR + '/TestData/' + filename
    data = pd.read_excel(filepath, sheet_name=sheet_name).values
    return data

优化后的代码中，将函数名修改为 `read_excel_data`，更明确地表达了函数的作用。将文件路径和文件名拼接的方式改为使用 `/` 进行连接，这样可以在不同的操作系统中都能正确读取文件。另外，可以将 `BASE_DIR` 变量作为参数传入，这样可以让函数更加通用。

读写配置文件

from configparser import ConfigParser


def read_config(file: str):
    """读取配置文件

    :param file: 路径
    :return: 文件对象
    """
    rc = ConfigParser()
    rc.read(file, encoding="utf-8")
    return rc


def write_config(file: str, section, option, value=None):
    """写配置文件

    :param file: 文件路径
    :param section: 节
    :param option: 选项
    :param value: 值
    :return:
    """
    rc = ConfigParser()
    rc.read(file, encoding="utf-8")
    rc.set(section, str(option), str(value))
    with open(file, "w", encoding="utf-8") as f:
        rc.write(f)

以上代码是使用 Python 的 ConfigParser 库来读取和写入配置文件的代码，主要包含两个函数：

- read_config(file): 读取指定路径的配置文件，并返回 ConfigParser 对象。
- write_config(file, section, option, value=None): 写入指定的配置项到指定的配置文件中。

优化封装的建议：

1. 将读取和写入配置文件的函数封装到一个类中，方便调用和维护。
2. 增加参数校验，如检查文件路径是否存在，检查传入的参数是否合法。
3. 增加读取和写入操作的异常处理，如文件不存在、读写出错等情况。
我们开始对以上代码的二次优化封装示例：

import os
from configparser import ConfigParser


class ConfigHelper:
    """配置文件读写助手"""

    def __init__(self, file_path):
        if not os.path.exists(file_path):
            raise FileNotFoundError(f"{file_path} not exist.")
        self._config = ConfigParser()
        self._config.read(file_path, encoding="utf-8")

    def get(self, section, option):
        """获取指定配置项的值

        :param section: 节
        :param option: 选项
        :return: 值
        """
        return self._config.get(section, option)

    def set(self, section, option, value):
        """设置指定配置项的值

        :param section: 节
        :param option: 选项
        :param value: 值
        """
        self._config.set(section, option, value)
        with open(file_path, "w", encoding="utf-8") as f:
            self._config.write(f)

调用示例：

config_helper = ConfigHelper("config.ini")
value = config_helper.get("section_name", "option_name")
config_helper.set("section_name", "option_name", "new_value")

这样的话，使用 ConfigHelper 类来读取和写入配置文件就更加方便和安全了。

读写json文件

import json


# 读取json数据
def get_json(file: str):
    """读取并获取json文件

    :param file: 文件路径
    :return:
    """
    with open(file, "r", encoding="utf-8") as f:
        data_json = json.load(f)
    return data_json
    # jsonData = json.load(f)
    # data_list = list()
    # for data in jsonData.values():
    #     data_list.append(data)
    # return data_list


def write_json(file, data):
    """写入json文件

    :param file: 文件路径
    :param data:需要传入的数据
    :return:
    """

    with open(file, "w", encoding="utf-8") as f:
        json.dump(data, f, indent=2, ensure_ascii=False)  # 写为多行

以上代码主要实现了读取和写入 JSON 文件的功能。

代码解析：

1. `get_json` 函数中，使用 `with` 语句打开文件，读取 JSON 数据，并使用 `json.load` 方法将 JSON 数据转换为 Python 对象，最后返回 Python 对象。该方法使用了类型注释，增强了代码的可读性。

2. `write_json` 函数中，使用 `with` 语句打开文件，将 Python 对象转换为 JSON 数据，并使用 `json.dump` 方法将 JSON 数据写入文件，`indent` 参数指定 JSON 数据的缩进，`ensure_ascii` 参数指定是否对非 ASCII 字符进行编码。该方法使用了类型注释，增强了代码的可读性。
对以上代码优化建议：

1. 函数名建议使用动词开头，表示该函数的功能，例如将 `get_json` 改为 `load_json`，将 `write_json` 改为 `dump_json`。

2. 可以将文件编码方式作为参数传入函数，增加函数的灵活性。

3. 可以在函数中添加异常处理，增加函数的健壮性。

我们开始对以上代码的二次优化封装：

import json


def load_json(file_path: str, encoding: str = "utf-8") -> dict:
    """加载 JSON 文件

    :param file_path: 文件路径
    :param encoding: 文件编码方式，默认为 utf-8
    :return: 返回 Python 对象
    """
    with open(file_path, "r", encoding=encoding) as f:
        data = json.load(f)
    return data


def dump_json(file_path: str, data: dict, encoding: str = "utf-8") -> None:
    """将 Python 对象写入 JSON 文件

    :param file_path: 文件路径
    :param data: 需要写入的 Python 对象
    :param encoding: 文件编码方式，默认为 utf-8
    :return: None
    """
    with open(file_path, "w", encoding=encoding) as f:
        json.dump(data, f, indent=2, ensure_ascii=False)


# 添加异常处理的代码
def safe_load_json(file_path: str, encoding: str = "utf-8") -> dict:
    """安全加载 JSON 文件

    :param file_path: 文件路径
    :param encoding: 文件编码方式，默认为 utf-8
    :return: 返回 Python 对象
    """
    try:
        with open(file_path, "r", encoding=encoding) as f:
            data = json.load(f)
    except FileNotFoundError:
        print(f"{file_path} 文件不存在")
        data = {}
    except json.JSONDecodeError:
        print(f"{file_path} 文件格式错误")
        data = {}
    return data


def safe_dump_json(file_path: str, data: dict, encoding: str = "utf-8") -> bool:
    """安全将 Python 对象写入 JSON 文件

    :param file_path: 文件路径
    :param data: 需要写入的 Python 对象
    :param encoding: 文件编码方式，默认为 utf-8
    :return: 返回写入是否成功
    """
    try:
        with open(file_path, "w", encoding=encoding) as f:
            json.dump(data, f, indent=2, ensure_ascii=False)
        return True
    except Exception as e:
        print(f"写入文件 {file_path} 失败，原因：{e}")
        return False

以上优化封装的代码中，我们增加了函数的健壮性和可读性，使代码更加易于维护和扩展。

import yaml

from glo import BASE_DIR


def yamlconfig(name):
"""配置一个自定义名称的yaml文件"""
    with open(BASE_DIR + '/TestData/' + name + '.yaml', 'rb') as f:
        data = yaml.load(f, Loader=yaml.FullLoader)
    name1 = data.get(name)
    return name1
    # print(name1)


# print(yamlconfig("flag"))
def write_yaml(name, data):
"""写入数据到一个自定义名称的yaml文件中"""
    with open(BASE_DIR + '/TestData/' + name + '.yaml', "w", encoding="utf-8") as f:
        f.write("flag: " + data)

def read_yaml(name):
"""读取数据，从一个自定义名称的yaml文件中"""
    with open(BASE_DIR + r'/TestData/' + name + '.yaml', 'rb') as f:
        data = yaml.load(f, Loader=yaml.FullLoader)
    name1 = data.get('flag')
    return name1


def yamltoken():
"""从token.yaml文件中获取token"""
    with open(BASE_DIR + r'/TestData/token.yaml', 'rb') as f:
        data = yaml.load(f, Loader=yaml.FullLoader)
    name1 = data.get('token')
    return name1
    # print(name1)

# yamltoken()

以上代码主要是对 yaml 文件的读写进行封装，包括读取 yaml 文件中的配置信息和写入数据到指定的 yaml 文件中。以下是对代码进行解析并优化封装的建议：

1. 建议对函数进行注释说明，以方便其他开发人员理解代码的意图和实现方式；
2. 在读取 yaml 文件时，可以添加异常捕获，如果出现异常可以返回默认值或者抛出异常；
3. 在写入 yaml 文件时，可以将数据以字典的形式传入，这样可以更方便地对数据进行操作；
4. 在代码中，可以将 yaml 文件的路径作为参数传入，这样可以使代码更加通用。

基于以上建议，可以对代码进行如下优化和封装：

import yaml

def read_yaml(file_path, default_value=None):
    """
    读取 yaml 配置文件
    :param file_path: 文件路径
    :param default_value: 默认值，当读取文件失败时返回该值，默认为 None
    :return: yaml 文件中的配置信息，以字典形式返回
    """
    try:
        with open(file_path, 'rb') as f:
            data = yaml.load(f, Loader=yaml.FullLoader)
        return data
    except Exception as e:
        print(f"读取文件 {file_path} 失败，错误信息为：{e}")
        return default_value

def write_yaml(file_path, data):
    """
    将数据写入 yaml 文件
    :param file_path: 文件路径
    :param data: 要写入文件的数据，以字典形式传入
    """
    try:
        with open(file_path, "w", encoding="utf-8") as f:
            yaml.dump(data, f, default_flow_style=False, allow_unicode=True)
    except Exception as e:
        print(f"写入文件 {file_path} 失败，错误信息为：{e}")

调用示例：

# 读取 yaml 文件
data = read_yaml("test.yaml", default_value={})
print(data)

# 写入 yaml 文件
data = {"name": "张三", "age": 20}
write_yaml("test.yaml", data)

这样可以更加方便地读取和写入 yaml 文件，并且可以更加灵活地处理异常情况。

以下代码是glo.py,该.py文件定义了系统全路径

"""
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time:2022/12/8 9:24
# @Author:SzetoZeZe
# @File:File_base.py
# @Update:
# @Update:系统全路径（即绝对路径）+需加上自己编写的存放文件路径地址（即相对路径）
"""
import os
from typing import Union

BASE_DIR: Union[bytes, str] = os.path.dirname(os.path.abspath(__file__))

一.读取文件（获取文件）

"""
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time:2023/1/30 16:54
# @Author:SzetoZeZe
# @File:read_filename.py
# @Update:
# @Explain：读取**文件数据内容
"""

import logging
import os
import json
import yaml
import pandas as pd
from Global.Base_setting_info.File_base import BASE_DIR


# 读取json数据
def get_json(file):
    """读取并获取json数据

    :param file: 存放路径
    :return: json数据
    """
    try:
        with open(file, "r", encoding="utf-8") as f:
            data = json.load(f)
        return data
    except NameError:
        raise NameError(f'读取json数据失败,文件路径信息:{file}')


def get_yaml_token():
    """
    获取token.yaml文件中的token
    """
    with open(BASE_DIR + r'/TestData/token.yaml', 'rb') as f:
        data = yaml.load(f, Loader=yaml.FullLoader)
    token_name = data.get('token')
    return token_name


def get_custom_yaml(name):
    """
    读取自定义名称的yaml文件
    """
    with open(BASE_DIR + r'/TestData/' + name + '.yaml', 'rb') as f:
        data = yaml.load(f, Loader=yaml.FullLoader)
    get_name = data.get('flag')
    return get_name

def get_custom_xlsx(file_name,sheet):
    """
    读取自定义名称的xlsx文件中的数据
    :param file_name: 文件名
    :param sheet: **.xlsx文件中的sheet页数
    :return:
    """
    df = pd.read_excel(BASE_DIR + rf'/TestData/{file_name}.xlsx', sheet_name=sheet)
    # df = pd.read_excel(r'TestData/example.xlsx', sheet_name=sheet)     #直接copy   example.xlsx的相对路径
    xlsx_data = df.values
    # print(data)
    return xlsx_data

def get_txt(file: str) -> list:
    """读取txt文件的数据

    :param file: 文件路径
    :return: 数据列表
    """
    logging.info(f"数据文件路径：{os.path.abspath(file)}")
    data = []
    with open(file, 'r', encoding="utf-8") as f:
        for line in f:
            # 去除注释行
            if line[0] == '#':
                continue
            # 去除换行符
            if line[-1] == '\n':
                line = line[:-1]
            # 去除空行
            if line.strip() == "":
                continue
            data.append(line.split("|"))

    return data


if __name__ == '__main__':
    L = get_txt(BASE_DIR + r"/Test_Data/stock_ts_code.txt")
    print(L)

以上代码主要实现了读取 json、yaml、txt、xlsx 文件中的数据。可以对其进行如下优化和封装：

1. 日志模块应该独立出来，不应该在读取数据的函数中使用。应该在调用读取数据函数时，使用 logging 模块记录日志。
2. 应该对读取数据函数进行封装，使其可以根据文件类型自动选择对应的读取方式，而不是手动指定文件类型。
3. 应该将读取数据函数放到一个单独的模块中，方便其他模块调用。

import json
import os
import logging
import yaml
import pandas as pd


def read_file(file_path: str):
    """读取数据文件

    :param file_path: 文件路径
    :return: 数据列表
    """
    file_type = os.path.splitext(file_path)[-1]
    if file_type == ".json":
        return read_json(file_path)
    elif file_type == ".yaml" or file_type == ".yml":
        return read_yaml(file_path)
    elif file_type == ".txt":
        return read_txt(file_path)
    elif file_type == ".xlsx" or file_type == ".xls":
        return read_xlsx(file_path)
    else:
        raise ValueError(f"不支持的文件类型:{file_type}")


def read_json(file_path: str):
    """读取json文件

    :param file_path: 文件路径
    :return: json数据
    """
    try:
        with open(file_path, "r", encoding="utf-8") as f:
            data = json.load(f)
        return data
    except NameError:
        raise NameError(f'读取json数据失败,文件路径信息:{file_path}')


def read_yaml(file_path: str):
    """读取yaml文件

    :param file_path: 文件路径
    :return: yaml数据
    """
    try:
        with open(file_path, "r", encoding="utf-8") as f:
            data = yaml.load(f, Loader=yaml.FullLoader)
        return data
    except NameError:
        raise NameError(f'读取yaml数据失败,文件路径信息:{file_path}')


def read_txt(file_path: str):
    """读取txt文件

    :param file_path: 文件路径
    :return: 数据列表
    """
    try:
        with open(file_path, 'r', encoding="utf-8") as f:
            data = []
            for line in f:
                # 去除注释行
                if line[0] == '#':
                    continue
                # 去除换行符
                if line[-1] == '\n':
                    line = line[:-1]
                # 去除空行
                if line.strip() == "":
                    continue
                data.append(line.split("|"))
        return data
    except NameError:
        raise NameError(f'读取txt数据失败,文件路径信息:{file_path}')


def read_xlsx(file_path: str, sheet_name: str = None):
    """读取xlsx文件

    :param file_path: 文件路径
    :param sheet_name: sheet名字
    :return: 数据列表
    """
    try:
        df = pd.read_excel(file_path, sheet_name=sheet_name)
        xlsx_data = df.values
        return xlsx_data
    except NameError:
        raise NameError(f'读取xlsx数据失败,文件路径信息:{file_path}')


if __name__ == '__main__':
    # 设置日志模块
    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
    # 测试读取数据
    data = read_file("example.json")
    logging.info(f"读取到数据: {data}")

根据优化建议我们这样可以更方便地调用读取数据函数，并且在新增文件类型时，只需要在 `read_file` 函数中添加对应的文件类型处理即可。

二.写入某内容到文件中

"""
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time:2023/2/8 17:04
# @Author:SzetoZeZe
# @File:write_filename.py
# @Update:
# @Explain：写入内容到文件中
"""
import json

from Global.Base_setting_info.File_base import BASE_DIR
from pandas.tests.io.excel.test_xlrd import xlrd
from xlutils.copy import copy


def write_token_yaml(file_name, Result_content):
    """写入token到yaml文件中

    :param file_name:写入文件名字
    :param Result_content:结果内容
    :return:
    """
    try:
        with open(BASE_DIR + "/" + file_name + ".yaml", 'w') as file:
            file.write("token: " + Result_content)
    except ValueError:
        raise ValueError('写入文件内容失败/Description Failed to write the file content')


def write_json(file, data):
    """写入json文件

    :param file: 文件路径
    :param data:需要传入的数据
    :return:
    """

    with open(file, "w", encoding="utf-8") as f:
        json.dump(data, f, indent=2, ensure_ascii=False)  # 写为多行


def write_yaml(name, data):
    """写入到自定义名称的yaml文件"""
    with open(BASE_DIR + '/TestData/' + name + '.yaml', "w", encoding="utf-8") as f:
        f.write("flag: " + data)


def write_xlsx(file_name,sheet, row, rank, data):
    """写入xlsx
    :param file_name:文件名
    :param sheet: 获取表单sheet名称
    :param row: 列
    :param rank: 行
    :param data: 写入的data数据
    :return:
    """
    rb = xlrd.open_workbook(BASE_DIR + rf'/TestData/{file_name}.xlsx')  # 打开weng.xls文件
    wb = copy(rb)  # 利用xlutils.copy下的copy函数复制
    ws = wb.get_sheet(sheet)  # 获取表单
    ws.write(row, rank, data)  # 改变（0,0）的值
    wb.save(BASE_DIR + rf'/TestData/{file_name}.xlsx')

以上这段代码主要是实现了写入文件的操作，包括写入 token 到 yaml 文件、写入 json 文件、写入 yaml 文件和写入 xlsx 文件。代码比较简单，可以通过调用相应的 Python 库实现文件操作。

这里的优化思路主要是封装函数，提高代码的可复用性和可维护性。以下是对每个函数的优化封装：

1. `write_token_yaml()`: 函数名建议改为 `write_yaml_token()`，参数建议增加 `file_path` 参数，将文件路径作为参数传入，而不是写死在函数内部。另外，函数中的写入操作可以使用 PyYAML 库实现，这样可以更方便地写入 YAML 文件，具体实现可以参考以下代码：

import yaml

def write_yaml_token(file_path, token):
    """将 token 写入 YAML 文件中"""
    with open(file_path, 'w') as f:
        yaml.dump({'token': token}, f)

2. `write_json()`: 函数名建议改为 `write_to_json()`，参数建议增加 `file_path` 参数，将文件路径作为参数传入，而不是写死在函数内部。另外，函数中的写入操作可以直接使用 `json.dump()` 函数实现，这样可以更简洁地写入 JSON 文件，具体实现可以参考以下代码：

3. `write_yaml()`: 函数名建议改为 `write_to_yaml()`，参数建议增加 `file_path` 参数，将文件路径作为参数传入，而不是写死在函数内部。另外，函数中的写入操作可以使用 PyYAML 库实现，这样可以更方便地写入 YAML 文件，具体实现可以参考以下代码：

import yaml

def write_to_yaml(file_path, data):
    """将数据写入 YAML 文件中"""
    with open(file_path, 'w') as f:
        yaml.dump(data, f)

4. `write_xlsx()`: 函数名建议改为 `write_to_xlsx()`，参数建议增加 `file_path` 参数，将文件路径作为参数传入，而不是写死在函数内部。另外，函数中的写入操作可以使用 openpyxl 库实现，这样可以更方便地写入 Excel 文件，具体实现可以参考以下代码：

from openpyxl import load_workbook

def write_to_xlsx(file_path, sheet_name, row, column, data):
    """将数据写入 Excel 文件中"""
    wb = load_workbook(file_path)
    sheet = wb[sheet_name]
    sheet.cell(row=row, column=column, value=data)
    wb.save(file_path)

通过对函数的优化封装，可以提高代码的可复用性和可维护性，方便代码的调用和维护。

三.创建一个自定义文件

"""
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time:2023/2/9 9:41
# @Author:SzetoZeZe
# @File:create_filenname.py
# @Update:
# @Explain：创建一个自定义文件名
"""
import yaml

from Global.Base_setting_info.File_base import BASE_DIR


def create_yaml_config(name):
    """
    配置一个自定义名称的yaml文件
    """
    with open(BASE_DIR + '/TestData/' + name + '.yaml', 'rb') as f:
        data = yaml.load(f, Loader=yaml.FullLoader)
    create_name = data.get(name)
    return create_name

以上代码的作用是从指定的 YAML 文件中读取数据，并将指定名称的数据返回。

import os
import yaml

def load_yaml_file(file_path):
    """
    从指定路径的 YAML 文件中读取数据
    """
    with open(file_path, 'r', encoding='utf-8') as f:
        data = yaml.safe_load(f)
    return data

def get_yaml_data(file_path, name):
    """
    从指定路径的 YAML 文件中获取指定名称的数据
    """
    data = load_yaml_file(file_path)
    return data.get(name)

def create_yaml_config(name):
    """
    从默认路径的 YAML 文件中获取指定名称的数据
    """
    file_path = os.path.join(os.getcwd(), 'TestData', f'{name}.yaml')
    return get_yaml_data(file_path, name)

这里对原有代码进行了以下优化：

1. 使用 `os.path` 而不是字符串拼接来构建文件路径，可以提高代码的可移植性；
2. 使用 `yaml.safe_load` 而不是 `yaml.load` 来加载 YAML 文件，可以提高安全性；
3. 将读取 YAML 文件的功能封装为一个函数 `load_yaml_file`，可以提高代码的复用性；
4. 将获取指定名称数据的功能封装为一个函数 `get_yaml_data`，可以提高代码的可读性；
5. 将默认路径硬编码改为使用 `os.getcwd()` 获取当前工作路径，可以提高代码的可维护性。