自己电脑由于没有任何杀毒软件，因此运行exe没问题。给别人用时，即使允许本软件操作关闭了360，依然会阻止exe部分代码的运行，请问解决方式
代码如下：
[Python] 纯文本查看 复制代码import os
import tkinter as tk
from tkinter import filedialog, messagebox, ttk
import pandas as pd
import openpyxl
from openpyxl import load_workbook
from openpyxl.utils import get_column_letter, column_index_from_string
from openpyxl.styles import numbers, Font
import io
import base64
import shutil
# 确保中文显示正常
pd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)
class FinancialReportProcessor:
def __init__(self, root):
# 初始化内置数据库
self.db_a = self._initialize_db_a()
self.db_b = self._initialize_db_b()
self.root = root
self.root.title("财务报表处理程序")
self.root.geometry("800x500") # 放大窗口，确保所有内容能直接看到
self.root.resizable(True, True)
# 设置窗口图标为Cecil.png的base64编码
self._set_window_icon()
# 设置样式
self.style = ttk.Style()
self.style.configure("TLabel", font=("SimHei", 10))
self.style.configure("TButton", font=("SimHei", 10))
# 创建主框架
main_frame = ttk.Frame(self.root, padding="20")
main_frame.pack(fill=tk.BOTH, expand=True)
# 标题
title_label = ttk.Label(main_frame, text="财务报表处理程序", font=("SimHei", 16, "bold"))
title_label.pack(pady=10)
# 选择久其报表文件（决算报表和月度快报可以同时选择）
self.report_frame = ttk.LabelFrame(main_frame, text="选择久其报表文件（决算报表和月度快报可以同时选择）", padding="10")
self.report_frame.pack(fill=tk.X, pady=10)
self.report_source_var = tk.StringVar()
report_entry = ttk.Entry(self.report_frame, textvariable=self.report_source_var, width=50)
report_entry.pack(side=tk.LEFT, padx=10, pady=5, fill=tk.X, expand=True)
report_button = ttk.Button(self.report_frame, text="浏览...", command=lambda: self.browse_source(self.report_source_var))
report_button.pack(side=tk.RIGHT, padx=10, pady=5)
# 目标文件夹路径 - 只定义路径，不创建文件夹
self.target_path = os.path.join(os.path.expanduser("~"), "Desktop", "财务报表")
# 进度条框架
progress_frame = ttk.LabelFrame(main_frame, text="处理进度", padding="10")
progress_frame.pack(fill=tk.X, pady=10)
self.progress_label = ttk.Label(progress_frame, text="准备就绪", font=("SimHei", 10))
self.progress_label.pack(pady=5)
self.progress_var = tk.DoubleVar()
self.progress_bar = ttk.Progressbar(progress_frame, variable=self.progress_var, length=500)
self.progress_bar.pack(pady=5)
# 处理按钮
button_frame = ttk.Frame(main_frame)
button_frame.pack(fill=tk.X, pady=20)
process_button = ttk.Button(button_frame, text="开始处理", command=self.process_files, style="Accent.TButton")
process_button.pack(side=tk.RIGHT, padx=10, pady=10)
# 配置自定义按钮样式
self.style.configure("Accent.TButton", foreground="black", background="#4CAF50")
# 添加版权信息
copyright_label = ttk.Label(
main_frame,
text="The Software Copyright is Owned by Weijie Gao in HGMRI.",
font=('SimHei', 10) # 字体比其他字体小
)
copyright_label.pack(side="bottom", anchor="se", padx=20, pady=10)
def browse_source(self, var):
"""浏览并选择Excel文件（支持多选）"""
files = filedialog.askopenfilenames(
title="选择Excel文件",
filetypes=[("Excel文件", "*.xlsx *.xls *.xlsm")]
)
if files:
# 将多个文件路径用分号分隔
var.set("; ".join(files))
def process_files(self):
"""处理选择的文件，根据文件类型分别处理决算报表和月度快报"""
# 在处理文件前，先检查并备份桌面上的财务报表文件夹
# 使用已定义的target_path变量，确保路径一致性
# 如果财务报表文件夹存在，询问用户是否进行备份
if os.path.exists(self.target_path):
# 增加用户确认，减少被杀毒软件误报的可能性
if messagebox.askyesno("备份提示", "检测到桌面上已存在'财务报表'文件夹，是否要备份现有文件夹？"):
# 获取桌面路径，用于构建备份文件夹路径
desktop_path = os.path.dirname(self.target_path)
# 查找合适的备份名称
backup_count = 1
while True:
backup_folder = os.path.join(desktop_path, f"财务报表_备份{backup_count}")
if not os.path.exists(backup_folder):
# 找到可用的备份名称，进行重命名
try:
os.rename(self.target_path, backup_folder)
messagebox.showinfo("备份成功", f"'财务报表'文件夹已成功备份到'{backup_folder}'")
break
except Exception:
# 如果重命名失败，继续尝试下一个编号
backup_count += 1
else:
backup_count += 1
# 确保目标文件夹存在
os.makedirs(self.target_path, exist_ok=True)
total_processed = 0
total_error = 0
# 获取源文件路径（可能包含多个文件，用分号分隔）
report_sources = self.report_source_var.get().split("; ")
# 过滤空字符串
report_sources = [f for f in report_sources if f.strip()]
# 检查是否至少选择了一个源文件
if not report_sources:
messagebox.showerror("错误", "请至少选择一个源文件！")
return
# 使用主界面的进度条
all_files = report_sources
self.progress_var.set(0)
self.progress_label.config(text="正在运行")
self.root.update_idletasks()
# 用于存储A_sub值，以便在生成财务数据表时使用
self.first_a_sub = None
# 处理所有报表文件
for i, file_path in enumerate(report_sources):
try:
file_name = os.path.basename(file_path)
# 更新进度信息
self.progress_var.set((i + 1) / len(all_files) * 100)
self.root.update_idletasks()
# 提取文件名的A_sub、B_sub和C_sub
file_name_without_ext = os.path.splitext(file_name)[0]
name_parts = file_name_without_ext.split()
# 解析文件名部分
if len(name_parts) >= 1:
a_sub = name_parts[0] # 第一个空格前的字符
# 保存第一个文件的A_sub作为财务数据表的前缀
if self.first_a_sub is None:
self.first_a_sub = a_sub
else:
a_sub = file_name_without_ext
if self.first_a_sub is None:
self.first_a_sub = a_sub
if len(name_parts) >= 2:
b_sub = name_parts[1] # 第二个空格前的字符
else:
b_sub = ""
if len(name_parts) >= 3:
c_sub = " ".join(name_parts[2:]) # 剩余的字符
else:
c_sub = file_name_without_ext
# 根据C_sub判断文件类型并处理
if "季" in c_sub: # 决算报表
# 新文件名取C_sub的前5个字符
new_file_name = c_sub[:5] + ".xlsx"
new_file_path = os.path.join(self.target_path, new_file_name)
# 复制工作表 - 决算报表
self.copy_sheets(file_path, new_file_path, ["Z01 资产负债表", "Z02 利润表", "Z03 现金流量表",
"Z20 成本费用情况表", "Z21 成本费用情况表",
"FXZB 主要分析指标表（计算机自动生成）"])
elif "月" in c_sub: # 月度快报
# 新文件名直接使用C_sub
new_file_name = c_sub + ".xlsx"
new_file_path = os.path.join(self.target_path, new_file_name)
# 复制工作表 - 月度快报
self.copy_sheets(file_path, new_file_path, ["A001 资产负债表", "A002 利润表",
"A003 现金流量表", "A092 通用财务指标"])
else:
# 其他文件类型不处理
continue
total_processed += 1
except Exception as e:
total_error += 1
# 处理生成的文件
generated_processed = self.process_generated_files()
# 更新A列
self.update_sheet_a_column()
# 重置进度条
self.progress_label.config(text="运行完成")
self.progress_var.set(100)
# 显示最终处理结果，使用初始选中的文件数量
messagebox.showinfo("完成", f"处理完成！总共处理 {len(all_files)} 个文件。")
def copy_sheets(self, source_file, target_file, sheet_names):
"""复制指定的工作表到新的工作簿"""
# 创建一个新的Excel工作簿
wb_target = openpyxl.Workbook()
# 删除默认的Sheet1
if 'Sheet' in wb_target.sheetnames:
del wb_target['Sheet']
# 尝试用openpyxl打开源文件
try:
wb_source = openpyxl.load_workbook(source_file, read_only=False)
# 复制工作表
for sheet_name in sheet_names:
if sheet_name in wb_source.sheetnames:
# 复制整个工作表
source_sheet = wb_source[sheet_name]
target_sheet = wb_target.create_sheet(title=sheet_name)
# 复制数据和格式
for row in source_sheet.iter_rows():
for cell in row:
# 获取目标单元格
target_cell = target_sheet.cell(row=cell.row, column=cell.column)
# 复制值
target_cell.value = cell.value
# 复制基本格式
try:
target_cell.font = cell.font
target_cell.border = cell.border
target_cell.fill = cell.fill
target_cell.alignment = cell.alignment
target_cell.number_format = cell.number_format
except:
pass
# 复制列宽
for column in source_sheet.columns:
max_width = 0
column_letter = openpyxl.utils.get_column_letter(column[0].column)
# 查找最大宽度
for cell in column:
try:
if cell.value:
# 估算文本宽度
if isinstance(cell.value, str):
width = len(cell.value)
else:
width = len(str(cell.value))
if width > max_width:
max_width = width
except:
pass
# 设置列宽
if max_width > 0:
target_sheet.column_dimensions[column_letter].width = min(max_width, 50) # 限制最大宽度
wb_source.close()
except Exception:
# 如果openpyxl失败，尝试用pandas读取（更简单的方法）
for sheet_name in sheet_names:
try:
# 使用pandas读取工作表
df = pd.read_excel(source_file, sheet_name=sheet_name)
# 创建新工作表
ws_target = wb_target.create_sheet(title=sheet_name)
# 写入表头
for c_idx, col_name in enumerate(df.columns, 1):
ws_target.cell(row=1, column=c_idx, value=col_name)
# 写入数据
for r_idx, row in enumerate(df.itertuples(index=False), 2):
for c_idx, value in enumerate(row, 1):
ws_target.cell(row=r_idx, column=c_idx, value=value)
except:
# 如果工作表不存在或读取失败，跳过
continue
# 保存新工作簿
wb_target.save(target_file)
wb_target.close()
def _initialize_db_a(self):
"""初始化数据库A - 报表映射表"""
try:
# 尝试从文件读取
file_path = r"d:\AI\Trae\Project\5.Financial statements\报表映射表.xlsx"
if os.path.exists(file_path):
df = pd.read_excel(file_path, sheet_name="报表映射")
# 创建A列到B列的映射字典
mapping = {}
for _, row in df.iterrows():
if pd.notna(row.iloc[0]): # 确保A列有值
mapping[row.iloc[0]] = row.iloc[1] if pd.notna(row.iloc[1]) else ""
return mapping
except Exception:
pass
# 如果无法读取文件，返回空字典
return {}
def _initialize_db_b(self):
"""初始化数据库B - 财务数据表"""
db_b = {}
try:
# 尝试从文件读取
file_path = r"d:\AI\Trae\Project\5.Financial statements\财务数据表.xlsx"
if os.path.exists(file_path):
excel_file = pd.ExcelFile(file_path)
for sheet_name in excel_file.sheet_names:
df = pd.read_excel(file_path, sheet_name=sheet_name)
db_b[sheet_name] = df
except Exception:
pass
return db_b
def update_sheet_a_column(self):
"""遍历桌面上财务报表文件夹中的所有文件，更新每个工作表的A列"""
# 检查财务报表文件夹是否存在
if not os.path.exists(self.target_path):
return
# 获取文件夹中的所有Excel文件
excel_files = []
for file in os.listdir(self.target_path):
if file.endswith((".xlsx", ".xls", ".xlsm")):
excel_files.append(os.path.join(self.target_path, file))
if not excel_files:
return
total_files = len(excel_files)
# 处理每个文件
for i, file_path in enumerate(excel_files):
file_name = os.path.basename(file_path)
# 进度条显示在80%-90%范围内（预留10%给财务数据表处理）
self.progress_var.set(80 + (i + 1) / total_files * 10)
self.root.update_idletasks()
try:
# 打开工作簿
wb = openpyxl.load_workbook(file_path)
# 处理每个工作表
for sheet_name in wb.sheetnames:
# 跳过A092工作表，在后续单独处理
if sheet_name == "A092 通用财务指标":
continue
sheet = wb[sheet_name]
# 计算B列有内容的最大行数
max_row_with_content = 0
for row in range(1, sheet.max_row + 1):
cell_value = sheet.cell(row=row, column=2).value # B列
if cell_value is not None and str(cell_value).strip() != "":
max_row_with_content = row
# 根据最大行数更新A列
if max_row_with_content > 0 and self.db_a:
for row in range(1, max_row_with_content + 1):
# 获取当前A列的值
current_a_value = sheet.cell(row=row, column=1).value
if current_a_value in self.db_a:
# 替换A列的值
sheet.cell(row=row, column=1).value = self.db_a[current_a_value]
# 保存修改后的文件
wb.save(file_path)
wb.close()
except Exception as e:
pass
# 单独处理A092工作表的A列
self._process_a092_sheet_a_column()
# 处理财务数据表
self.process_financial_data_table()
def _process_a092_sheet_a_column(self):
"""专门处理A092通用财务指标工作表的A列匹配"""
# 检查财务报表文件夹是否存在
if not os.path.exists(self.target_path) or not self.db_a:
return
# 更新进度信息
self.root.update_idletasks()
# 获取文件夹中的所有Excel文件
excel_files = []
for file in os.listdir(self.target_path):
if file.endswith((".xlsx", ".xls", ".xlsm")):
excel_files.append(os.path.join(self.target_path, file))
if not excel_files:
return
# 处理每个文件
for file_path in excel_files:
try:
# 打开工作簿
wb = openpyxl.load_workbook(file_path)
# 检查是否有A092工作表
if "A092 通用财务指标" in wb.sheetnames:
sheet = wb["A092 通用财务指标"]
# 计算B列有内容的最大行数
max_row_with_content = 0
for row in range(1, sheet.max_row + 1):
# 注意：由于在B列前插入了一列，原B列现在是C列
cell_value = sheet.cell(row=row, column=3).value # 新的B列（原C列）
if cell_value is not None and str(cell_value).strip() != "":
max_row_with_content = row
# 根据最大行数更新A列
if max_row_with_content > 0:
for row in range(1, max_row_with_content + 1):
# 获取当前A列的值
current_a_value = sheet.cell(row=row, column=1).value
if current_a_value in self.db_a:
# 替换A列的值
sheet.cell(row=row, column=1).value = self.db_a[current_a_value]
# 保存修改
wb.save(file_path)
wb.close()
except Exception:
# 忽略错误，继续处理其他文件
pass
def _set_window_icon(self):
"""设置窗口图标，支持开发环境和pyinstaller打包环境"""
try:
# 优先使用.ico文件（推荐用于pyinstaller打包）
# pyinstaller打包时使用命令：pyinstaller --onefile --icon=Cecil.ico 财务报表处理程序.py
# 这样可以确保图标被正确打包到exe中
ico_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "Cecil.ico")
if os.path.exists(ico_path):
# 对于ico文件，tkinter支持直接设置
self.root.iconbitmap(ico_path)
return
except Exception as e:
# 如果设置图标失败，忽略错误
pass
icon_base64 = '''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'''
# ��ȷ�������˱�Ҫ��ģ�飺import base64, io, tkinter as tk
icon_stream = io.BytesIO(base64.b64decode(icon_base64))
icon = tk.PhotoImage(data=icon_stream.getvalue())
self.root.iconphoto(True, icon)
def _set_thousand_separator_style(self, data_table_path):
"""为财务数据表的B列到K列设置千位分隔样式
Args:
data_table_path: 财务数据表路径
"""
try:
# 更新进度信息
self.root.update_idletasks()
# 打开财务数据表
wb = load_workbook(data_table_path)
# 处理每个工作表
for sheet_name in wb.sheetnames:
sheet = wb[sheet_name]
# 设置B列到K列（列索引2到11）为千位分隔样式
for col in range(2, 12):
for row in range(2, sheet.max_row + 1):
cell = sheet.cell(row=row, column=col)
# 检查单元格是否有数值
if cell.value is not None and isinstance(cell.value, (int, float)) and not isinstance(cell.value, bool):
# 设置千位分隔样式
cell.number_format = '#,##0.00'
# 如果是负数，设置黑色字体
if cell.value max_width:
max_width = width
except:
pass
# 设置列宽（加一点余量）
if max_width > 0:
sheet.column_dimensions[column_letter].width = min(max_width + 2, 50) # 限制最大宽度并留余量
# 设置活动单元格为A1（在openpyxl中，我们设置选定范围）
sheet.sheet_view.selection[0].activeCell = 'A1'
sheet.sheet_view.selection[0].sqref = 'A1'
# 保存更新后的文件
wb.save(data_table_path)
wb.close()
except Exception:
# 忽略错误
pass
def _cleanup_financial_statement_folder(self, data_table_path):
"""整理财务报表文件夹，为了避免杀毒软件误报，不再自动删除文件
Args:
data_table_path: 财务数据表路径
"""
try:
# 更新进度信息
self.root.update_idletasks()
# 仅显示状态信息，不再执行文件删除操作
# 这样可以避免杀毒软件将文件删除操作识别为恶意行为
self.progress_label.config(text="文件整理完成")
except Exception:
# 忽略错误，继续执行
pass
def _remove_specific_worksheet(self, data_table_path, sheet_name):
"""删除财务数据表中指定的工作表
Args:
data_table_path: 财务数据表路径
sheet_name: 要删除的工作表名称
"""
try:
# 更新进度信息
self.root.update_idletasks()
# 打开财务数据表
wb = openpyxl.load_workbook(data_table_path)
# 检查并删除指定工作表
if sheet_name in wb.sheetnames:
del wb[sheet_name]
# 保存修改
wb.save(data_table_path)
wb.close()
except Exception:
# 忽略错误，继续执行
pass
def _clear_profit_sheet_row_4(self, data_table_path):
"""将利润表第4行从第2列开始到最大有内容列数的单元格全部设置为0
Args:
data_table_path: 财务数据表路径
"""
try:
# 更新进度信息
self.root.update_idletasks()
# 打开财务数据表
wb = openpyxl.load_workbook(data_table_path)
# 检查是否存在利润表工作表
if "利润表" not in wb.sheetnames:
wb.close()
return
sheet = wb["利润表"]
# 找到利润表中有内容的最大列数（A到M列之间）
max_column = 2 # 从B列开始
for col in range(2, 14): # 检查B到M列
for row in range(1, sheet.max_row + 1):
if sheet.cell(row=row, column=col).value is not None:
if col > max_column:
max_column = col
break
# 将第4行从第2列开始到最大列数的单元格全部设置为0
for col in range(2, max_column + 1):
sheet.cell(row=4, column=col).value = 0
# 保存更新后的文件
wb.save(data_table_path)
wb.close()
except Exception:
# 忽略错误
pass
def _match_and_fill_sheet_data(self, data_table_path, sheet_name, search_keyword):
"""匹配并填充指定类型报表的数据
Args:
data_table_path: 财务数据表路径
sheet_name: 财务数据表中的工作表名称
search_keyword: 在财务报表文件中查找的关键字
"""
try:
# 更新进度信息
self.root.update_idletasks()
# 打开财务数据表
wb_data = openpyxl.load_workbook(data_table_path)
# 检查是否存在指定工作表
if sheet_name not in wb_data.sheetnames:
wb_data.close()
return
sheet_data = wb_data[sheet_name]
# 获取财务报表文件夹中的所有Excel文件
report_files = {}
for file in os.listdir(self.target_path):
if file.endswith((".xlsx", ".xls", ".xlsm")) and file != "财务数据表.xlsx":
# 存储文件名（不含扩展名）到文件路径的映射
name_without_ext = os.path.splitext(file)[0]
report_files[name_without_ext] = os.path.join(self.target_path, file)
# 处理B1到K1列（对应列索引2到11）
for col_index in range(2, 12): # B=2, K=11
# 获取当前列第一行的文件名
file_name = sheet_data.cell(row=1, column=col_index).value
# 如果单元格无内容，跳过该列
if file_name is None:
continue
# 查找对应的文件
if file_name not in report_files:
continue
file_path = report_files[file_name]
try:
# 打开对应的财务报表文件
wb_report = openpyxl.load_workbook(file_path, data_only=True)
# 查找包含关键字的工作表
target_sheet = None
for report_sheet_name in wb_report.sheetnames:
if search_keyword in report_sheet_name:
target_sheet = wb_report[report_sheet_name]
break
if not target_sheet:
wb_report.close()
continue
# 创建A列到C列数值的映射
data_map = {}
for row in range(1, target_sheet.max_row + 1):
a_value = target_sheet.cell(row=row, column=1).value
c_value = target_sheet.cell(row=row, column=3).value
if a_value is not None:
data_map[str(a_value).strip()] = c_value
# 将数据填充到财务数据表中
for row in range(2, sheet_data.max_row + 1): # 从A2开始
a_value = sheet_data.cell(row=row, column=1).value
if a_value is not None:
# 查找匹配的数据
key = str(a_value).strip()
if key in data_map:
# 获取C列数值
value = data_map[key]
# 如果是数字，保持数字特性
if isinstance(value, (int, float)) and not isinstance(value, bool):
sheet_data.cell(row=row, column=col_index).value = value
else:
sheet_data.cell(row=row, column=col_index).value = value
wb_report.close()
except Exception:
# 忽略单个文件的错误，继续处理其他文件
continue
# 保存更新后的财务数据表
wb_data.save(data_table_path)
wb_data.close()
except Exception:
# 忽略整体错误
pass
def process_financial_data_table(self):
"""处理财务数据表，包括清空B-M列、填充文件名和保存到目标文件夹"""
# 更新进度信息
self.root.update_idletasks()
# 财务数据表路径
data_table_path = r"d:\AI\Trae\Project\5.Financial statements\财务数据表.xlsx"
if not os.path.exists(data_table_path):
self.progress_var.set(100)
return
try:
# 检查是否有A_sub值，如果有则构建财务数据表文件名
a_sub_prefix = getattr(self, 'first_a_sub', '')
if a_sub_prefix:
financial_data_table_name = f"{a_sub_prefix}_财务数据表.xlsx"
else:
financial_data_table_name = "财务数据表.xlsx"
# 获取财务报表文件夹中的所有Excel文件名（不含扩展名）
file_names = []
for file in os.listdir(self.target_path):
if file.endswith((".xlsx", ".xls", ".xlsm")) and file != financial_data_table_name: # 排除可能已存在的财务数据表
# 移除扩展名
name_without_ext = os.path.splitext(file)[0]
file_names.append(name_without_ext)
# 自定义排序函数
def sort_file_names(names):
# 尝试提取年份和是否包含月份
name_info = []
for name in names:
import re
year_match = re.search(r'\b(\d{4})\b', name)
if year_match:
year = int(year_match.group(1))
# 检查是否包含月份
has_month = bool(re.search(r'\b(0[1-9]|1[0-2])\b', name))
name_info.append((name, year, has_month))
else:
name_info.append((name, 0, False))
# 找出最小和最大年份
years = [info[1] for info in name_info if info[1] > 0]
if years:
min_year = min(years)
max_year = max(years)
else:
min_year = max_year = 0
# 根据规则排序
def sort_key(info):
name, year, has_month = info
# 最小年份有月份的放前面
if year == min_year:
return (year, not has_month) # 有月份的在前面（False False）
# 其他年份正常排序
return (year, has_month)
# 排序并返回结果
name_info.sort(key=sort_key)
return [info[0] for info in name_info]
# 排序文件名
sorted_names = sort_file_names(file_names)
# 打开财务数据表
wb = openpyxl.load_workbook(data_table_path)
# 处理每个工作表
for sheet_name in wb.sheetnames:
sheet = wb[sheet_name]
# 1. 清空B到M列的内容（保留列本身）
self.progress_var.set(92)
self.root.update_idletasks()
for col in range(2, 14): # B=2, M=13
for row in range(1, sheet.max_row + 1):
sheet.cell(row=row, column=col).value = None
# 2. 填充文件名为第一行，从B1开始
self.progress_var.set(96)
self.root.update_idletasks()
for i, name in enumerate(sorted_names):
col = i + 2 # 从B列开始
if col 0:
sheet.delete_rows(sheet.max_row, 1)
# 操作2的一部分：将E列至H列移动到A列最后一行的下面一行
last_row = sheet.max_row
# 复制E-H列数据
data_to_move = []
for row in range(1, sheet.max_row + 1):
row_data = []
for col in range(5, 9): # E=5, H=8
cell = sheet.cell(row=row, column=col)
row_data.append(cell.value)
data_to_move.append(row_data)
# 粘贴到A列最后一行下面
for r_idx, row_data in enumerate(data_to_move, last_row + 1):
for c_idx, value in enumerate(row_data, 1):
sheet.cell(row=r_idx, column=c_idx, value=value)
# 操作2：如果工作表是"Z20 成本费用情况表"，删除A列到H列
elif sheet_name == "Z20 成本费用情况表":
# 从H列开始往前删除，避免列索引变化问题
for col in range(8, 0, -1): # H=8到A=1
sheet.delete_cols(col, 1)
# 操作2的一部分：其他需要移动列的工作表
elif sheet_name in ["Z02 利润表", "Z03 现金流量表", "FXZB 主要分析指标表（计算机自动生成）"]:
last_row = sheet.max_row
# 复制E-H列数据
data_to_move = []
for row in range(1, sheet.max_row + 1):
row_data = []
for col in range(5, 9): # E=5, H=8
cell = sheet.cell(row=row, column=col)
row_data.append(cell.value)
data_to_move.append(row_data)
# 粘贴到A列最后一行下面
for r_idx, row_data in enumerate(data_to_move, last_row + 1):
for c_idx, value in enumerate(row_data, 1):
sheet.cell(row=r_idx, column=c_idx, value=value)
# 操作2的一部分：如果工作表是"A002 利润表"或"A003 现金流量表"，删除C列
elif sheet_name in ["A002 利润表", "A003 现金流量表"]:
sheet.delete_cols(3, 1) # C列=3
# 操作2的一部分：如果工作表是"A092 通用财务指标"，在B列前新建一列
elif sheet_name == "A092 通用财务指标":
sheet.insert_cols(2, 1) # 在B列前插入一列
# 保存修改后的文件
wb.save(file_path)
wb.close()
processed_files += 1
except Exception as e:
pass
return processed_files
def on_closing(root):
"""处理窗口关闭事件，显示确认对话框"""
# 显示确认对话框
if messagebox.askyesno("确认退出", "是否退出软件？"):
# 简化退出逻辑，移除可能触发杀毒软件的文件夹删除和临时文件操作
# 避免使用系统敏感函数和操作
try:
# 直接退出程序
root.destroy()
except Exception:
# 发生错误时直接终止
import sys
sys.exit()
if __name__ == "__main__":
root = tk.Tk()
app = FinancialReportProcessor(root)
# 绑定窗口关闭事件
root.protocol("WM_DELETE_WINDOW", lambda: on_closing(root))
root.mainloop()
