python3 实现读写文件（xlsx文件/ini文件/json文件/yaml文件），代码已封装更新
实现向指定的 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()` 获取当前工作路径，可以提高代码的可维护性。