qrpa 1.0.34__py3-none-any.whl → 1.1.50__py3-none-any.whl

qrpa/fun_excel.py

@@ -14,6 +14,9 @@ import threading
 from playwright.sync_api import sync_playwright
 import psutil
 
+import os, sys
+from pathlib import Path
+
 from .fun_base import log, sanitize_filename, create_file_path, copy_file, add_https, send_exception
 
 excel_color_index = {
@@ -73,6 +76,49 @@ excel_color_index = {
     "深蓝灰色"     : 55,  # #333399
 }
 
+def aggregate_by_column(data, group_by_col_name):
+    """
+    根据指定列名对二维表数据聚合：
+    - 数字列求和
+    - 字符串列用换行符拼接
+
+    :param data: 二维列表，第一行为表头
+    :param group_by_col_name: 要聚合的列名，如 "店长"
+    :return: 聚合后的二维列表
+    """
+    headers = data[0]
+    group_index = headers.index(group_by_col_name)
+    grouped = defaultdict(list)
+
+    # 按 group_by 列聚合行
+    for row in data[1:]:
+        key = row[group_index]
+        grouped[key].append(row)
+
+    result = [headers]
+
+    for key, rows in grouped.items():
+        agg_row = []
+        for col_idx in range(len(headers)):
+            col_values = [r[col_idx] for r in rows]
+            # 聚合字段
+            if col_idx == group_index:
+                agg_value = key
+            else:
+                # 尝试将值转为 float，如果成功就求和，否则拼接
+                try:
+                    nums = [float(v) for v in col_values if
+                            isinstance(v, (int, float)) or (isinstance(v, str) and v.strip() != '')]
+                    agg_value = sum(nums)
+                except ValueError:
+                    # 拼接字符串（去重可加 set）
+                    strings = [str(v).strip() for v in col_values if str(v).strip()]
+                    agg_value = '\n'.join(strings)
+            agg_row.append(agg_value)
+        result.append(agg_row)
+
+    return result
+
 def set_cell_prefix_red(cell, n, color_name):
     """
     将指定 Excel 单元格内容的前 n 个字符设置为红色。
@@ -105,6 +151,34 @@ def wrap_column(sheet, columns=None, WrapText=True):
                 log(f'设置[{c}] 换行 {WrapText}')
                 sheet.range(f'{col_name}:{col_name}').api.WrapText = WrapText
 
+def sort_by_column_excel(sheet, sort_col: str, has_header=True, order="desc"):
+    """
+    对整个表格按照某一列排序
+
+    :param sheet: xlwings 的 sheet 对象
+    :param sort_col: 排序依据的列（如 'D'）
+    :param has_header: 是否有表头（默认 True）
+    :param order: 'asc' 升序，'desc' 降序
+    """
+    # 找到表格的最后一行和列
+    last_cell = sheet.used_range.last_cell
+    rng = sheet.range((1, 1), (last_cell.row, last_cell.column))
+
+    # 排序依据列
+    col_index = ord(sort_col.upper()) - ord('A') + 1
+    key = sheet.range((2 if has_header else 1, col_index)).api
+
+    # 排序顺序
+    order_val = 1 if order == "asc" else 2
+
+    # 调用 Excel 的 Sort 方法
+    rng.api.Sort(
+        Key1=key,
+        Order1=order_val,
+        Orientation=1,
+        Header=1 if has_header else 0
+    )
+
 def sort_by_column(data, col_index, header_rows=2, reverse=True):
     if not data or header_rows >= len(data):
         return data
@@ -149,37 +223,88 @@ def merge_by_column_v2(sheet, column_name, other_columns):
         log(f'未找到合并的列名: {column_name}')
         return
 
-    data = sheet.range(f'{col_letter}1').expand('table').value
-    # col_index = column_name_to_index(col_letter)
-    start_row = 1
-    merge_ranges = []  # 用来存储所有待合并的单元格范围
+    # 更安全的数据获取方式，确保获取完整的数据范围
+    last_row = get_last_row(sheet, col_letter)
+    data = sheet.range(f'{col_letter}1:{col_letter}{last_row}').value
+
+    # 确保data是列表格式
+    if not isinstance(data, list):
+        data = [data]
 
-    # 缓存其他列的列号
-    other_columns_index = {}
+    log(f'数据范围: {col_letter}1:{col_letter}{last_row}, 数据长度: {len(data)}')
+
+    start_row = 2  # 从第2行开始，跳过表头
+    merge_row_ranges = []  # 用来存储需要合并的行范围 (start_row, end_row)
+
+    # 获取所有需要合并的列
+    all_columns = [col_letter]  # 主列
     for col in other_columns:
         col_name = find_column_by_data(sheet, 1, col)
         if col_name:
-            other_columns_index[col_name] = column_name_to_index(col_name)
+            all_columns.append(col_name)
 
-    for row in range(2, len(data) + 1):
-        log(f'查找 {row}/{len(data)}')
-        if data[row - 1][0] != data[row - 2][0]:
-            if row - start_row > 1:
-                # 将合并范围加入列表
-                merge_ranges.append((col_letter, start_row, row - 1))
-                for col_name, col_index in other_columns_index.items():
-                    merge_ranges.append((col_name, start_row, row - 1))
+    log(f'需要合并的列: {all_columns}')
+
+    # 遍历数据行，从第3行开始比较（因为第1行是表头，第2行是第一个数据行）
+    for row in range(3, len(data) + 1):
+        log(f'查找 {row}/{len(data)}, 当前值: {data[row - 1] if row - 1 < len(data) else "超出范围"}, 前一个值: {data[row - 2] if row - 2 < len(data) else "超出范围"}')
+
+        # 检查值是否发生变化
+        if row <= len(data) and data[row - 1] != data[row - 2]:
+            # 值发生变化，处理前一组
+            end_row = row - 1
+            log(f'添加合并范围: {start_row} 到 {end_row}')
+            merge_row_ranges.append((start_row, end_row))
             start_row = row
 
-    if len(data) - start_row > 1:
-        merge_ranges.append((col_letter, start_row, len(data)))
-        for col_name, col_index in other_columns_index.items():
-            merge_ranges.append((col_name, start_row, len(data)))
+    # 处理最后一组数据（循环结束后，start_row 到数据末尾）
+    if start_row <= len(data):
+        end_row = len(data)
+        log(f'处理最后一组: {start_row} 到 {end_row}')
+        merge_row_ranges.append((start_row, end_row))
 
-    # 批量合并单元格
-    for col_name, start, end in merge_ranges:
-        log(f'处理 {col_name}{start}:{col_name}{end} merge')
-        sheet.range(f'{col_name}{start}:{col_name}{end}').merge()
+    log(f'行合并范围: {merge_row_ranges}')
+
+    # 对每个行范围，在所有指定列中执行合并
+    for start_row, end_row in merge_row_ranges:
+        if start_row < end_row:  # 只有当开始行小于结束行时才合并（多行）
+            for col_name in all_columns:
+                try:
+                    cell_range = sheet.range(f'{col_name}{start_row}:{col_name}{end_row}')
+                    
+                    # 验证：检查范围内的值是否都相同
+                    values = cell_range.value
+                    if not isinstance(values, list):
+                        values = [values]
+                    
+                    # 检查是否所有值都相同（忽略 None）
+                    non_none_values = [v for v in values if v is not None]
+                    if non_none_values and len(set(non_none_values)) > 1:
+                        log(f'警告：{col_name}{start_row}:{col_name}{end_row} 包含不同的值，跳过合并: {set(non_none_values)}')
+                        continue
+                    
+                    log(f'处理 {col_name}{start_row}:{col_name}{end_row} merge')
+                    
+                    # 保存第一个单元格的值
+                    first_cell_value = sheet.range(f'{col_name}{start_row}').value
+                    
+                    # 先清空所有单元格（避免多行文本导致的合并问题）
+                    cell_range.value = None
+                    
+                    # 执行合并
+                    cell_range.merge()
+                    
+                    # 恢复第一个单元格的值
+                    cell_range.value = first_cell_value
+                    
+                except Exception as e:
+                    log(f'合并失败 {col_name}{start_row}:{col_name}{end_row}: {e}')
+                    # 继续处理其他列
+                    continue
+        elif start_row == end_row:
+            log(f'单行数据无需合并: {start_row} 到 {end_row}')
+        else:
+            log(f'跳过无效合并范围: {start_row} 到 {end_row}')
 
 def merge_by_column(sheet, column_name, other_columns):
     log('正在处理合并单元格')
@@ -589,10 +714,10 @@ def InsertImageV2(sheet, columns=None, platform='shein', img_width=150, img_save
 
     img_key_letter = find_column_by_data(sheet, 1, img_save_key)
 
-    # 预计算所有单元格的合并区域信息 (优化点1)
+    # 阶段1：调整所有单元格尺寸 (优化点1)
     area_map = {}
     for row in range(start_row, last_row + 1):
-        log(f'计算 {row}/{last_row}')  # 如果数据量非常大，这里的日志会影响性能，可以考虑优化
+        log(f'计算 {row}/{last_row}')
         for col_letter in col_letter_map.values():
             cell_ref = f'{col_letter}{row}'
             cell_range = sheet.range(cell_ref)
@@ -603,32 +728,46 @@ def InsertImageV2(sheet, columns=None, platform='shein', img_width=150, img_save
                 cell_address = cell_range.address
 
             if cell_address not in area_map:
-                # 计算合并区域的宽高和位置
-                cell_width = cell_range.width
-                cell_height = cell_range.height
-
-                # 调整列宽和行高
-                if cell_width < img_width:
-                    cell_range.column_width = img_width / 6.1
-
-                # 这一行暂时先自动控制宽度
+                # 调整列宽
                 cell_range.column_width = img_width / 6.1
 
-                if cell_height < img_width:
-                    cell_range.row_height = max(150 / 8, img_width / cell_range.rows.count)
+                # 调整行高
+                if cell_range.height < img_width:
+                    if cell_range.merge_cells:
+                        # 合并单元格：为每一行设置高度
+                        rows_count = cell_range.rows.count
+                        per_row_height = img_width / rows_count
+                        for single_row in cell_range.rows:
+                            single_row.row_height = max(per_row_height, 150 / 8)
+                    else:
+                        cell_range.row_height = max(img_width, 150 / 8)
 
                 if cell_height_with_img:
-                    cell_range.row_height = img_width
-
+                    if cell_range.merge_cells:
+                        rows_count = cell_range.rows.count
+                        for single_row in cell_range.rows:
+                            single_row.row_height = img_width / rows_count
+                    else:
+                        cell_range.row_height = img_width
+                
+                # 重新读取调整后的宽高
+                if cell_range.merge_cells:
+                    cell_range = sheet.range(cell_ref).merge_area
+                else:
+                    cell_range = sheet.range(cell_ref)
+                
                 # 计算居中位置
-                top = cell_range.top + (cell_range.height - img_width) / 2
-                left = cell_range.left + (cell_range.width - img_width) / 2
+                actual_width = cell_range.width
+                actual_height = cell_range.height
+                actual_img_size = img_width - 4
+                top = cell_range.top + (actual_height - actual_img_size) / 2 - 2
+                left = cell_range.left + (actual_width - actual_img_size) / 2 - 2
 
                 area_map[cell_address] = {
                     'top'      : top,
                     'left'     : left,
                     'width'    : img_width,
-                    'cell_list': [c.address for c in cell_range]
+                    'cell_list': [c.address for c in cell_range] if cell_range.merge_cells else [cell_address]
                 }
 
     # 处理图片插入 (优化点2)
@@ -685,6 +824,238 @@ def InsertImageV2(sheet, columns=None, platform='shein', img_width=150, img_save
             else:
                 log(f'图片地址不存在 [{img_col_name}] : 第{row}行')
 
+def InsertImageV3(sheet, columns=None, platform='shein', img_widths=None, img_save_key=None, dir_name=None, cell_height_with_img=False, start_row=2):
+    """
+    V3版本：支持一次性插入多列图片，每列可以设置不同的宽度
+    
+    Args:
+        sheet: Excel工作表对象
+        columns: 图片列名列表，如 ['SKC图片', 'SKU图片']
+        platform: 平台名称，如 'shein'
+        img_widths: 图片宽度列表，与columns对应，如 [90, 60]
+        img_save_key: 图片保存时的key列
+        dir_name: 图片保存目录名
+        cell_height_with_img: 是否根据图片调整单元格高度
+        start_row: 开始行号，默认为2
+    """
+    if not columns:
+        return
+    
+    # 如果没有提供宽度列表，使用默认宽度150
+    if not img_widths:
+        img_widths = [150] * len(columns)
+    
+    # 确保宽度列表长度与列名列表一致
+    if len(img_widths) != len(columns):
+        raise ValueError(f"img_widths长度({len(img_widths)})必须与columns长度({len(columns)})一致")
+
+    minimize(sheet.book.app)
+
+    # 只清空一次所有图片
+    clear_all_pictures(sheet)
+
+    # 获取每列图片列的列号，并批量下载图片
+    col_letter_map = {}
+    col_width_map = {}  # 存储每列对应的宽度
+    
+    for idx, img_col in enumerate(columns):
+        col_letter = find_column_by_data(sheet, 1, img_col)
+        if col_letter is not None:
+            col_letter_map[img_col] = col_letter
+            col_width_map[col_letter] = img_widths[idx]
+            # 下载图片
+            log(f'批量下载图片: {img_col} => {col_letter} (宽度: {img_widths[idx]})')
+            last_row = get_last_row(sheet, col_letter)
+            images = sheet.range(f'{col_letter}2:{col_letter}{last_row}').value
+            images = images if isinstance(images, list) else [images]
+            download_images_concurrently(images, platform)
+
+    # 任意一个列作为主参考列，用来确定行数
+    if not col_letter_map:
+        return
+
+    ref_col_letter = next(iter(col_letter_map.values()))
+    last_row = get_last_row(sheet, ref_col_letter)
+
+    img_key_letter = find_column_by_data(sheet, 1, img_save_key)
+
+    # 阶段1：收集每个单元格需要的尺寸要求
+    cell_size_requirements = {}  # {cell_address: {'width': max_width, 'height': max_height, 'merge': is_merge}}
+    
+    for row in range(start_row, last_row + 1):
+        for col_letter in col_letter_map.values():
+            cell_ref = f'{col_letter}{row}'
+            cell_range = sheet.range(cell_ref)
+            cell_address = cell_range.address
+            img_width = col_width_map[col_letter]
+            
+            if cell_range.merge_cells:
+                cell_range = cell_range.merge_area
+                cell_address = cell_range.address
+            
+            # 记录每个单元格需要的最大尺寸
+            if cell_address not in cell_size_requirements:
+                cell_size_requirements[cell_address] = {
+                    'width': img_width,
+                    'height': img_width,
+                    'cell_range': cell_range,
+                    'merge': cell_range.merge_cells
+                }
+            else:
+                # 取最大值
+                cell_size_requirements[cell_address]['width'] = max(
+                    cell_size_requirements[cell_address]['width'], img_width
+                )
+                cell_size_requirements[cell_address]['height'] = max(
+                    cell_size_requirements[cell_address]['height'], img_width
+                )
+    
+    # 阶段2：统一调整所有单元格的宽高（按列分别处理）
+    log(f'调整单元格尺寸...')
+    adjusted_cells = {}  # 记录已调整的单元格，避免重复调整
+    
+    for col_letter in col_letter_map.values():
+        img_width = col_width_map[col_letter]
+        
+        for row in range(start_row, last_row + 1):
+            cell_ref = f'{col_letter}{row}'
+            cell_range = sheet.range(cell_ref)
+            cell_address = cell_range.address
+            
+            if cell_range.merge_cells:
+                cell_range = cell_range.merge_area
+                cell_address = cell_range.address
+            
+            # 调整列宽（按原来的逻辑，每列都调整）
+            if cell_range.width < img_width:
+                cell_range.column_width = img_width / 6.1
+            # 这一行暂时先自动控制宽度
+            cell_range.column_width = img_width / 6.1
+            
+            # 行高只调整一次（使用最大需求）
+            if cell_address not in adjusted_cells:
+                adjusted_cells[cell_address] = True
+                required_height = cell_size_requirements[cell_address]['height']
+                
+                # 调整行高
+                if cell_range.height < required_height:
+                    if cell_range.merge_cells:
+                        # 合并单元格：为每一行设置高度
+                        rows_count = cell_range.rows.count
+                        per_row_height = required_height / rows_count
+                        for single_row in cell_range.rows:
+                            single_row.row_height = max(per_row_height, 150 / 8)
+                    else:
+                        cell_range.row_height = max(required_height, 150 / 8)
+                
+                if cell_height_with_img:
+                    if cell_range.merge_cells:
+                        rows_count = cell_range.rows.count
+                        for single_row in cell_range.rows:
+                            single_row.row_height = required_height / rows_count
+                    else:
+                        cell_range.row_height = required_height
+    
+    # 阶段3：计算所有图片的位置
+    area_map = {}
+    for row in range(start_row, last_row + 1):
+        log(f'计算位置 {row}/{last_row}')
+        for col_letter in col_letter_map.values():
+            cell_ref = f'{col_letter}{row}'
+            cell_range = sheet.range(cell_ref)
+            cell_address = cell_range.address
+            img_width = col_width_map[col_letter]
+            
+            if cell_range.merge_cells:
+                cell_range = cell_range.merge_area
+                cell_address = cell_range.address
+            
+            # 重新读取调整后的宽高
+            actual_width = cell_range.width
+            actual_height = cell_range.height
+            
+            # 计算该列图片的居中位置
+            # 图片实际大小是 img_width-4，插入时偏移+2，所以这里-2补偿
+            actual_img_size = img_width - 4
+            top = cell_range.top + (actual_height - actual_img_size) / 2 - 2
+            left = cell_range.left + (actual_width - actual_img_size) / 2 - 2
+            
+            # 每个列都单独保存位置
+            area_map[f'{cell_address}_{col_letter}'] = {
+                'top': top,
+                'left': left,
+                'width': img_width,
+                'cell_address': cell_address,
+                'cell_list': [c.address for c in cell_range] if cell_range.merge_cells else [cell_address]
+            }
+
+    # 阶段4：插入图片
+    for row in range(start_row, last_row + 1):
+        for img_col_name, col_letter in col_letter_map.items():
+            cell_ref = f'{col_letter}{row}'
+            cell_range = sheet.range(cell_ref)
+            original_address = cell_range.address
+
+            if cell_range.merge_cells:
+                cell_range = cell_range.merge_area
+                cell_address = cell_range.address
+            else:
+                cell_address = original_address
+
+            # 检查是否是合并单元格的非首单元格（跳过）
+            area_key = f'{cell_address}_{col_letter}'
+            if area_key not in area_map:
+                continue
+                
+            area_info = area_map[area_key]
+            
+            # 对于合并单元格，只在第一个单元格处理
+            if cell_range.merge_cells:
+                # 获取合并区域的第一个单元格地址
+                first_cell_in_merge = area_info['cell_list'][0] if area_info['cell_list'] else cell_address
+                # 如果当前单元格不是合并区域的第一个单元格，跳过
+                if original_address != first_cell_in_merge:
+                    continue
+
+            # 使用预计算的位置信息
+            top = area_info['top']
+            left = area_info['left']
+            width = area_info['width']
+
+            # 获取图片链接
+            if cell_range.merge_cells:
+                img_url = cell_range.value[0]
+            else:
+                img_url = cell_range.value
+
+            if img_url:
+                if img_key_letter is not None:
+                    image_dir = Path(f'{os.getenv('auto_dir')}/image') / dir_name
+                    extension = Path(img_url).suffix
+                    filename = str(sheet.range(f'{img_key_letter}{row}').value)
+                    img_save_path = image_dir / f"{sanitize_filename(filename)}{extension}"
+                else:
+                    img_save_path = None
+
+                img_path = download_img_v2(img_url, platform, img_save_path)
+                log(f'插入图片 {sheet.name} [{img_col_name}] {row}/{last_row} {img_path}')
+                if not img_path:
+                    log('跳过:', img_path, img_url)
+                    continue
+                cell_value = cell_range.value
+
+                # 插入图片
+                try:
+                    # 使用预计算的位置直接插入图片
+                    sheet.pictures.add(img_path, top=top + 2, left=left + 2, width=width - 4, height=width - 4)
+                    cell_range.value = None
+                except Exception as e:
+                    # 插入图片失败恢复链接地址
+                    cell_range.value = cell_value
+                    send_exception()
+            else:
+                log(f'图片地址不存在 [{img_col_name}] : 第{row}行')
+
 def download_images_concurrently(image_urls, platform='shein', img_save_dir=None):
     # 使用线程池执行并发下载
     with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
@@ -693,18 +1064,22 @@ def download_images_concurrently(image_urls, platform='shein', img_save_dir=None
     return results
 
 def download_img_by_chrome(image_url, save_name):
-    with sync_playwright() as p:
-        browser = p.chromium.launch(headless=True)  # 运行时可以看到浏览器
-        context = browser.new_context()
-        page = context.new_page()
-        # 直接通过Playwright下载图片
-        response = page.request.get(image_url)
-        with open(save_name, 'wb') as f:
-            f.write(response.body())  # 将下载的内容保存为文件
-        log(f"图片已通过chrome下载并保存为:{save_name}")
-        # 关闭浏览器
-        browser.close()
-    return save_name
+    try:
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True)  # 运行时可以看到浏览器
+            context = browser.new_context()
+            page = context.new_page()
+            # 直接通过Playwright下载图片
+            response = page.request.get(image_url)
+            with open(save_name, 'wb') as f:
+                f.write(response.body())  # 将下载的内容保存为文件
+            log(f"图片已通过chrome下载并保存为:{save_name}")
+            # 关闭浏览器
+            browser.close()
+            return save_name
+    except:
+        send_exception()
+        return None
 
 def download_img_v2(image_url, platform='shein', img_save_path=None):
     image_url = add_https(image_url)
@@ -1213,6 +1588,73 @@ def colorize_by_field(sheet, field):
         row_range.color = bg_color  # 应用背景色
         sheet.range(f"A{row}").api.Font.Bold = True  # 让店铺名称加粗
 
+def colorize_by_field_v2(sheet, field):
+    """
+    改进版：按指定字段为行着色，正确处理合并单元格
+    
+    Args:
+        sheet: Excel工作表对象
+        field: 用于分组着色的字段名（列名）
+    """
+    minimize(sheet.book.app)
+    
+    # 查找字段所在的列
+    field_column = find_column_by_data(sheet, 1, field)
+    if field_column is None:
+        log(f'未找到字段列: {field}')
+        return
+    
+    log(f'按字段 {field} (列 {field_column}) 着色')
+    
+    # 获取最后一行和最后一列
+    last_row = get_last_row(sheet, field_column)
+    max_column_letter = get_max_column_letter(sheet)
+    
+    # 记录字段值对应的颜色
+    field_color_map = {}
+    last_field_value = None  # 记录上一个非空值
+    
+    # 从第2行开始遍历（跳过表头）
+    for row in range(2, last_row + 1):
+        # 读取当前行的字段值
+        cell = sheet.range(f'{field_column}{row}')
+        current_value = cell.value
+        
+        # 如果是合并单元格的非首单元格，值可能为 None，使用上一个非空值
+        if current_value is None or current_value == '':
+            # 检查是否是合并单元格
+            if cell.merge_cells:
+                # 使用合并区域的值
+                merge_area = cell.merge_area
+                current_value = merge_area.value
+                if isinstance(current_value, (list, tuple)):
+                    current_value = current_value[0] if current_value else None
+            
+            # 如果仍然为空，使用上一个非空值
+            if current_value is None or current_value == '':
+                current_value = last_field_value
+        else:
+            # 更新上一个非空值
+            last_field_value = current_value
+        
+        # 跳过空值
+        if current_value is None or current_value == '':
+            continue
+        
+        # 为新的字段值分配颜色
+        if current_value not in field_color_map:
+            field_color_map[current_value] = random_color()
+        
+        # 应用背景色到整行
+        bg_color = field_color_map[current_value]
+        row_range = sheet.range(f'A{row}:{max_column_letter}{row}')
+        row_range.color = bg_color
+        
+        # 可选：让第一列加粗（店铺信息等）
+        # sheet.range(f'A{row}').api.Font.Bold = True
+    
+    log(f'着色完成，共 {len(field_color_map)} 个不同的 {field} 值')
+
 def add_borders(sheet, lineStyle=1):
     log('添加边框')
     # 获取工作表的整个范围（假设表格的数据是从A1开始）
@@ -1961,7 +2403,7 @@ def pre_format_columns_safe(sheet, columns, data_rows):
 
 def post_format_columns_safe(sheet, columns, data_rows):
     """
-    后格式化函数：在写入数据后确认列格式
+    后格式化函数：在写入数据后确认列格式并强制转换为文本
     
     Args:
         sheet: Excel工作表对象
@@ -1981,8 +2423,32 @@ def post_format_columns_safe(sheet, columns, data_rows):
             # 只对实际有数据的行进行格式化
             if data_rows > 0:
                 range_str = f'{col_name}1:{col_name}{data_rows}'
-                sheet.range(range_str).number_format = '@'
-                log(f'后格式化成功: {range_str}')
+                target_range = sheet.range(range_str)
+                
+                # 设置格式为文本
+                target_range.number_format = '@'
+                
+                # 关键步骤：读取数据并重新写入，触发文本转换
+                # 这样可以将已经写入的数字转换为文本格式
+                values = target_range.value
+                if values is not None:
+                    # 处理单个值的情况
+                    if not isinstance(values, list):
+                        if values != '':
+                            target_range.value = str(values)
+                    # 处理列表的情况（单列多行）
+                    elif len(values) > 0:
+                        # 检查是否是二维数组（实际上单列应该是一维数组）
+                        if isinstance(values[0], list):
+                            # 二维数组，取第一列
+                            converted_values = [[str(row[0]) if row[0] is not None and row[0] != '' else row[0]] for row in values]
+                        else:
+                            # 一维数组
+                            converted_values = [[str(val)] if val is not None and val != '' else [val] for val in values]
+                        # 重新写入（这次会按照文本格式写入）
+                        target_range.value = converted_values
+                
+                log(f'后格式化并转换成功: {range_str}')
 
         except Exception as e:
             log(f'后格式化列 {col_name} 失败: {e}，继续处理其他列')
@@ -2045,11 +2511,12 @@ def format_to_month(sheet, columns=None):
 
 def add_sum_for_cell(sheet, col_list, row=2):
     last_row = sheet.range('A' + str(sheet.cells.last_cell.row)).end('up').row
-    for col_name in col_list:
-        col_letter = find_column_by_data(sheet, 1, col_name)
-        sheet.range(f'{col_letter}{row}').formula = f'=SUM({col_letter}{row + 1}:{col_letter}{last_row})'
-        sheet.range(f'{col_letter}{row}').api.Font.Color = 255
-        sheet.range(f'{col_letter}:{col_letter}').autofit()
+    if last_row > row:
+        for col_name in col_list:
+            col_letter = find_column_by_data(sheet, 1, col_name)
+            sheet.range(f'{col_letter}{row}').formula = f'=SUM({col_letter}{row + 1}:{col_letter}{last_row})'
+            sheet.range(f'{col_letter}{row}').api.Font.Color = 255
+            sheet.range(f'{col_letter}:{col_letter}').autofit()
 
 def clear_for_cell(sheet, col_list, row=2):
     last_row = sheet.range('A' + str(sheet.cells.last_cell.row)).end('up').row
@@ -2077,6 +2544,7 @@ def add_formula_for_column(sheet, col_name, formula, start_row=2):
             # AutoFill 快速填充到所有行（start_row 到 last_row）
             sheet.range(f'{col_letter}{start_row}').api.AutoFill(
                 sheet.range(f'{col_letter}{start_row}:{col_letter}{last_row}').api)
+        sheet.range(f'{col_letter}:{col_letter}').autofit()
 
 def autofit_column(sheet, columns=None):
     if columns is None: