本程序用于Ni基牌号调料程序

较严重的错误会覆盖次严重的错误，错误严重级别由大到小排序：

存在元素超过标准范围>

超过3种元素不在目标范围内>

调料后，存在元素超出标准范围>

调料后，存在元素超出一般范围>

调料后，存在元素超出目标范围>

调料后，存在元素超出炉前补加时参考配入上限>

补加重量过多（超过100kg）

两个安全系数分别为0.8和0.9

import glob
import os
import pandas as pd
import logging
from tkinter import *
from tkinter import simpledialog, messagebox
import datetime
import sys
from scipy.optimize import fsolve
import numpy as np

这里防止pd更新时启用旧功能，导致函数无法运行

pd.set_option('future.no_silent_downcasting', True)

初始化全局变量

TOTAL_WEIGHT = 0.0
DF_RANGE_REQUIREMENTS = None
FOLDER_PATH = os.path.dirname(os.path.abspath(file))

获取当前脚本或者程序所在的根目录（在打包的EXE中运行时也有效）

if getattr(sys, 'frozen', False):
application_path = os.path.dirname(sys.executable)
else:
application_path = os.path.dirname(os.path.abspath(file))

创造Ni基合金中的文件配置

Ni_BASED_ALLOY_CONFIGS = {
"XB-407M2": {
"folder": "XB-407M2调料文件",
"log_file": "XB-407M2调料日志.txt"
},
"HT700R": {
"folder": "HT700R调料文件",
"log_file": "HT700R调料日志.txt"
}
}

这里设置日志文件的保存路径函数，文件夹和文件名为形参，后续需要传递实参，使用str()确保路径为字符

def setup_logging(folder_path, log_file_name):
log_file_path = os.path.join(str(folder_path), str(log_file_name))
logging.basicConfig(filename=log_file_path, level=logging.INFO, format='%(message)s')
with open(log_file_path, 'a') as log_file:
log_file.write('\n')

def setup_paths(alloy_name):
config = Ni_BASED_ALLOY_CONFIGS[alloy_name] # 这里输入alloy_name可以定位到字典的子字典
condiments_folder = os.path.join(application_path, config['folder'])
global DF_RANGE_REQUIREMENTS, FOLDER_PATH
xlsx_files = glob.glob(os.path.join(str(condiments_folder), '*.xlsx'))
if xlsx_files:
DF_RANGE_REQUIREMENTS = xlsx_files[0] # 取第一个找到的 .xlsx 文件，是成分页文件，位于调料文件中
FOLDER_PATH = os.path.join(str(condiments_folder), '测试结果') # 这里找到日志保存路径，并启动日志记录
setup_logging(FOLDER_PATH, config['log_file'])

def alloy_weight_input(alloy_name):
global TOTAL_WEIGHT
alloy_weight_value = simpledialog.askfloat(f"{alloy_name}钢液重量", f"坩埚中的{alloy_name}钢液重量约为（单位：kg）：",
initialvalue=True)
TOTAL_WEIGHT = alloy_weight_value
setup_paths(alloy_name)
# 运行setup_paths函数后，已经将DF_RANGE_REQUIREMENTS = xlsx_files[0]，即成分页位置得到更新
# 同时，已经将FOLDER_PATH = os.path.join(str(condiments_folder), '测试结果')，即测试页位置得到更新
main_process() # 在main_process函数中可以运行更新后的DF_RANGE_REQUIREMENTS和FOLDER_PATH
messagebox.showinfo("提示", f"{alloy_name}调料程序运行完毕，请在调料日志中查看详情。")

def main_process():
file_paths = find_xlsx_files(FOLDER_PATH) # 首先找到测试结果位置
for file_path in file_paths: # 将测试结果输入到加工函数中，进行加工
df_results = process_test_results(file_path)
df_merge = merge_data(DF_RANGE_REQUIREMENTS, df_results) # 将测试结果和成分页进行合并
alerts = check_element_ranges(df_merge)
handle_alerts(alerts, df_merge)

初始化GUI

root = Tk()
root.title('调料程序')

动态创建按钮

for i, alloy in enumerate(Ni_BASED_ALLOY_CONFIGS.keys()):
button = Button(root, text=f'{alloy}调料计算', command=lambda a=alloy: alloy_weight_input(a), height=1, width=15)
button.grid(row=0, column=i, padx=10, pady=10)

def find_xlsx_files(folder_path): # 定义1个函数，获取测试结果文件地址，这里小写的folder_path只是形参，需要在主函数中用FOLDER_PATH代替
search_path = os.path.join(folder_path, '*.xlsx')
file_paths = glob.glob(search_path)
return file_paths

file_paths虽然是列表形式，但是加入函数for file_path in find_xlsx_files(FOLDER_PATH):

print(file_path)，其中的file_path就是列表中的1个元素了，此时1个元素不以列表形式展示

def process_test_results(file_path): # 定义1个函数，可以对测试结果进行提取加工，将其格式和成分页模板对齐
try:
df_test_results = pd.read_excel(file_path)
df_results = df_test_results.iloc[9:25, [0, 3]].replace('<', '', regex=True) # 注意替换函数中的字符时，一定要将regex=True加上
df_results.columns = ['元素', '测试结果']
df_results['测试结果'] = pd.to_numeric(df_results['测试结果'], errors='coerce') # 将测试结果转换为数字形式
df_results.reset_index(drop=True, inplace=True) # 重置索引
return df_results
except Exception as e:
logging.error(f'Error processing file {file_path}: {e}')
return pd.DataFrame()

def merge_data(requirements_file, df_results): # 定义读取数据，合并数据的函数，将成分页模板和提取的测试结果合并输出
df_range_requirements = pd.read_excel(requirements_file)
df_merge = pd.merge(df_range_requirements, df_results, on='元素', how='left')
# on属性用于寻找共同列，left属性表示左连接，返回左侧DataFrame的所有键，以及它们在右侧DataFrame中的匹配（如果存在）。
return df_merge

def check_element_ranges(df_merge): # 定义报警函数，用于监控是否存在元素超限，df_merge是融合了成分页和检测结果的全面数据
alerts = []
standard_range_issues_plus = 0
standard_range_issues_sub = 0
general_range_issues_plus = 0
general_range_issues_sub = 0
target_range_issues_plus = 0
target_range_issues_sub = 0
# 这里需要使用逐行检测的方式，用于确定每种超限的类型，并逐行给出警报
for index, row in df_merge.iterrows():
element = row['元素']
test_result = row['测试结果']
range_row = df_merge[df_merge['元素'] == element].iloc[0]

text
    if test_result < range_row['标准范围下限']:  # 这里需要注意if和elif并列和if和if并列的情况区别，前者是只能满足1个条件执行，后者可以同时满足同时执行多个条件
        alerts.append(f"警报：元素{element}<标准范围。")
        standard_range_issues_sub += 1

    elif test_result > range_row['标准范围上限']:
        alerts.append(f"警报：元素{element}>标准范围。")
        standard_range_issues_plus += 1

    elif test_result < range_row['一般范围下限']:
        alerts.append(f"注意：元素{element}<一般范围。")
        general_range_issues_sub += 1

    elif test_result > range_row['一般范围上限']:
        alerts.append(f"注意：元素{element}>一般范围。")
        general_range_issues_plus += 1

    elif test_result < range_row['目标范围下限']:
        alerts.append(f"注意：元素{element}<目标范围。")
        target_range_issues_sub += 1

    elif test_result > range_row['目标范围上限']:
        alerts.append(f"注意：元素{element}>目标范围。")
        target_range_issues_plus += 1

if standard_range_issues_sub + standard_range_issues_plus > 0:
    alerts.append("警报：存在元素超过标准范围，请联系牌号负责人进行调料。")

elif general_range_issues_sub + general_range_issues_plus + target_range_issues_sub + target_range_issues_plus > 3:
    alerts.append("警报：超过3种元素不在目标范围内，请联系牌号负责人进行调料。")

else:
    alerts.append("注意：元素检测结果处于正常波动水平，请按照程序调料。")
return alerts

这里是验算函数，用于验算加入物料后，实际成分和名义成分是否符合要求

def check_element_ranges_after_addition(df_check): # 这里的df_check文件是融合了问题元素和正常元素以及所有补加情况的文件
file_path = os.path.join(FOLDER_PATH, '调料后各元素变化情况.xlsx') # 无论如何，在检查之前先将check文件保存
df_check.round(4).to_excel(file_path, index=False)
alerts2 = []
standard_range_issues = 0
general_range_issues = 0
target_range_issues = 0
addition_lim_issues = 0
for index, row in df_check.iterrows():
element = row['元素']
future_result = row['补加后元素实际含量']
future_result_name = row['补加后元素名义含量']
range_row = df_check[df_check['元素'] == element].iloc[0]
if future_result < range_row['标准范围下限'] or future_result > range_row['标准范围上限']:
alerts2.append(f"警报：调料后，元素{element}超出标准范围。")
standard_range_issues += 1
elif future_result < range_row['一般范围下限'] or future_result > range_row['一般范围上限']:
alerts2.append(f"警报：调料后，元素{element}超出一般范围。")
general_range_issues += 1
elif future_result < range_row['目标范围下限'] or future_result > range_row['目标范围上限']:
alerts2.append(f"警报：调料后，元素{element}超出目标范围。")
target_range_issues += 1
elif future_result_name > range_row['炉前补加时参考配入上限']:
alerts2.append(f"警报：调料后，元素{element}超出炉前补加时参考配入上限。")
addition_lim_issues += 1
if standard_range_issues > 0:
alerts2.append("警报：调料后，存在元素超过标准范围，请联系牌号负责人进行调料。")
elif general_range_issues > 0:
alerts2.append("警报：调料后，存在元素超过一般范围，请联系牌号负责人进行调料。")
elif target_range_issues > 0:
alerts2.append("警报：调料后，存在元素超过目标范围，请联系牌号负责人进行调料。")
elif addition_lim_issues > 0:
alerts2.append("警报：调料后，存在元素超过炉前补加时参考配入上限，请联系牌号负责人进行调料。")
else:
alerts2.append("注意：调料后，元素均在目标范围，请按照程序调料。")
return alerts2

def calculate_additions_sub(df_merge):
# 补加料存在安全系数，相对条件严格，需要补加的料更多，但是检查函数只是按照目标范围检查，相当于条件更宽松。如果按照安全系数来检查，有可能造成条件过于严格，处于无限迭代之中。
# 此时可以将没有通过检查的调料后各元素变化情况的‘补加后元素实际含量’假设为下次‘测试结果’，重新迭代，最终产生的结果只需要满足检查函数即可，而不是这里的安全范围，相当于条件更宽松了。
# 最后将两次结果的补加情况相加即可。
# 在sub情况中也引入元素安全范围的概念，选择出不安全的元素进行补加，安全系数为0.8
df_element_low = df_merge[(df_merge['目标值'] - df_merge['测试结果']) / df_merge['目标值'] >
(df_merge['目标值'] - df_merge['目标范围下限']) / df_merge['目标值'] * 0.8].copy()
# 从DataFrame中提取测试值、目标值和元素名，通过to_numpy()函数将数值转换为numpy数组，可以提高运行速度
test_values = df_element_low['测试结果'].to_numpy()
target_values = df_element_low['炉前参考补加目标'].to_numpy()

text
# 定义方程组，用来N元1次解方程，方程中的补加重量本质上是未知的变量，所有可以用vars代替N多个补加元素的补加重量
def solve_equations(vars):
    total = TOTAL_WEIGHT + np.sum(vars)
    equations = []  # 初始化一个空列表，用来存储方程组
    for test_value, target_value, var in zip(test_values, target_values, vars):
        # 使用 zip 函数将 test_values, target_values, vars 各元素一一对应起来，并迭代生成方程组。每个元素的测试值、目标值和变量（补加量）被同时处理和运算。
        equation = (test_value * TOTAL_WEIGHT / 100 + var) / total - target_value / 100
        # 这里建立equation方程式，本质上是要求equation=0时的var值，并且将不同的var值都添加在equations空列表中
        equations.append(equation)
    return equations

# 初始猜测，设置初始猜测值，假设每种元素的初始补加量为10kg，然后通过迭代方式求解方程组。
initial_guess = np.full(len(test_values), 10)  # 假设每种元素的初始补加量为10kg
solutions, infodict, ier, mesg = fsolve(solve_equations, initial_guess, full_output=True)
# 将解添加到DataFrame中
df_element_low['补加重量'] = solutions
# 计算补加后的实际含量，由于求解过程中均是以numpy数组形式储存数字，所以可以用np.sum求和
addition_weight = np.sum(solutions)
df_element_low['补加后元素实际含量'] = (df_element_low['测试结果'] * TOTAL_WEIGHT / 100 + df_element_low[
    '补加重量']) / (TOTAL_WEIGHT + addition_weight) * 100
df_element_low['补加后元素名义含量'] = (df_element_low['目标值'] * TOTAL_WEIGHT / 100 + df_element_low[
    '补加重量']) / (TOTAL_WEIGHT + addition_weight) * 100
df_merge['补加重量'] = 0.0
df_merge['补加后元素实际含量'] = df_merge['测试结果'] * TOTAL_WEIGHT / (
            addition_weight + TOTAL_WEIGHT)  # 计算补加之后其余元素的实际含量
df_merge['补加后元素名义含量'] = df_merge['目标值'] * TOTAL_WEIGHT / (
            addition_weight + TOTAL_WEIGHT)  # 计算补加之后其余元素的名义含量
df_merge.update(df_element_low)
# 这里不能将此操作赋值给新的变量，不然会报错，直接在df_merge基础上进行覆盖操作
df_check = df_merge
df_element_problem = df_element_low
return df_check, df_element_problem

def calculate_additions_plus(df_merge): # 这里是3种元素全都超过目标范围上限的情况
df_element_problem = df_merge[df_merge['测试结果'] > df_merge['目标范围上限']].copy() # 先将超过目标范围上限的元素挑出
needed_addition = df_element_problem['测试结果'] * TOTAL_WEIGHT / df_element_problem[
'炉前参考降低目标'] - TOTAL_WEIGHT
addition_weight = needed_addition.iloc[:].max() # 补加重量为降低超限元素时需要的最大重量

text
# addition_weight算出后，基本可以确定merge数据结构中的各元素实际和名义产量
df_merge['补加重量'] = 0.0
df_merge['补加后元素实际含量'] = df_merge['测试结果'] * TOTAL_WEIGHT / (
            addition_weight + TOTAL_WEIGHT)  # 计算补加之后其余元素的实际含量
df_merge['补加后元素名义含量'] = df_merge['目标值'] * TOTAL_WEIGHT / (
            addition_weight + TOTAL_WEIGHT)  # 计算补加之后其余元素的名义含量
# 这里的df_merge计算中包括了全部元素，但是由于Ni或者Fe在后续可能需要补加，所以这里的Ni或者Fe算法结果不代表最终结果，需要在最后重新计算

# 后续计算补加元素加入后，元素实际含量是否变低到安全范围外，如果变低到安全范围外，则需要补加
# 这里肯定不包括超限元素，因为补加后，超限元素变为目标降低值，高于目标值
df_element_low = df_merge[(df_merge['目标值'] - df_merge['补加后元素实际含量']) / df_merge['目标值'] >
                          (df_merge['目标值'] - df_merge['目标范围下限']) / df_merge['目标值'] * 0.9].copy()
# (df_merge['目标值'] - df_merge['目标范围下限']) / df_merge['目标值'] * 0.9计算出目标值安全波动范围
# 其中0.9代表安全系数，指代补加后元素实际含量处于目标范围的90%内才安全，否则就需要补加
# (df_merge['目标值'] - df_merge['补加后元素实际含量']) / df_merge['目标值']计算出补加后元素实际含量变化范围，如果>80%则超出安全范围就需要补加

# 建立补加元素阵列后，首先初始化df_element_low，补全数据结构
df_element_low['补加重量'] = 0.0
df_element_low['补加后元素实际含量'] = 0
df_element_low['补加后元素名义含量'] = 0

# 之后开始填充数据结构
df_element_low['补加重量'] = (TOTAL_WEIGHT + addition_weight) * df_element_low[
    '炉前参考补加目标'] / 100 - TOTAL_WEIGHT * df_element_low['测试结果'] / 100

if addition_weight > df_element_low['补加重量'].sum():
    if 'Ni' in df_element_low['元素'].values[0]:
        df_element_low.loc[df_element_low['元素'] == 'Ni', '补加重量'] += addition_weight - df_element_low[
            '补加重量'].sum()
    elif 'Ni' not in df_element_low['元素'].values[0]:
        df_merge.loc[df_merge['元素'] == 'Ni', '补加重量'] = addition_weight - df_element_low['补加重量'].sum()
# 无论如何，在这种情况下，至少保证了加进去足够多的元素重量，让超限元素降下来了；当补加重量过多，超过了降限元素量后，其本身补加量是按照加上降限补加量来算的，
# 所以此时补加量更多后，导致元素含量更少，补充不到炉前参考补加目标了，具体补充到多少，还需要看具体的偏离程度，如果可以通过检查，就不需要再补加
elif addition_weight <= df_element_low['补加重量'].sum():
    df_element_low['补加重量'] = df_element_low['补加重量']

df_element_low['补加后元素实际含量'] = (df_element_low['测试结果'] / 100 * TOTAL_WEIGHT + df_element_low[
    '补加重量']) / (addition_weight + TOTAL_WEIGHT) * 100
df_element_low['补加后元素名义含量'] = (df_element_low['目标值'] / 100 * TOTAL_WEIGHT + df_element_low[
    '补加重量']) / (addition_weight + TOTAL_WEIGHT) * 100
# 必须添加df_merge的实际含量运算和名义含量运算，用来计算当Ni或者Fe不在df_element_low数据中的情况，此时df_merge中的Ni或者Fe元素是正确的算法
# 注意，当Ni或者Fe不在df_element_low中时，元素就必然在df_merge中，这时候就需要重新计算df_merge中的Ni的元素实际含量和元素名义含量
# 用来匹配上述的df_merge.loc[df_merge['元素'] == 'Ni', '补加重量'] = addition_weight - df_element_low['补加重量'].sum()的更新
df_merge['补加后元素实际含量'] = (df_merge['测试结果'] / 100 * TOTAL_WEIGHT + df_merge[
    '补加重量']) / (addition_weight + TOTAL_WEIGHT) * 100
df_merge['补加后元素名义含量'] = (df_merge['目标值'] / 100 * TOTAL_WEIGHT + df_merge[
    '补加重量']) / (addition_weight + TOTAL_WEIGHT) * 100

df_merge.update(df_element_low)
df_check = df_merge
df_element_problem = df_element_low
return df_check, df_element_problem

def calculate_additions_plus_sub(df_merge):
df_element_problem_sub = df_merge[df_merge['测试结果'] < df_merge['目标范围下限']].copy()
df_element_problem_plus = df_merge[df_merge['测试结果'] > df_merge['目标范围上限']].copy()

text
# 首先计算需要将缺少元素补加到目标的重量
test_values = df_element_problem_sub['测试结果'].to_numpy()
target_values = df_element_problem_sub['炉前参考补加目标'].to_numpy()

# 定义方程组，用来N元1次解方程，方程中的补加重量本质上是未知的变量，所有可以用vars代替N多个补加元素的补加重量
def solve_equations(vars):
    total = TOTAL_WEIGHT + np.sum(vars)
    equations = []  # 初始化一个空列表，用来存储方程组
    for test_value, target_value, var in zip(test_values, target_values, vars):
        # 使用 zip 函数将 test_values, target_values, vars 各元素一一对应起来，并迭代生成方程组。每个元素的测试值、目标值和变量（补加量）被同时处理和运算。
        equation = (test_value * TOTAL_WEIGHT / 100 + var) / total - target_value / 100
        # 这里建立equation方程式，本质上是要求equation=0时的var值，并且将不同的var值都添加在equations空列表中
        equations.append(equation)
    return equations

# 初始猜测，设置初始猜测值，假设每种元素的初始补加量为10kg，然后通过迭代方式求解方程组。
initial_guess = np.full(len(test_values), 10)  # 假设每种元素的初始补加量为10kg
solutions, infodict, ier, mesg = fsolve(solve_equations, initial_guess, full_output=True)
# 将解添加到DataFrame中
df_element_problem_sub['补加重量'] = solutions
# 计算补加后的实际含量，由于求解过程中均是以numpy数组形式储存数字，所以可以用np.sum求和
addition_weight_sub = np.sum(solutions)

# 其次计算需要将多余元素降低时需要补加的重量
needed_addition = df_element_problem_plus['测试结果'] * TOTAL_WEIGHT / df_element_problem_plus[
    '炉前参考降低目标'] - TOTAL_WEIGHT
addition_weight_plus = needed_addition.iloc[:].max()  # 补加重量为降低超限元素时需要的最大重量

if addition_weight_sub >= addition_weight_plus:
    return calculate_additions_sub(df_merge)

elif addition_weight_sub < addition_weight_plus:
    return calculate_additions_plus(df_merge)

def log_alert(alert, level='info'): # 定义警报和信息的区分，如果错误水平是错误，则动用警报，否则是通知
if level == 'error':
logging.error(alert)
else:
logging.info(alert)

这里是将合并数据进行检查的过程

def handle_alerts(alerts, df_merge):
alert_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M')
alert_set = set() # 将警报和通知全都放在一个集合当中
for alert in alerts:
if "警报" in alert:
alert_set.add("警报")
log_alert(alert)
elif "<" in alert:
alert_set.add("<")
log_alert(alert)
elif ">" in alert:
alert_set.add(">")
log_alert(alert)
# 注意集合之中不允许存在同样的两种符号，所以这里可以判断是哪一种超限情况以及严重超限情况

text
if "警报" in alert_set:
    log_alert(alert_time + '调料记录\n' + "警报：检测结果出现异常，请联系牌号负责人进行调料。", 'error')
    messagebox.showwarning("警报", "警报：检测结果出现异常，请联系牌号负责人进行调料。")

if "<" in alert_set and ">" not in alert_set:
    df_check, df_element_problem = calculate_additions_sub(df_merge)
    alerts2 = check_element_ranges_after_addition(df_check)
    for alert2 in alerts2:
        if "警报" in alert2:
            log_alert(alert_time + '调料记录\n' + alert2, 'error')
            text = str(alert2)
            messagebox.showwarning("警报", text)
        else:
            log_alert(alert_time + '调料记录\n' + alert2)
            zero_weight_indices = df_check[df_check['补加重量'] == 0].index  # 删除补加重量为0的所有行
            df_check = df_check.iloc[:, [0, -3]].drop(zero_weight_indices)  # 删除补加重量为0的所有行
            addition_weight = df_check['补加重量'].sum()
            if addition_weight > 100:
                log_alert("警报：补加重量过多（超过100kg），请联系牌号负责人。")
                messagebox.showwarning("警报", "警报：补加重量过多（超过100kg），请联系牌号负责人。")
            elif addition_weight <= 100:
                formatted_text = format_element_additions(df_check)
                log_alert('补加重量如下（单位kg）：\n' + formatted_text)

if ">" in alert_set and "<" not in alert_set:
    df_check, df_element_problem = calculate_additions_plus(df_merge)
    alerts2 = check_element_ranges_after_addition(df_check)
    for alert2 in alerts2:
        if "警报" in alert2:
            log_alert(alert_time + '调料记录\n' + alert2, 'error')
            text = str(alert2)
            messagebox.showwarning("警报", text)
        else:
            log_alert(alert_time + '调料记录\n' + alert2)
            zero_weight_indices = df_check[df_check['补加重量'] == 0].index  # 删除补加重量为0的所有行
            df_check = df_check.iloc[:, [0, -3]].drop(zero_weight_indices)  # 删除补加重量为0的所有行
            addition_weight = df_check['补加重量'].sum()
            if addition_weight > 100:
                log_alert("警报：补加重量过多（超过100kg），请联系牌号负责人。")
                messagebox.showwarning("警报", "警报：补加重量过多（超过100kg），请联系牌号负责人。")
            elif addition_weight <= 100:
                formatted_text = format_element_additions(df_check)
                log_alert('补加重量如下（单位kg）：\n' + formatted_text)

if ">" in alert_set and "<" in alert_set:
    df_check, df_element_problem = calculate_additions_plus_sub(df_merge)
    alerts2 = check_element_ranges_after_addition(df_check)
    for alert2 in alerts2:
        if "警报" in alert2:
            log_alert(alert_time + '调料记录\n' + alert2, 'error')
            text = str(alert2)
            messagebox.showwarning("警报", text)
        else:
            log_alert(alert_time + '调料记录\n' + alert2)
            zero_weight_indices = df_check[df_check['补加重量'] == 0].index  # 删除补加重量为0的所有行
            df_check = df_check.iloc[:, [0, -3]].drop(zero_weight_indices)  # 删除补加重量为0的所有行
            addition_weight = df_check['补加重量'].sum()
            if addition_weight > 100:
                log_alert("警报：补加重量过多（超过100kg），请联系牌号负责人。")
                messagebox.showwarning("警报", "警报：补加重量过多（超过100kg），请联系牌号负责人。")
            elif addition_weight <= 100:
                formatted_text = format_element_additions(df_check)
                log_alert('补加重量如下（单位kg）：\n' + formatted_text)

def format_element_additions(df_check):
return df_check.map(lambda x: f"{x:.4f}" if isinstance(x, float) else str(x)).apply(' '.join, axis=1).to_string(
index=False)

root.mainloop()
这是我的后端代码，如何在前端设计html网页，可以在网页中与后端代码交互，在前端实现后端的一些互动操作的功能。

这种本身py文件设计很多页面交互的代码，是不是不适合使用html进行网页界面交互？有什么好的方案推荐吗

有没有可以不用移植py代码的交互逻辑到html文件上，可以直接在html文件上运行python的程序，展示python的交互，并在html上显示结果

可以在html页面上设计一个按钮，点击后，自动链接到某个本地硬盘的路径的应用程序，将其打开吗，帮我设计一段代码，自动打开"D:\Apps\CCleaner\CCleaner.exe"。