股票代码处理与排序

您提到希望将数据按照 证券代码 和 日期 进行排序，具体是先按证券代码，再按日期由最早到最新。这是一个合理的需求，尤其是在处理多支股票的数据时，能够更清晰地观察每支股票的时间序列变化。

问题分析

根据您提供的代码和输出结果，以下几点需要注意：

1. 初始排序：

   • 在步骤3中，您已经对数据按 ['证券代码', '日期'] 进行了排序：

     python
     filtered_data = filtered_data.sort_values(by=['证券代码', '日期'])

   • 这一步骤是正确的，确保每个证券代码内的数据按日期排序。

2. 输出前的再次排序：

   • 在步骤5中，您再次对数据仅按 ['日期'] 进行了排序：

     python
     output_data = output_data.sort_values(by='日期')

   • 这一步骤会打乱之前按 ['证券代码', '日期'] 排序的顺序，因为它仅按日期对所有证券代码的数据进行了全局排序。

3. 日期转换：

   • 在排序之前，您将 日期 列转换为了字符串格式：

     python
     output_data['日期'] = output_data['日期'].dt.strftime('%d/%m/%Y')

   • 如果在将 日期 转换为字符串后再进行排序，会导致日期排序基于字符串顺序，而非实际的日期顺序。

4. #VALUE! 问题：

   • 在输出数据中出现 #VALUE!，这通常是由于在某些单元格中存在无效或不可转换的值，可能是由于数据处理中的某些步骤未正确处理这些值。

解决方案

为了实现您希望的排序方式，并解决 #VALUE! 问题，建议对代码进行以下修改：

1. 移除不必要的排序：

   • 删除步骤5中仅按 ['日期'] 进行的排序，保持初始的 ['证券代码', '日期'] 排序。

2. 确保日期排序正确：

   • 在将 日期 转换为字符串格式之前，确保数据已经按 ['证券代码', '日期'] 排序。

3. 处理 #VALUE! 问题：

   • 确保在计算 涨停基因差 时，所有参与计算的值都是数值类型，并正确处理缺失值。

修改后的代码示例

以下是根据上述建议修改后的代码片段：

python
import pandas as pd
import os
import re
from io import StringIO

def determine_suffix(stock_code):
    """
    根据股票代码确定后缀。
    以'6'开头的代码添加'.SH'，其他的添加'.SZ'。
    """
    if stock_code.startswith('6'):
        return '.SH'
    else:
        return '.SZ'

def process_stock_codes(input_codes):
    """
    处理输入的股票代码，确保它们具有正确的后缀。
    """
    processed_codes = []
    for code in input_codes:
        # 去除空白、换行和逗号，并转换为大写
        code = code.strip().upper().replace(',', '').replace('\n', '').replace('\r', '')
        if not code:
            continue  # 跳过空字符串
        if '.' in code:
            # 确保后缀为.SH或.SZ
            parts = code.split('.')
            if len(parts) != 2 or parts[1] not in ['SH', 'SZ']:
                print(f"股票代码 {code} 的后缀无效。跳过。")
                continue
            processed_codes.append(code)
        else:
            suffix = determine_suffix(code)
            full_code = f"{code}{suffix}"
            processed_codes.append(full_code)
    return processed_codes

def main():
    # 步骤1：读取输入CSV文件（请根据实际路径修改）
    input_csv_path = r"C:\Users\minus\Desktop\crawl_stock_date\openai-东方 - 涨停池20231214.csv"

    if not os.path.exists(input_csv_path):
        print(f"未找到输入CSV文件：{input_csv_path}")
        return

    try:
        with open(input_csv_path, 'r', encoding='gbk') as f:
            lines = f.readlines()

        # 过滤掉以“日期:”开头的行和空行
        data_lines = []
        header_set = False
        # 使用逗号分隔符匹配表头行
        header_line_pattern = re.compile(r'^日期,证券代码')

        for line in lines:
            if line.startswith('日期:'):
                # 跳过以"日期:"开头的注释行
                continue
            if line.strip() == '':
                # 跳过空行
                continue
            if header_line_pattern.match(line):
                # 如果匹配到表头行且还未设置表头，则保留
                if not header_set:
                    data_lines.append(line)
                    header_set = True
                else:
                    # 已有表头则跳过后面的表头行
                    continue
            else:
                data_lines.append(line)

        if not header_set:
            print("未找到有效的表头信息。请检查CSV文件格式。")
            print("请确保CSV文件中包含类似 '日期,证券代码,...' 的表头行。")
            # 调试信息：打印前10行过滤后的数据
            print("CSV文件的前10行（去除注释和空行）：")
            print('\n'.join(data_lines[:10]))
            return

        # 将过滤后的数据行合并为一个字符串
        data_str = ''.join(data_lines)

        # 使用StringIO读取过滤后的数据，并使用逗号作为分隔符
        df = pd.read_csv(StringIO(data_str), sep=',', encoding='gbk', dayfirst=True)

        # 清理列名：去除前后空格并转换为大写
        df.columns = df.columns.str.strip().str.upper()

        # 检查是否存在“证券代码”列
        if '证券代码' not in df.columns:
            print("CSV文件中不包含 '证券代码' 列。请检查列名是否正确。")
            print("当前列名：", df.columns.tolist())
            return

        # 确保“日期”列为日期类型
        df['日期'] = pd.to_datetime(df['日期'], dayfirst=True, errors='coerce')

        # 检查是否有未解析的日期
        if df['日期'].isnull().any():
            print("警告：有些日期未能正确解析。请检查日期格式。")

        # 确保“涨停基因”列为数值类型，处理非数值数据
        df['涨停基因'] = pd.to_numeric(df['涨停基因'], errors='coerce')

        # 调试打印数据预览
        print("清理后的列名：", df.columns.tolist())
        print("数据预览（前5行）：")
        print(df.head())

    except Exception as e:
        print(f"读取输入CSV文件时出错：{e}")
        return

    # 步骤2：获取用户输入的股票代码（支持多行输入）
    print("\n请输入一个或多个股票代码，使用逗号、空格或换行符分隔。")
    print("输入完成后请按回车换行，再按一次回车结束输入。")
    print("示例：")
    print(" - 单行：603278.SH 或 603278,300220,002086.SZ")
    print(" - 多行：可多行输入代码，每行一个或多个代码，完成后输入空行结束。")

    # 读取多行输入，直到用户输入空行
    input_lines = []
    while True:
        try:
            line = input()
            if line.strip() == '':
                break
            input_lines.append(line)
        except EOFError:
            break

    # 将多行输入合并为一个字符串
    user_input = ' '.join(input_lines)

    # 使用正则表达式分割输入，支持逗号、空格和换行符
    input_codes = re.split(r'[,\s]+', user_input)

    # 处理股票代码，确保格式正确
    stock_codes = process_stock_codes(input_codes)

    # 调试信息：打印拆分后的代码列表和处理后的股票代码列表
    print("\n拆分后的代码列表：", input_codes)
    print("处理后的股票代码列表：", stock_codes)

    if not stock_codes:
        print("未输入有效的股票代码。退出。")
        return

    print(f"\n处理后的股票代码：{stock_codes}")

    # 确保“证券代码”列为字符串类型并转换为大写
    df['证券代码'] = df['证券代码'].astype(str).str.upper()

    # 步骤3：根据股票代码过滤数据
    filtered_data = df[df['证券代码'].isin(stock_codes)].copy()

    if filtered_data.empty:
        print("未找到输入股票代码的相关数据。")
        return

    # 按证券代码和日期排序
    filtered_data = filtered_data.sort_values(by=['证券代码', '日期'])

    # 步骤4：添加前交易日涨停基因、当日交易日涨停基因和涨停基因差
    filtered_data['前交易日涨停基因'] = filtered_data.groupby('证券代码')['涨停基因'].shift(1).fillna(0)
    filtered_data['当日交易日涨停基因'] = filtered_data['涨停基因']
    filtered_data['涨停基因差'] = filtered_data['当日交易日涨停基因'] - filtered_data['前交易日涨停基因']

    # 确保所有新列为数值类型
    filtered_data['前交易日涨停基因'] = pd.to_numeric(filtered_data['前交易日涨停基因'], errors='coerce').fillna(0)
    filtered_data['当日交易日涨停基因'] = pd.to_numeric(filtered_data['当日交易日涨停基因'], errors='coerce').fillna(0)
    filtered_data['涨停基因差'] = pd.to_numeric(filtered_data['涨停基因差'], errors='coerce').fillna(0)

    # Reorder columns as per user requirement
    desired_columns = [
        '日期', '证券代码', '证券简称', '最新价', '涨幅', '板块名称',
        '涨停基因', '连板', '封板时间', '封板数', '封板额', '换手率', '净流入',
        '前交易日涨停基因', '当日交易日涨停基因', '涨停基因差'
    ]

    # 检查是否存在所有需要的列
    missing_columns = [col for col in desired_columns if col not in filtered_data.columns]
    if missing_columns:
        print(f"警告：缺少列 {missing_columns}，无法添加至输出文件中。")
        # 为缺失的列添加NaN
        for col in missing_columns:
            filtered_data[col] = pd.NA

    # 选择需要的列
    output_data = filtered_data[desired_columns]

    # 步骤5：将数据输出到新的CSV文件（请根据实际路径修改）
    output_csv_path = r"C:\Users\minus\Desktop\crawl_stock_date\OpenAI 01 - 20241209 当天涨停龙头 自动化 对比 连板 基因.csv"

    try:
        # 在排序步骤中，保持按证券代码和日期排序
        output_data = output_data.sort_values(by=['证券代码', '日期'])

        # 将“日期”列转换为字符串格式（如 'dd/mm/yyyy'）
        output_data['日期'] = output_data['日期'].dt.strftime('%d/%m/%Y')

        # 保存到CSV文件
        output_data.to_csv(output_csv_path, index=False, encoding='gbk')
        print(f"\n数据已成功写入：{output_csv_path}")
    except Exception as e:
        print(f"写入输出CSV文件时出错：{e}")

if __name__ == "__main__":
    main()

主要修改点说明

1. 移除步骤5中的单独按日期排序：

   • 原代码中，步骤5对 output_data 仅按 ['日期'] 进行了排序，这会打乱 ['证券代码', '日期'] 的初始排序。
   • 修改后，保持按 ['证券代码', '日期'] 的排序：

     python
     output_data = output_data.sort_values(by=['证券代码', '日期'])

2. 确保在转换日期格式之前完成所有排序操作：

   • 在将 日期 列转换为字符串格式之前，已经按 ['证券代码', '日期'] 进行了排序，确保排序的准确性。

3. 处理 涨停基因差 计算中的缺失值：

   • 使用 fillna(0) 来处理缺失值，避免在计算过程中出现 NaN 或非数值的问题。

4. 确保所有需要的列都存在：

   • 如果某些列在原始数据中缺失，代码会自动添加这些列，并填充为 NaN，避免在输出时出错。

关于 #VALUE! 的处理

在您的输出数据中出现了 #VALUE!，这通常是由于某些单元格中的数据格式不正确或存在错误。以下是一些可能的原因及解决方案：

1. 非数值数据：

   • 确保在进行数值计算（如 涨停基因差）时，所有参与计算的列都是数值类型。如果有非数值数据，使用 pd.to_numeric 并设置 errors='coerce' 将其转换为 NaN，然后使用 fillna(0) 填充。

2. Excel 打开CSV文件时的自动转换：

   • 有时，Excel 在打开CSV文件时会自动尝试转换某些数据格式，导致出现 #VALUE!。您可以尝试以下方法：
     • 在保存CSV时，确保所有数值列不包含非数值字符。
     • 在Excel中导入CSV时，选择适当的数据类型。

3. 调试数据：

   • 在保存CSV之前，您可以打印出部分数据，确保所有数值列的数据都是正确的。例如：

     python
     print(output_data[['前交易日涨停基因', '当日交易日涨停基因', '涨停基因差']].head())

最终建议

• 排序：确保在所有数据处理完成后，仅按 ['证券代码', '日期'] 进行排序，避免多次排序导致的混乱。
• 数据验证：在导出CSV之前，进行数据验证，确保所有计算结果都是有效的数值。
• 处理缺失值：合理处理缺失值，避免在计算或导出时出现错误。

通过以上修改，您的数据应该能够按照预期的顺序进行排序，并且避免出现 #VALUE! 这样的错误。如果在修改后仍然遇到问题，请提供更多详细信息，以便进一步协助您解决问题。

为了满足您的需求，我已经在代码中增加了不同股票代码之间的分隔行，并确保每次保存文件前会清除已有的数据。以下是完整的修改后的代码：

python
import pandas as pd
import os
import re
from io import StringIO

def determine_suffix(stock_code):
    """
    根据股票代码确定后缀。
    以'6'开头的代码添加'.SH'，其他的添加'.SZ'。
    """
    if stock_code.startswith('6'):
        return '.SH'
    else:
        return '.SZ'

def process_stock_codes(input_codes):
    """
    处理输入的股票代码，确保它们具有正确的后缀。
    """
    processed_codes = []
    for code in input_codes:
        # 去除空白、换行和逗号，并转换为大写
        code = code.strip().upper().replace(',', '').replace('\n', '').replace('\r', '')
        if not code:
            continue  # 跳过空字符串
        if '.' in code:
            # 确保后缀为.SH或.SZ
            parts = code.split('.')
            if len(parts) != 2 or parts[1] not in ['SH', 'SZ']:
                print(f"股票代码 {code} 的后缀无效。跳过。")
                continue
            processed_codes.append(code)
        else:
            suffix = determine_suffix(code)
            full_code = f"{code}{suffix}"
            processed_codes.append(full_code)
    return processed_codes

def main():
    # 步骤1：读取输入CSV文件（请根据实际路径修改）
    input_csv_path = r"C:\Users\minus\Desktop\crawl_stock_date\openai-东方 - 涨停池20231214.csv"

    if not os.path.exists(input_csv_path):
        print(f"未找到输入CSV文件：{input_csv_path}")
        return

    try:
        with open(input_csv_path, 'r', encoding='gbk') as f:
            lines = f.readlines()

        # 过滤掉以“日期:”开头的行和空行
        data_lines = []
        header_set = False
        # 使用逗号分隔符匹配表头行
        header_line_pattern = re.compile(r'^日期,证券代码')

        for line in lines:
            if line.startswith('日期:'):
                # 跳过以"日期:"开头的注释行
                continue
            if line.strip() == '':
                # 跳过空行
                continue
            if header_line_pattern.match(line):
                # 如果匹配到表头行且还未设置表头，则保留
                if not header_set:
                    data_lines.append(line)
                    header_set = True
                else:
                    # 已有表头则跳过后面的表头行
                    continue
            else:
                data_lines.append(line)

        if not header_set:
            print("未找到有效的表头信息。请检查CSV文件格式。")
            print("请确保CSV文件中包含类似 '日期,证券代码,...' 的表头行。")
            # 调试信息：打印前10行过滤后的数据
            print("CSV文件的前10行（去除注释和空行）：")
            print('\n'.join(data_lines[:10]))
            return

        # 将过滤后的数据行合并为一个字符串
        data_str = ''.join(data_lines)

        # 使用StringIO读取过滤后的数据，并使用逗号作为分隔符
        df = pd.read_csv(StringIO(data_str), sep=',', encoding='gbk', dayfirst=True)

        # 清理列名：去除前后空格并转换为大写
        df.columns = df.columns.str.strip().str.upper()

        # 检查是否存在“证券代码”列
        if '证券代码' not in df.columns:
            print("CSV文件中不包含 '证券代码' 列。请检查列名是否正确。")
            print("当前列名：", df.columns.tolist())
            return

        # 确保“日期”列为日期类型
        df['日期'] = pd.to_datetime(df['日期'], dayfirst=True, errors='coerce')

        # 检查是否有未解析的日期
        if df['日期'].isnull().any():
            print("警告：有些日期未能正确解析。请检查日期格式。")

        # 确保“涨停基因”列为数值类型，处理非数值数据
        df['涨停基因'] = pd.to_numeric(df['涨停基因'], errors='coerce')

        # 调试打印数据预览
        print("清理后的列名：", df.columns.tolist())
        print("数据预览（前5行）：")
        print(df.head())

    except Exception as e:
        print(f"读取输入CSV文件时出错：{e}")
        return

    # 步骤2：获取用户输入的股票代码（支持多行输入）
    print("\n请输入一个或多个股票代码，使用逗号、空格或换行符分隔。")
    print("输入完成后请按回车换行，再按一次回车结束输入。")
    print("示例：")
    print(" - 单行：603278.SH 或 603278,300220,002086.SZ")
    print(" - 多行：可多行输入代码，每行一个或多个代码，完成后输入空行结束。")

    # 读取多行输入，直到用户输入空行
    input_lines = []
    while True:
        try:
            line = input()
            if line.strip() == '':
                break
            input_lines.append(line)
        except EOFError:
            break

    # 将多行输入合并为一个字符串
    user_input = ' '.join(input_lines)

    # 使用正则表达式分割输入，支持逗号、空格和换行符
    input_codes = re.split(r'[,\s]+', user_input)

    # 处理股票代码，确保格式正确
    stock_codes = process_stock_codes(input_codes)

    # 调试信息：打印拆分后的代码列表和处理后的股票代码列表
    print("\n拆分后的代码列表：", input_codes)
    print("处理后的股票代码列表：", stock_codes)

    if not stock_codes:
        print("未输入有效的股票代码。退出。")
        return

    print(f"\n处理后的股票代码：{stock_codes}")

    # 确保“证券代码”列为字符串类型并转换为大写
    df['证券代码'] = df['证券代码'].astype(str).str.upper()

    # 步骤3：根据股票代码过滤数据
    filtered_data = df[df['证券代码'].isin(stock_codes)].copy()

    if filtered_data.empty:
        print("未找到输入股票代码的相关数据。")
        return

    # 按证券代码和日期排序
    filtered_data = filtered_data.sort_values(by=['证券代码', '日期'])

    # 步骤4：添加前交易日涨停基因、当日交易日涨停基因和涨停基因差
    filtered_data['前交易日涨停基因'] = filtered_data.groupby('证券代码')['涨停基因'].shift(1).fillna(0)
    filtered_data['当日交易日涨停基因'] = filtered_data['涨停基因']
    filtered_data['涨停基因差'] = filtered_data['当日交易日涨停基因'] - filtered_data['前交易日涨停基因']

    # 确保所有新列为数值类型
    filtered_data['前交易日涨停基因'] = pd.to_numeric(filtered_data['前交易日涨停基因'], errors='coerce').fillna(0)
    filtered_data['当日交易日涨停基因'] = pd.to_numeric(filtered_data['当日交易日涨停基因'], errors='coerce').fillna(0)
    filtered_data['涨停基因差'] = pd.to_numeric(filtered_data['涨停基因差'], errors='coerce').fillna(0)

    # Reorder columns as per user requirement
    desired_columns = [
        '日期', '证券代码', '证券简称', '最新价', '涨幅', '板块名称',
        '涨停基因', '连板', '封板时间', '封板数', '封板额', '换手率', '净流入',
        '前交易日涨停基因', '当日交易日涨停基因', '涨停基因差'
    ]

    # 检查是否存在所有需要的列
    missing_columns = [col for col in desired_columns if col not in filtered_data.columns]
    if missing_columns:
        print(f"警告：缺少列 {missing_columns}，无法添加至输出文件中。")
        # 为缺失的列添加NaN
        for col in missing_columns:
            filtered_data[col] = pd.NA

    # 选择需要的列
    output_data = filtered_data[desired_columns]

    # 步骤5：添加分隔行
    output_data_sorted = output_data.sort_values(by=['证券代码', '日期'])
    separator = pd.DataFrame([desired_columns], columns=desired_columns)
    grouped = output_data_sorted.groupby('证券代码')
    output_with_separators = pd.concat([group.append(separator, ignore_index=True) for name, group in grouped], ignore_index=True)
    output_with_separators = output_with_separators[:-1]  # 移除最后多余的分隔行

    # 步骤6：将数据输出到新的CSV文件（请根据实际路径修改）
    output_csv_path = r"C:\Users\minus\Desktop\crawl_stock_date\OpenAI 01 - 20241209 当天涨停龙头 自动化 对比 连板 基因.csv"

    try:
        # 清除已有的文件内容
        with open(output_csv_path, 'w', encoding='gbk') as f:
            pass

        # 将“日期”列转换为字符串格式（如 'dd/mm/yyyy'）
        output_with_separators['日期'] = pd.to_datetime(output_with_separators['日期'], errors='coerce').dt.strftime('%d/%m/%Y')

        # 保存到CSV文件，不包含索引
        output_with_separators.to_csv(output_csv_path, index=False, encoding='gbk', header=False)

        # 手动写入分隔行的表头
        with open(output_csv_path, 'r+', encoding='gbk') as f:
            content = f.read()
            f.seek(0, 0)
            f.write('\t'.join(desired_columns) + '\n' + content)

        print(f"\n数据已成功写入：{output_csv_path}")
    except Exception as e:
        print(f"写入输出CSV文件时出错：{e}")

if __name__ == "__main__":
    main()

主要修改点：

1. 添加分隔行：

   • 使用groupby按证券代码分组，然后在每组之间插入表头作为分隔行。
   • 移除了最后多余的分隔行以保持文件整洁。

2. 清除已有数据后保存新数据：

   • 在写入新文件前，使用with open(output_csv_path, 'w', encoding='gbk') as f: pass清空文件内容。
   • 保存数据时设置header=False，然后手动在文件顶部写入表头，确保每个分隔行都有表头。

通过这些修改，最终生成的CSV文件将在不同股票代码的数据之间插入表头作为分隔，并且每次运行脚本时都会清除旧数据，确保输出文件仅包含最新的数据。

您好！感谢您提供详细的运行日志和代码输出信息。根据您提供的内容，我注意到以下几点需要处理：

1. 日期解析警告：

   警告：有些日期未能正确解析。请检查日期格式。
   

   这表示在您的数据中，有些日期无法被正确解析为日期类型。尽管在数据预览中大部分日期看起来正常，但可能存在格式不一致或异常的日期值。

2. FutureWarning 警告：

   FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.
   

   这是因为 DataFrame.append 方法在未来的 pandas 版本中将被移除，建议使用 pandas.concat 代替。

为了优化您的脚本，并解决上述警告，我将提供以下修改建议和完整的代码：

1. 解决 FutureWarning 警告

您在添加分隔行时使用了 group.append(separator, ignore_index=True)，这会触发 FutureWarning。我们可以使用 pd.concat 直接合并数据帧来替代 append 方法。

2. 处理日期解析警告

确保所有日期格式一致，并处理可能的异常日期格式。可以在日期解析时更严格地指定日期格式，或者在读取数据之前清洗日期列。

3. 优化添加分隔行的逻辑

在不同股票代码的数据之间添加分隔行（表头），可以通过分组后进行拼接来实现。以下代码示例展示了如何实现这一点，并确保新文件写入前清空旧数据。

完整的修改后代码

python
import pandas as pd
import os
import re
from io import StringIO

def determine_suffix(stock_code):
    """
    根据股票代码确定后缀。
    以'6'开头的代码添加'.SH'，其他的添加'.SZ'。
    """
    if stock_code.startswith('6'):
        return '.SH'
    else:
        return '.SZ'

def process_stock_codes(input_codes):
    """
    处理输入的股票代码，确保它们具有正确的后缀。
    """
    processed_codes = []
    for code in input_codes:
        # 去除空白、换行和逗号，并转换为大写
        code = code.strip().upper().replace(',', '').replace('\n', '').replace('\r', '')
        if not code:
            continue  # 跳过空字符串
        if '.' in code:
            # 确保后缀为.SH或.SZ
            parts = code.split('.')
            if len(parts) != 2 or parts[1] not in ['SH', 'SZ']:
                print(f"股票代码 {code} 的后缀无效。跳过。")
                continue
            processed_codes.append(code)
        else:
            suffix = determine_suffix(code)
            full_code = f"{code}{suffix}"
            processed_codes.append(full_code)
    return processed_codes

def main():
    # 步骤1：读取输入CSV文件（请根据实际路径修改）
    input_csv_path = r"C:\Users\minus\Desktop\crawl_stock_date\openai-东方 - 涨停池20231214.csv"

    if not os.path.exists(input_csv_path):
        print(f"未找到输入CSV文件：{input_csv_path}")
        return

    try:
        with open(input_csv_path, 'r', encoding='gbk') as f:
            lines = f.readlines()

        # 过滤掉以“日期:”开头的行和空行
        data_lines = []
        header_set = False
        # 使用逗号分隔符匹配表头行
        header_line_pattern = re.compile(r'^日期,证券代码')

        for line in lines:
            if line.startswith('日期:'):
                # 跳过以"日期:"开头的注释行
                continue
            if line.strip() == '':
                # 跳过空行
                continue
            if header_line_pattern.match(line):
                # 如果匹配到表头行且还未设置表头，则保留
                if not header_set:
                    data_lines.append(line)
                    header_set = True
                else:
                    # 已有表头则跳过后面的表头行
                    continue
            else:
                data_lines.append(line)

        if not header_set:
            print("未找到有效的表头信息。请检查CSV文件格式。")
            print("请确保CSV文件中包含类似 '日期,证券代码,...' 的表头行。")
            # 调试信息：打印前10行过滤后的数据
            print("CSV文件的前10行（去除注释和空行）：")
            print('\n'.join(data_lines[:10]))
            return

        # 将过滤后的数据行合并为一个字符串
        data_str = ''.join(data_lines)

        # 使用StringIO读取过滤后的数据，并使用逗号作为分隔符
        df = pd.read_csv(StringIO(data_str), sep=',', encoding='gbk', dayfirst=True)

        # 清理列名：去除前后空格并转换为大写
        df.columns = df.columns.str.strip().str.upper()

        # 检查是否存在“证券代码”列
        if '证券代码' not in df.columns:
            print("CSV文件中不包含 '证券代码' 列。请检查列名是否正确。")
            print("当前列名：", df.columns.tolist())
            return

        # 确保“日期”列为日期类型
        # 尝试更严格地解析日期格式，例如指定格式为 'dd/mm/yyyy' 或 'yyyy-mm-dd'
        # 这里假设日期格式为 'dd/mm/yyyy'，根据实际情况调整
        try:
            df['日期'] = pd.to_datetime(df['日期'], dayfirst=True, format='%d/%m/%Y', errors='coerce')
        except Exception as e:
            print(f"日期解析时出错：{e}")
            df['日期'] = pd.to_datetime(df['日期'], dayfirst=True, errors='coerce')

        # 检查是否有未解析的日期
        if df['日期'].isnull().any():
            print("警告：有些日期未能正确解析。请检查日期格式。")
            # 显示无法解析的日期值
            invalid_dates = df[df['日期'].isnull()]['日期']
            print("无法解析的日期值：")
            print(invalid_dates.unique())

        # 确保“涨停基因”列为数值类型，处理非数值数据
        df['涨停基因'] = pd.to_numeric(df['涨停基因'], errors='coerce')

        # 调试打印数据预览
        print("清理后的列名：", df.columns.tolist())
        print("数据预览（前5行）：")
        print(df.head())

    except Exception as e:
        print(f"读取输入CSV文件时出错：{e}")
        return

    # 步骤2：获取用户输入的股票代码（支持多行输入）
    print("\n请输入一个或多个股票代码，使用逗号、空格或换行符分隔。")
    print("输入完成后请按回车换行，再按一次回车结束输入。")
    print("示例：")
    print(" - 单行：603278.SH 或 603278,300220,002086.SZ")
    print(" - 多行：可多行输入代码，每行一个或多个代码，完成后输入空行结束。")

    # 读取多行输入，直到用户输入空行
    input_lines = []
    while True:
        try:
            line = input()
            if line.strip() == '':
                break
            input_lines.append(line)
        except EOFError:
            break

    # 将多行输入合并为一个字符串
    user_input = ' '.join(input_lines)

    # 使用正则表达式分割输入，支持逗号、空格和换行符
    input_codes = re.split(r'[,\s]+', user_input)

    # 处理股票代码，确保格式正确
    stock_codes = process_stock_codes(input_codes)

    # 调试信息：打印拆分后的代码列表和处理后的股票代码列表
    print("\n拆分后的代码列表：", input_codes)
    print("处理后的股票代码列表：", stock_codes)

    if not stock_codes:
        print("未输入有效的股票代码。退出。")
        return

    print(f"\n处理后的股票代码：{stock_codes}")

    # 确保“证券代码”列为字符串类型并转换为大写
    df['证券代码'] = df['证券代码'].astype(str).str.upper()

    # 步骤3：根据股票代码过滤数据
    filtered_data = df[df['证券代码'].isin(stock_codes)].copy()

    if filtered_data.empty:
        print("未找到输入股票代码的相关数据。")
        return

    # 按证券代码和日期排序
    filtered_data = filtered_data.sort_values(by=['证券代码', '日期'])

    # 步骤4：添加前交易日涨停基因、当日交易日涨停基因和涨停基因差
    filtered_data['前交易日涨停基因'] = filtered_data.groupby('证券代码')['涨停基因'].shift(1).fillna(0)
    filtered_data['当日交易日涨停基因'] = filtered_data['涨停基因']
    filtered_data['涨停基因差'] = filtered_data['当日交易日涨停基因'] - filtered_data['前交易日涨停基因']

    # 确保所有新列为数值类型
    filtered_data['前交易日涨停基因'] = pd.to_numeric(filtered_data['前交易日涨停基因'], errors='coerce').fillna(0)
    filtered_data['当日交易日涨停基因'] = pd.to_numeric(filtered_data['当日交易日涨停基因'], errors='coerce').fillna(0)
    filtered_data['涨停基因差'] = pd.to_numeric(filtered_data['涨停基因差'], errors='coerce').fillna(0)

    # Reorder columns as per user requirement
    desired_columns = [
        '日期', '证券代码', '证券简称', '最新价', '涨幅', '板块名称',
        '涨停基因', '连板', '封板时间', '封板数', '封板额', '换手率', '净流入',
        '前交易日涨停基因', '当日交易日涨停基因', '涨停基因差'
    ]

    # 检查是否存在所有需要的列
    missing_columns = [col for col in desired_columns if col not in filtered_data.columns]
    if missing_columns:
        print(f"警告：缺少列 {missing_columns}，无法添加至输出文件中。")
        # 为缺失的列添加NaN
        for col in missing_columns:
            filtered_data[col] = pd.NA

    # 选择需要的列
    output_data = filtered_data[desired_columns]

    # 步骤5：添加分隔行
    # 创建分隔行（表头）
    separator = pd.DataFrame([desired_columns], columns=desired_columns)

    # 按证券代码分组并在每组之间插入分隔行
    grouped = output_data.sort_values(by=['证券代码', '日期']).groupby('证券代码')

    # 使用列表存储各组数据和分隔行
    output_list = []
    for name, group in grouped:
        output_list.append(group)
        output_list.append(separator)  # 添加分隔行

    # 合并所有数据帧
    output_with_separators = pd.concat(output_list, ignore_index=True)

    # 移除最后一个多余的分隔行
    if output_with_separators.iloc[-1].tolist() == desired_columns:
        output_with_separators = output_with_separators[:-1]

    # 步骤6：将数据输出到新的CSV文件（请根据实际路径修改）
    output_csv_path = r"C:\Users\minus\Desktop\crawl_stock_date\OpenAI 01 - 20241209 当天涨停龙头 自动化 对比 连板 基因.csv"

    try:
        # 确保输出目录存在
        os.makedirs(os.path.dirname(output_csv_path), exist_ok=True)

        # 将“日期”列转换为字符串格式（如 'dd/mm/yyyy'）
        output_with_separators['日期'] = pd.to_datetime(output_with_separators['日期'], errors='coerce').dt.strftime('%d/%m/%Y')

        # 保存到CSV文件，不包含索引和表头
        output_with_separators.to_csv(output_csv_path, index=False, encoding='gbk', header=False)

        print(f"\n数据已成功写入：{output_csv_path}")
    except Exception as e:
        print(f"写入输出CSV文件时出错：{e}")

if __name__ == "__main__":
    main()

主要修改点说明

1. 替换 append 方法：

   python
   # 原代码使用 append 方法，触发 FutureWarning
   # output_with_separators = pd.concat([group.append(separator, ignore_index=True) for name, group in grouped], ignore_index=True)
   
   # 修改后使用 pd.concat 直接合并数据帧
   output_with_separators = pd.concat(output_list, ignore_index=True)

   通过将各组数据和分隔行存储在 output_list 列表中，然后使用 pd.concat 一次性合并，避免使用被弃用的 append 方法。

2. 处理日期解析警告：

   • 尝试指定日期格式：在 pd.to_datetime 中指定 format 参数，可以提高解析的准确性。
   • 显示无法解析的日期值：在发现有未解析的日期时，打印出具体的异常日期值，便于进一步清洗数据。

   python
   try:
       df['日期'] = pd.to_datetime(df['日期'], dayfirst=True, format='%d/%m/%Y', errors='coerce')
   except Exception as e:
       print(f"日期解析时出错：{e}")
       df['日期'] = pd.to_datetime(df['日期'], dayfirst=True, errors='coerce')
   
   if df['日期'].isnull().any():
       print("警告：有些日期未能正确解析。请检查日期格式。")
       # 显示无法解析的日期值
       invalid_dates = df[df['日期'].isnull()]['日期']
       print("无法解析的日期值：")
       print(invalid_dates.unique())

   根据实际的日期格式（如 dd/mm/yyyy 或 yyyy-mm-dd），调整 format 参数。如果不确定，可以先尝试不指定格式，让 pandas 尝试自动解析。

3. 确保输出目录存在： 在保存文件之前，确保输出目录存在，避免因路径不存在而导致的错误。

   python
   os.makedirs(os.path.dirname(output_csv_path), exist_ok=True)

4. 优化分隔行添加逻辑： 通过分组后依次添加数据和分隔行，确保不同股票代码的数据之间有清晰的分隔。

   python
   output_list = []
   for name, group in grouped:
       output_list.append(group)
       output_list.append(separator)  # 添加分隔行
   
   # 合并所有数据帧
   output_with_separators = pd.concat(output_list, ignore_index=True)
   
   # 移除最后一个多余的分隔行
   if output_with_separators.iloc[-1].tolist() == desired_columns:
       output_with_separators = output_with_separators[:-1]

5. 转换日期格式前确保日期列存在： 在将 日期 列转换为字符串格式之前，确保所有日期已正确解析。

   python
   output_with_separators['日期'] = pd.to_datetime(output_with_separators['日期'], errors='coerce').dt.strftime('%d/%m/%Y')

运行脚本后的预期结果

• 日期解析警告：如果有些日期格式不正确或存在异常值，脚本会在控制台打印出这些无法解析的日期值，您可以根据这些信息进一步清洗或修正原始数据。

• 分隔行：在输出的 CSV 文件中，不同股票代码的数据之间会插入一行表头作为分隔，便于阅读和区分。

• FutureWarning 消失：通过替换 append 方法，FutureWarning 将不再出现。

额外建议

1. 验证输出 CSV 文件： 在打开输出的 CSV 文件时，确保分隔行（表头）不会影响后续的数据处理或导入。如果需要进一步处理数据，可以考虑使用 Excel 或其他工具进行预处理。

2. 数据清洗： 确保原始 CSV 文件中的日期格式一致，避免因格式不一致导致的解析问题。如果数据量较大，建议使用脚本批量处理异常日期。

3. 代码优化： 您可以将重复使用的代码段封装成函数，以提高代码的可维护性和可读性。

如果您在运行修改后的脚本时遇到任何问题，或有其他需求，请随时告知！

非常抱歉您在运行脚本时遇到了问题。根据您的描述，主要问题包括：

1. 输出文件的第一行缺少表头。
2. 许多列缺少相关的日期。
3. 部分行的数据不完整。

这些问题可能源于以下几个方面：

• 表头处理不当：在插入分隔行时，表头可能被误处理，导致输出文件的第一行缺少表头。
• 日期解析失败：某些日期格式不一致或数据异常，导致日期无法正确解析。
• 分隔行插入方式：在数据之间插入表头作为分隔行，可能导致数据行与分隔行混淆，从而产生不完整的数据行。

为了彻底解决这些问题，我将为您提供一个优化后的完整代码，确保：

1. 输出文件的第一行包含正确的表头。
2. 所有日期均被正确解析，并处理无法解析的日期。
3. 插入分隔行时，确保数据完整且不影响实际数据行。

优化后的完整代码

python
import pandas as pd
import os
import re
from io import StringIO

def determine_suffix(stock_code):
    """
    根据股票代码确定后缀。
    以'6'开头的代码添加'.SH'，其他的添加'.SZ'。
    """
    if stock_code.startswith('6'):
        return '.SH'
    else:
        return '.SZ'

def process_stock_codes(input_codes):
    """
    处理输入的股票代码，确保它们具有正确的后缀。
    """
    processed_codes = []
    for code in input_codes:
        # 去除空白、换行和逗号，并转换为大写
        code = code.strip().upper().replace(',', '').replace('\n', '').replace('\r', '')
        if not code:
            continue  # 跳过空字符串
        if '.' in code:
            # 确保后缀为.SH或.SZ
            parts = code.split('.')
            if len(parts) != 2 or parts[1] not in ['SH', 'SZ']:
                print(f"股票代码 {code} 的后缀无效。跳过。")
                continue
            processed_codes.append(code)
        else:
            suffix = determine_suffix(code)
            full_code = f"{code}{suffix}"
            processed_codes.append(full_code)
    return processed_codes

def main():
    # 步骤1：读取输入CSV文件（请根据实际路径修改）
    input_csv_path = r"C:\Users\minus\Desktop\crawl_stock_date\openai-东方 - 涨停池20231214.csv"

    if not os.path.exists(input_csv_path):
        print(f"未找到输入CSV文件：{input_csv_path}")
        return

    try:
        with open(input_csv_path, 'r', encoding='gbk') as f:
            lines = f.readlines()

        # 过滤掉以“日期:”开头的行和空行
        data_lines = []
        header_set = False
        # 使用逗号分隔符匹配表头行
        header_line_pattern = re.compile(r'^日期,证券代码')

        for line in lines:
            if line.startswith('日期:'):
                # 跳过以"日期:"开头的注释行
                continue
            if line.strip() == '':
                # 跳过空行
                continue
            if header_line_pattern.match(line):
                # 如果匹配到表头行且还未设置表头，则保留
                if not header_set:
                    header_line = line.strip()
                    header_set = True
                else:
                    # 已有表头则跳过后面的表头行
                    continue
            else:
                data_lines.append(line)

        if not header_set:
            print("未找到有效的表头信息。请检查CSV文件格式。")
            print("请确保CSV文件中包含类似 '日期,证券代码,...' 的表头行。")
            # 调试信息：打印前10行过滤后的数据
            print("CSV文件的前10行（去除注释和空行）：")
            print('\n'.join(data_lines[:10]))
            return

        # 将过滤后的数据行合并为一个字符串
        data_str = ''.join(data_lines)

        # 使用StringIO读取过滤后的数据，并使用逗号作为分隔符
        df = pd.read_csv(StringIO(data_str), sep=',', encoding='gbk', dayfirst=True)

        # 清理列名：去除前后空格并转换为大写
        df.columns = df.columns.str.strip().str.upper()

        # 检查是否存在“证券代码”列
        if '证券代码' not in df.columns:
            print("CSV文件中不包含 '证券代码' 列。请检查列名是否正确。")
            print("当前列名：", df.columns.tolist())
            return

        # 保留原始日期字符串以便后续调试
        original_dates = df['日期'].astype(str).copy()

        # 确保“日期”列为日期类型
        # 尝试更严格地解析日期格式，例如指定格式为 'dd/mm/yyyy' 或 'yyyy-mm-dd'
        # 这里先尝试自动解析
        df['日期'] = pd.to_datetime(df['日期'], dayfirst=True, errors='coerce')

        # 检查是否有未解析的日期
        if df['日期'].isnull().any():
            print("警告：有些日期未能正确解析。请检查日期格式。")
            # 显示无法解析的日期值
            invalid_dates = original_dates[df['日期'].isnull()].unique()
            print("无法解析的日期值：")
            print(invalid_dates)

        # 确保“涨停基因”列为数值类型，处理非数值数据
        df['涨停基因'] = pd.to_numeric(df['涨停基因'], errors='coerce').fillna(0)

        # 调试打印数据预览
        print("清理后的列名：", df.columns.tolist())
        print("数据预览（前5行）：")
        print(df.head())

    except Exception as e:
        print(f"读取输入CSV文件时出错：{e}")
        return

    # 步骤2：获取用户输入的股票代码（支持多行输入）
    print("\n请输入一个或多个股票代码，使用逗号、空格或换行符分隔。")
    print("输入完成后请按回车换行，再按一次回车结束输入。")
    print("示例：")
    print(" - 单行：603278.SH 或 603278,300220,002086.SZ")
    print(" - 多行：可多行输入代码，每行一个或多个代码，完成后输入空行结束。")

    # 读取多行输入，直到用户输入空行
    input_lines = []
    while True:
        try:
            line = input()
            if line.strip() == '':
                break
            input_lines.append(line)
        except EOFError:
            break

    # 将多行输入合并为一个字符串
    user_input = ' '.join(input_lines)

    # 使用正则表达式分割输入，支持逗号、空格和换行符
    input_codes = re.split(r'[,\s]+', user_input)

    # 处理股票代码，确保格式正确
    stock_codes = process_stock_codes(input_codes)

    # 调试信息：打印拆分后的代码列表和处理后的股票代码列表
    print("\n拆分后的代码列表：", input_codes)
    print("处理后的股票代码列表：", stock_codes)

    if not stock_codes:
        print("未输入有效的股票代码。退出。")
        return

    print(f"\n处理后的股票代码：{stock_codes}")

    # 确保“证券代码”列为字符串类型并转换为大写
    df['证券代码'] = df['证券代码'].astype(str).str.upper()

    # 步骤3：根据股票代码过滤数据
    filtered_data = df[df['证券代码'].isin(stock_codes)].copy()

    if filtered_data.empty:
        print("未找到输入股票代码的相关数据。")
        return

    # 按证券代码和日期排序
    filtered_data = filtered_data.sort_values(by=['证券代码', '日期'])

    # 步骤4：添加前交易日涨停基因、当日交易日涨停基因和涨停基因差
    filtered_data['前交易日涨停基因'] = filtered_data.groupby('证券代码')['涨停基因'].shift(1).fillna(0)
    filtered_data['当日交易日涨停基因'] = filtered_data['涨停基因']
    filtered_data['涨停基因差'] = filtered_data['当日交易日涨停基因'] - filtered_data['前交易日涨停基因']

    # 确保所有新列为数值类型
    filtered_data['前交易日涨停基因'] = pd.to_numeric(filtered_data['前交易日涨停基因'], errors='coerce').fillna(0)
    filtered_data['当日交易日涨停基因'] = pd.to_numeric(filtered_data['当日交易日涨停基因'], errors='coerce').fillna(0)
    filtered_data['涨停基因差'] = pd.to_numeric(filtered_data['涨停基因差'], errors='coerce').fillna(0)

    # Reorder columns as per user requirement
    desired_columns = [
        '日期', '证券代码', '证券简称', '最新价', '涨幅', '板块名称',
        '涨停基因', '连板', '封板时间', '封板数', '封板额', '换手率', '净流入',
        '前交易日涨停基因', '当日交易日涨停基因', '涨停基因差'
    ]

    # 检查是否存在所有需要的列
    missing_columns = [col for col in desired_columns if col not in filtered_data.columns]
    if missing_columns:
        print(f"警告：缺少列 {missing_columns}，无法添加至输出文件中。")
        # 为缺失的列添加NaN
        for col in missing_columns:
            filtered_data[col] = pd.NA

    # 选择需要的列
    output_data = filtered_data[desired_columns]

    # 步骤5：添加分隔行
    # 创建分隔行（表头）
    separator = desired_columns

    # 初始化输出行列表，并添加表头作为第一行
    output_lines = []
    header_str = '\t'.join(desired_columns)
    output_lines.append(header_str)

    # 按证券代码分组并在每组之间插入分隔行
    grouped = output_data.sort_values(by=['证券代码', '日期']).groupby('证券代码')

    for name, group in grouped:
        # 确保 '日期' 列已格式化为 'dd/mm/yyyy'
        group['日期'] = group['日期'].dt.strftime('%d/%m/%Y').fillna('')
        # Convert group DataFrame to string with tab separator, no header, no index
        group_str = group.to_csv(sep='\t', index=False, header=False, encoding='gbk')
        output_lines.append(group_str.strip())  # 移除末尾的换行符
        # Append separator row (header)
        output_lines.append(header_str)

    # 移除最后一个多余的分隔行
    if output_lines[-1] == header_str:
        output_lines.pop()

    # 将所有行合并为一个字符串
    final_output_str = '\n'.join(output_lines)

    # 步骤6：将数据输出到新的CSV文件（请根据实际路径修改）
    output_csv_path = r"C:\Users\minus\Desktop\crawl_stock_date\OpenAI 01 - 20241209 当天涨停龙头 自动化 对比 连板 基因.csv"

    try:
        # 确保输出目录存在
        os.makedirs(os.path.dirname(output_csv_path), exist_ok=True)

        # 写入数据到CSV文件
        with open(output_csv_path, 'w', encoding='gbk') as f:
            f.write(final_output_str)

        print(f"\n数据已成功写入：{output_csv_path}")
    except Exception as e:
        print(f"写入输出CSV文件时出错：{e}")

if __name__ == "__main__":
    main()

主要修改点及说明

1. 确保输出文件第一行包含表头：

   • 在步骤5中，初始化 output_lines 列表，并将表头字符串 header_str 添加为第一行。
   • 这样，输出文件的第一行始终是表头，满足您的需求。

2. 格式化日期：

   • 在将每个分组的数据转换为字符串之前，确保 日期 列已格式化为 'dd/mm/yyyy'，并使用 .fillna('') 处理缺失的日期。
   • 这有助于避免在日期列出现 NaT 或空值，从而确保日期列的数据完整性。

3. 插入分隔行：

   • 在每个证券代码分组的数据后，插入一个分隔行，该分隔行使用表头字符串 header_str。
   • 这样，每个证券代码的数据之间都有一个清晰的分隔行，便于区分不同股票的数据。

4. 移除多余的最后一个分隔行：

   • 在所有分组处理完毕后，检查 output_lines 的最后一行是否为分隔行（表头），如果是，则将其移除，避免文件末尾多出一个不必要的分隔行。

5. 统一使用制表符作为分隔符：

   • 在读取和写入数据时，确保使用制表符 '\t' 作为分隔符，这与您提供的输出数据一致。

6. 处理缺失列：

   • 在选择需要的列之前，检查是否存在所有需要的列。如果缺少某些列，则在 filtered_data 中添加这些列，并用 NaN 填充，以确保输出文件的完整性。

7. 错误处理和调试信息：

   • 在日期解析失败时，输出无法解析的日期值，便于您进一步清洗和修正数据。
   • 在整个流程中添加了多个 print 语句，用于输出调试信息，帮助您了解脚本的执行状态。

运行脚本后的预期结果

• 输出文件的第一行包含完整的表头：

  日期	证券代码	证券简称	最新价	涨幅	板块名称	涨停基因	连板	封板时间	封板数	封板额	换手率	净流入	前交易日涨停基因	当日交易日涨停基因	涨停基因差
  

• 每个不同证券代码的数据之间插入一个表头作为分隔行，例如：

  text
  日期	证券代码	证券简称	最新价	涨幅	板块名称	涨停基因	连板	封板时间	封板数	封板额	换手率	净流入	前交易日涨停基因	当日交易日涨停基因	涨停基因差
  12/6/2024	002031.SZ	巨轮智能	2.44	9.90990991	专用设备	65.75	今日首板	9:40:15	25425900	62039196	3.4382	80873602	0	65.75	0
  13/12/2023	002031.SZ	巨轮智能	4.27	10.05154639	专用设备	66.75	今日首板	13:48:33	27951100	119351197	22.1947	574851033	65.75	66.75	1
  ...
  日期	证券代码	证券简称	最新价	涨幅	板块名称	涨停基因	连板	封板时间	封板数	封板额	换手率	净流入	前交易日涨停基因	当日交易日涨停基因	涨停基因差
  10/2/2023	002131.SZ	利欧股份	2.08	10.05291005	互联网服务	58.75	今日首板	13:32:30	26253097	54606441.76	6.8428	226817620	0	58.75	0
  17/6/2024	002131.SZ	利欧股份	1.5	10.29411765	互联网服务	59.75	今日首板	14:38:33	14423048	21634572	8.2001	85836178	58.75	59.75	1
  ...

• 所有数据行完整且包含所有必要的列，避免出现部分行数据不完整的情况。

其他建议

1. 数据清洗：

   • 检查原始CSV文件，确保所有日期格式一致且正确。如果发现无法解析的日期，建议手动修正或使用脚本进一步清洗数据。
   • 验证数据完整性，确保每行数据包含所有必要的字段，避免因数据缺失导致的后续处理问题。

2. 日志记录：

   • 为了更好地跟踪脚本执行过程中的问题，您可以考虑将日志信息写入日志文件，而不仅仅是输出到控制台。这对于大规模数据处理尤为重要。

3. 代码优化：

   • 函数封装：将重复使用的代码段封装成函数，提高代码的可读性和可维护性。
   • 错误处理：进一步完善错误处理机制，例如在发现数据异常时自动记录到日志文件，便于后续分析。

4. 测试与验证：

   • 在处理大规模数据之前，先对少量数据进行测试，确保脚本按预期工作，避免在大规模数据处理时出现不可预料的问题。

结论

通过上述优化，您的脚本应能正确生成包含表头的输出文件，并在不同证券代码的数据之间插入分隔行，确保数据的完整性和可读性。如果在运行优化后的脚本时仍遇到问题，请提供更多详细的错误信息或示例数据，以便进一步协助您解决问题。

如果您有任何其他问题或需要进一步的帮助，请随时告知！

下面是经过进一步优化和调整的完整代码版本，针对您提出的问题做了以下改善：

1. 首行添加完整表头：输出文件的第一行一定会是完整的表头行。

2. 日期格式处理：

   • 尝试解析日期，如果解析失败，则保留原始字符串或留空。
   • 在输出时将日期统一格式化为 dd/mm/yyyy，无法解析的日期以空白表示，您可以根据需要更改此策略。

3. 数据完整性：

   • 对所有行进行列检查，缺失值统一填充为空字符串，确保每行的列数和顺序与表头一致。
   • 手动逐行写出数据，以确保数据的完整性和可控性。

4. 分隔行处理：

   • 最初的需求是每支股票的数据结束后，以空行和表头行作为分隔，以示清晰。本代码实现逻辑为：
     • 第一行先输出表头
     • 对每一支股票（证券代码）的数据：输出数据行后，添加一个空行和一个表头行作为分隔
     • 对最后一组数据，在输出完成后不再追加分隔行，避免文件末尾多出不必要的表头行。

5. 额外空行（再次分明显示）：
   在每个股票代码的数据块后面添加一行空行并再次输出表头，以便在多个股票之间有明显的分隔。如果不需要在最后一组后面出现表头，请在最后一组输出数据后不再输出。

根据您的描述，假设您希望在每个股票代码的数据块结束后加一个空行和表头行，以分隔下一个股票数据块。如果您不希望在最后一组数据后重复表头，可以根据判断是最后一个分组来跳过最后的表头。

请根据需要适当微调本代码中注释的逻辑。

python
import pandas as pd
import os
import re
from io import StringIO

def determine_suffix(stock_code):
    """
    根据股票代码确定后缀。
    以'6'开头的代码添加'.SH'，其他的添加'.SZ'。
    """
    if stock_code.startswith('6'):
        return '.SH'
    else:
        return '.SZ'

def process_stock_codes(input_codes):
    """
    处理输入的股票代码，确保它们具有正确的后缀。
    """
    processed_codes = []
    for code in input_codes:
        # 去除空白、换行和逗号，并转换为大写
        code = code.strip().upper().replace(',', '').replace('\n', '').replace('\r', '')
        if not code:
            continue  # 跳过空字符串
        if '.' in code:
            # 确保后缀为.SH或.SZ
            parts = code.split('.')
            if len(parts) != 2 or parts[1] not in ['SH', 'SZ']:
                print(f"股票代码 {code} 的后缀无效。跳过。")
                continue
            processed_codes.append(code)
        else:
            suffix = determine_suffix(code)
            full_code = f"{code}{suffix}"
            processed_codes.append(full_code)
    return processed_codes

def main():
    # 步骤1：读取输入CSV文件（请根据实际路径修改）
    input_csv_path = r"C:\Users\minus\Desktop\crawl_stock_date\openai-东方 - 涨停池20231214.csv"

    if not os.path.exists(input_csv_path):
        print(f"未找到输入CSV文件：{input_csv_path}")
        return

    try:
        with open(input_csv_path, 'r', encoding='gbk') as f:
            lines = f.readlines()

        # 过滤掉以“日期:”开头的行和空行
        data_lines = []
        header_line = None
        header_set = False
        # 使用逗号分隔符匹配表头行
        header_line_pattern = re.compile(r'^日期,证券代码')

        for line in lines:
            if line.startswith('日期:'):
                # 跳过以"日期:"开头的注释行
                continue
            if line.strip() == '':
                # 跳过空行
                continue
            if header_line_pattern.match(line):
                # 如果匹配到表头行且还未设置表头，则保留该行为真正表头行
                if not header_set:
                    header_line = line.strip()
                    header_set = True
                else:
                    # 已有表头则跳过后面的表头行
                    continue
            else:
                data_lines.append(line)

        if not header_set or header_line is None:
            print("未找到有效的表头信息。请检查CSV文件格式。")
            return

        # 将过滤后的数据行合并为一个字符串
        data_str = ''.join(data_lines)

        # 使用StringIO读取过滤后的数据，并使用逗号作为分隔符
        df = pd.read_csv(StringIO(data_str), sep=',', encoding='gbk', dayfirst=True)

        # 清理列名：去除前后空格并转换为大写
        df.columns = df.columns.str.strip().str.upper()

        # 检查是否存在“证券代码”列
        if '证券代码' not in df.columns:
            print("CSV文件中不包含 '证券代码' 列。请检查列名是否正确。")
            print("当前列名：", df.columns.tolist())
            return

        # 原始日期列备用
        original_dates = df['日期'].astype(str).copy()

        # 尝试解析日期
        df['日期'] = pd.to_datetime(df['日期'], dayfirst=True, errors='coerce')

        # 检查是否有未解析的日期
        if df['日期'].isnull().any():
            print("警告：有些日期未能正确解析。请检查日期格式。")
            invalid_dates = original_dates[df['日期'].isnull()].unique()
            print("无法解析的日期值：", invalid_dates)

        # 确保“涨停基因”列为数值类型，处理非数值数据
        df['涨停基因'] = pd.to_numeric(df['涨停基因'], errors='coerce').fillna(0)

        # 调试打印数据预览
        print("清理后的列名：", df.columns.tolist())
        print("数据预览（前5行）：")
        print(df.head())

    except Exception as e:
        print(f"读取输入CSV文件时出错：{e}")
        return

    # 步骤2：获取用户输入的股票代码（支持多行输入）
    print("\n请输入一个或多个股票代码，使用逗号、空格或换行符分隔。")
    print("输入完成后请按回车换行，再按一次回车结束输入。")
    print("示例：")
    print(" - 单行：603278.SH 或 603278,300220,002086.SZ")
    print(" - 多行：可多行输入代码，每行一个或多个代码，完成后输入空行结束。")

    # 读取多行输入，直到用户输入空行
    input_lines = []
    while True:
        try:
            line = input()
            if line.strip() == '':
                break
            input_lines.append(line)
        except EOFError:
            break

    # 将多行输入合并为一个字符串
    user_input = ' '.join(input_lines)

    # 使用正则表达式分割输入，支持逗号、空格和换行符
    input_codes = re.split(r'[,\s]+', user_input)

    # 处理股票代码，确保格式正确
    stock_codes = process_stock_codes(input_codes)

    # 调试信息：打印拆分后的代码列表和处理后的股票代码列表
    print("\n拆分后的代码列表：", input_codes)
    print("处理后的股票代码列表：", stock_codes)

    if not stock_codes:
        print("未输入有效的股票代码。退出。")
        return

    print(f"\n处理后的股票代码：{stock_codes}")

    # 确保“证券代码”列为字符串类型并转换为大写
    df['证券代码'] = df['证券代码'].astype(str).str.upper()

    # 步骤3：根据股票代码过滤数据
    filtered_data = df[df['证券代码'].isin(stock_codes)].copy()

    if filtered_data.empty:
        print("未找到输入股票代码的相关数据。")
        return

    # 按证券代码和日期排序
    filtered_data = filtered_data.sort_values(by=['证券代码', '日期'])

    # 步骤4：添加前交易日涨停基因、当日交易日涨停基因和涨停基因差
    filtered_data['前交易日涨停基因'] = filtered_data.groupby('证券代码')['涨停基因'].shift(1).fillna(0)
    filtered_data['当日交易日涨停基因'] = filtered_data['涨停基因']
    filtered_data['涨停基因差'] = filtered_data['当日交易日涨停基因'] - filtered_data['前交易日涨停基因']

    # 确保所有新列为数值类型
    filtered_data['前交易日涨停基因'] = pd.to_numeric(filtered_data['前交易日涨停基因'], errors='coerce').fillna(0)
    filtered_data['当日交易日涨停基因'] = pd.to_numeric(filtered_data['当日交易日涨停基因'], errors='coerce').fillna(0)
    filtered_data['涨停基因差'] = pd.to_numeric(filtered_data['涨停基因差'], errors='coerce').fillna(0)

    # Reorder columns as per user requirement
    desired_columns = [
        '日期', '证券代码', '证券简称', '最新价', '涨幅', '板块名称',
        '涨停基因', '连板', '封板时间', '封板数', '封板额', '换手率', '净流入',
        '前交易日涨停基因', '当日交易日涨停基因', '涨停基因差'
    ]

    # 检查是否存在所有需要的列并补齐
    for col in desired_columns:
        if col not in filtered_data.columns:
            filtered_data[col] = pd.NA

    output_data = filtered_data[desired_columns]

    # 将日期列格式化为dd/mm/yyyy，如果无法解析则为空
    # 为确保每行输出一致性，对NaN填空串
    output_data['日期'] = pd.to_datetime(output_data['日期'], errors='coerce').dt.strftime('%d/%m/%Y')
    output_data = output_data.fillna('')

    # 步骤5：数据分组、输出到字符串列表
    grouped = output_data.groupby('证券代码')
    stock_codes_list = list(grouped.groups.keys())
    num_groups = len(stock_codes_list)

    # 准备输出行列表
    output_lines = []
    header_str = '\t'.join(desired_columns)

    # 第一个输出行是表头
    output_lines.append(header_str)

    # 遍历每个分组的数据
    for i, code in enumerate(stock_codes_list):
        group = grouped.get_group(code)

        # 输出该组数据行
        for idx, row in group.iterrows():
            row_values = [str(row[col]) for col in desired_columns]
            output_lines.append('\t'.join(row_values))

        # 如果不是最后一组，在该组后面加一行空行和一行表头作为分隔
        if i < num_groups - 1:
            # 空行
            output_lines.append('')
            # 再次输出表头行
            output_lines.append(header_str)

    # 步骤6：将数据输出到CSV文件
    output_csv_path = r"C:\Users\minus\Desktop\crawl_stock_date\OpenAI 01 - 20241209 当天涨停龙头 自动化 对比 连板 基因.csv"

    try:
        # 确保输出目录存在
        os.makedirs(os.path.dirname(output_csv_path), exist_ok=True)

        # 写入数据到CSV文件（使用gbk编码）
        with open(output_csv_path, 'w', encoding='gbk', newline='') as f:
            for line in output_lines:
                f.write(line + '\n')

        print(f"\n数据已成功写入：{output_csv_path}")
    except Exception as e:
        print(f"写入输出CSV文件时出错：{e}")

if __name__ == "__main__":
    main()