JUKUAN/Lib/future/transaction_pair_analysis.py

# 交易配对分析工具
# 用于从交易记录CSV文件中为开仓/平仓交易进行配对，为每对关联交易分配相同ID

import pandas as pd
import numpy as np
from datetime import datetime
import re
import os
import warnings
warnings.filterwarnings('ignore')


def _get_current_directory():
    """
    获取当前文件所在目录
    
    返回:
        str: 当前目录路径
    """
    try:
        current_dir = os.path.dirname(os.path.abspath(__file__))
    except NameError:
        current_dir = os.getcwd()
    return current_dir


def read_transaction_csv(csv_path):
    """
    读取交易记录CSV文件，支持多种编码格式
    
    参数:
        csv_path (str): CSV文件路径
    
    返回:
        pandas.DataFrame: 包含交易记录的DataFrame
    """
    encodings = ['gbk', 'utf-8-sig', 'utf-8', 'gb2312', 'gb18030', 'latin1']
    
    for encoding in encodings:
        try:
            df = pd.read_csv(csv_path, encoding=encoding)
            print(f"成功使用 {encoding} 编码读取CSV文件")
            print(f"从CSV文件中读取到 {len(df)} 条记录")
            return df
        except UnicodeDecodeError:
            continue
        except Exception as e:
            if encoding == encodings[-1]:
                print(f"读取CSV文件时出错: {str(e)}")
                raise
            continue
    
    print(f"无法使用任何编码格式读取CSV文件: {csv_path}")
    return pd.DataFrame()


def parse_transaction_data(df):
    """
    解析交易数据，提取关键信息
    
    参数:
        df (pandas.DataFrame): 原始交易数据
    
    返回:
        pandas.DataFrame: 添加了解析字段的DataFrame
    """
    df = df.copy()
    
    # 提取标的（完整信息用于匹配）
    df['标的_完整'] = df['标的'].astype(str).str.strip()
    
    # 提取交易类型
    df['交易类型_标准'] = df['交易类型'].astype(str).str.strip()
    
    # 判断是开仓还是平仓
    df['仓位操作'] = df['交易类型_标准'].apply(lambda x: '开仓' if '开' in x else ('平仓' if '平' in x else '未知'))
    
    # 判断方向（多/空）
    df['方向'] = df['交易类型_标准'].apply(lambda x: '多' if '多' in x else ('空' if '空' in x else '未知'))
    
    # 从成交数量中提取数字（去掉"手"等单位）
    def extract_quantity(qty_str):
        """从成交数量字符串中提取数字"""
        try:
            qty_str = str(qty_str).strip()
            # 使用正则提取数字（包括负号和小数点）
            match = re.search(r'(-?\d+(?:\.\d+)?)', qty_str)
            if match:
                return abs(float(match.group(1)))  # 返回绝对值
            return 0
        except:
            return 0
    
    df['成交数量_数值'] = df['成交数量'].apply(extract_quantity)
    
    # 合并日期和时间为完整时间戳用于排序
    def parse_datetime(row):
        """解析日期和时间"""
        try:
            date_str = str(row['日期']).strip()
            time_str = str(row['委托时间']).strip()
            datetime_str = f"{date_str} {time_str}"
            return pd.to_datetime(datetime_str)
        except:
            return pd.NaT
    
    df['交易时间'] = df.apply(parse_datetime, axis=1)
    
    # 过滤掉无效记录
    df = df[df['成交数量_数值'] > 0].copy()
    df = df[df['仓位操作'] != '未知'].copy()
    df = df[df['方向'] != '未知'].copy()
    df = df[~df['交易时间'].isna()].copy()
    
    print(f"解析后有效记录: {len(df)} 条")
    
    return df


def fix_incomplete_pairs(df):
    """
    修复不完整的配对（配对ID只出现一次的情况）
    
    参数:
        df (pandas.DataFrame): 已配对的交易数据
    
    返回:
        pandas.DataFrame: 修复后的DataFrame
    """
    df = df.copy()
    max_iterations = 10  # 最大迭代次数，防止无限循环
    iteration = 0
    
    print(f"\n开始修复不完整配对...")
    
    while iteration < max_iterations:
        iteration += 1
        
        # 统计每个配对ID出现的次数（排除"未配对"和空值）
        paired_mask = (df['交易对ID'] != '') & (df['交易对ID'] != '未配对')
        paired_df = df[paired_mask]
        
        if len(paired_df) == 0:
            break
        
        # 统计每个配对ID出现的次数
        pair_id_counts = paired_df['交易对ID'].value_counts()
        
        # 找出只出现一次的配对ID（不完整配对）
        incomplete_pair_ids = pair_id_counts[pair_id_counts == 1].index.tolist()
        
        if len(incomplete_pair_ids) == 0:
            print(f"  迭代 {iteration}: 没有发现不完整配对，修复完成")
            break
        
        print(f"  迭代 {iteration}: 发现 {len(incomplete_pair_ids)} 个不完整配对")
        
        fixed_count = 0
        
        # 处理每个不完整配对
        for pair_id in incomplete_pair_ids:
            # 找到这个配对ID对应的交易
            pair_mask = df['交易对ID'] == pair_id
            incomplete_trade = df[pair_mask].iloc[0]
            
            target = incomplete_trade['标的_完整']
            direction = incomplete_trade['方向']
            operation = incomplete_trade['仓位操作']  # 开仓或平仓
            trade_time = incomplete_trade['交易时间']
            trade_qty = incomplete_trade['成交数量_数值']
            
            # 查找可匹配的未配对交易
            # 条件：相同标的、相同方向、配对ID为空或"未配对"
            unpaired_mask = (
                (df['标的_完整'] == target) &
                (df['方向'] == direction) &
                ((df['交易对ID'] == '') | (df['交易对ID'] == '未配对'))  # 未配对
            )
            unpaired_trades = df[unpaired_mask].copy()
            
            if len(unpaired_trades) == 0:
                continue
            
            # 根据不完整交易的类型，查找匹配的交易
            if operation == '开仓':
                # 如果是开仓，查找平仓交易（时间在开仓之后）
                matching_trades = unpaired_trades[
                    (unpaired_trades['仓位操作'] == '平仓') &
                    (unpaired_trades['交易时间'] >= trade_time)
                ].sort_values('交易时间')
            else:  # operation == '平仓'
                # 如果是平仓，查找开仓交易（时间在平仓之前）
                matching_trades = unpaired_trades[
                    (unpaired_trades['仓位操作'] == '开仓') &
                    (unpaired_trades['交易时间'] <= trade_time)
                ].sort_values('交易时间', ascending=False)  # 从后往前，优先匹配最近的
            
            if len(matching_trades) == 0:
                continue
            
            # 使用贪心算法累加匹配的交易
            remaining_qty = trade_qty
            matched_indices = []
            
            for idx in matching_trades.index:
                match_qty = df.loc[idx, '成交数量_数值']
                
                if remaining_qty <= 0:
                    break
                
                if match_qty <= remaining_qty:
                    # 这笔交易可以加入配对
                    matched_indices.append(idx)
                    remaining_qty -= match_qty
                else:
                    # 交易数量大于剩余需要量，跳过（保持精确匹配）
                    continue
            
            # 如果找到精确匹配的组合（剩余数量为0或接近0）
            if len(matched_indices) > 0 and abs(remaining_qty) < 0.01:
                # 将匹配的交易添加到对应的配对ID中
                for idx in matched_indices:
                    df.loc[idx, '交易对ID'] = pair_id
                
                fixed_count += len(matched_indices)
                
                if operation == '开仓':
                    print(f"    修复: {target} {direction} 1笔开仓({trade_qty:.0f}手) 匹配 {len(matched_indices)}笔平仓 -> {pair_id}")
                else:
                    print(f"    修复: {target} {direction} 1笔平仓({trade_qty:.0f}手) 匹配 {len(matched_indices)}笔开仓 -> {pair_id}")
        
        if fixed_count == 0:
            # 没有修复任何配对，退出循环
            print(f"  迭代 {iteration}: 无法修复更多配对，停止")
            break
        
        print(f"  迭代 {iteration}: 修复了 {fixed_count} 笔交易")
    
    # 最终检查：统计不完整配对
    paired_mask = (df['交易对ID'] != '') & (df['交易对ID'] != '未配对')
    paired_df = df[paired_mask]
    if len(paired_df) > 0:
        pair_id_counts = paired_df['交易对ID'].value_counts()
        incomplete_count = len(pair_id_counts[pair_id_counts == 1])
        if incomplete_count > 0:
            print(f"\n警告: 仍有 {incomplete_count} 个不完整配对无法修复")
        else:
            print(f"\n修复完成: 所有配对都已完整")
    
    return df


def pair_transactions(df):
    """
    为交易进行配对，分配交易对ID
    
    参数:
        df (pandas.DataFrame): 解析后的交易数据
    
    返回:
        pandas.DataFrame: 添加了交易对ID的DataFrame
    """
    df = df.copy()
    df['交易对ID'] = ''  # 初始化交易对ID列
    
    # 按交易时间排序
    df = df.sort_values('交易时间').reset_index(drop=True)
    
    pair_id_counter = 1  # 交易对ID计数器
    paired_count = 0  # 已配对交易数
    unpaired_count = 0  # 未配对交易数
    
    # 按标的分组
    grouped = df.groupby('标的_完整')
    
    print(f"\n开始配对，共有 {len(grouped)} 个不同标的")
    
    for target, group in grouped:
        # 再按方向分组（多/空）
        for direction in ['多', '空']:
            direction_group = group[group['方向'] == direction].copy()
            
            if len(direction_group) == 0:
                continue
            
            # 分离开仓和平仓交易
            open_trades = direction_group[direction_group['仓位操作'] == '开仓'].copy()
            close_trades = direction_group[direction_group['仓位操作'] == '平仓'].copy()
            
            if len(open_trades) == 0 or len(close_trades) == 0:
                # 标记未配对的交易
                for idx in direction_group.index:
                    df.loc[idx, '交易对ID'] = f'未配对'
                    unpaired_count += 1
                continue
            
            # 第零阶段：优先处理同一时间的交易（特别是数量相等的1开1平）
            # 按时间分组，处理同一时间点的开仓和平仓
            time_groups = direction_group.groupby('交易时间')
            for time_key, time_group in time_groups:
                time_open_trades = time_group[time_group['仓位操作'] == '开仓'].copy()
                time_close_trades = time_group[time_group['仓位操作'] == '平仓'].copy()
                
                if len(time_open_trades) == 0 or len(time_close_trades) == 0:
                    continue
                
                # 优先匹配数量完全相等的1开1平
                for close_idx in time_close_trades.index:
                    if df.loc[close_idx, '交易对ID'] != '':  # 已配对的平仓交易跳过
                        continue
                    
                    close_qty = df.loc[close_idx, '成交数量_数值']
                    
                    # 查找同一时间、数量相等的未配对开仓
                    matching_open = time_open_trades[
                        (time_open_trades['成交数量_数值'] == close_qty) &
                        (df.loc[time_open_trades.index, '交易对ID'] == '')
                    ]
                    
                    if len(matching_open) > 0:
                        # 找到匹配的开仓，优先使用第一个
                        open_idx = matching_open.index[0]
                        pair_id = f'P{pair_id_counter:04d}'
                        df.loc[open_idx, '交易对ID'] = pair_id
                        df.loc[close_idx, '交易对ID'] = pair_id
                        
                        paired_count += 2
                        pair_id_counter += 1
                        print(f"  同时间1开1平匹配: {target} {direction} {close_qty:.0f}手 -> {pair_id}")
            
            # 第一阶段：多开1平匹配
            # 遍历每笔平仓交易，查找可以合并匹配的多笔开仓
            for close_idx in close_trades.index:
                if df.loc[close_idx, '交易对ID'] != '':  # 已配对的平仓交易跳过
                    continue
                
                close_time = df.loc[close_idx, '交易时间']
                close_qty = df.loc[close_idx, '成交数量_数值']
                
                # 查找该平仓交易之前或同一时间的所有未配对开仓交易
                # 注意：同一时间的1开1平已经在第零阶段处理，这里主要处理多开1平的情况
                valid_open_trades = open_trades[
                    (open_trades['交易时间'] <= close_time) & 
                    (df.loc[open_trades.index, '交易对ID'] == '')  # 未被配对的开仓交易
                ].copy()
                
                if len(valid_open_trades) == 0:
                    continue
                
                # 尝试找到开仓数量之和等于平仓数量的组合
                # 使用贪心算法：按时间顺序累加开仓数量
                remaining_qty = close_qty
                paired_open_indices = []
                
                for open_idx in valid_open_trades.index:
                    open_qty = df.loc[open_idx, '成交数量_数值']
                    
                    if remaining_qty <= 0:
                        break
                    
                    if open_qty <= remaining_qty:
                        # 这笔开仓可以加入配对
                        paired_open_indices.append(open_idx)
                        remaining_qty -= open_qty
                    else:
                        # 开仓数量大于剩余需要量，跳过（保持精确匹配）
                        continue
                
                # 如果找到精确匹配的组合（剩余数量为0或接近0）
                if len(paired_open_indices) > 0 and abs(remaining_qty) < 0.01:
                    # 为配对的交易分配相同的ID
                    pair_id = f'P{pair_id_counter:04d}'
                    for open_idx in paired_open_indices:
                        df.loc[open_idx, '交易对ID'] = pair_id
                    df.loc[close_idx, '交易对ID'] = pair_id
                    
                    paired_count += len(paired_open_indices) + 1  # 开仓+平仓
                    pair_id_counter += 1
                    
                    if len(paired_open_indices) > 1:
                        print(f"  多开1平匹配: {target} {direction} {len(paired_open_indices)}笔开仓({sum([df.loc[idx, '成交数量_数值'] for idx in paired_open_indices]):.0f}手) 匹配 1笔平仓({close_qty:.0f}手) -> {pair_id}")
            
            # 第二阶段：1开多平匹配（原有逻辑）
            # 遍历每笔开仓交易，寻找匹配的平仓交易
            for open_idx in open_trades.index:
                # 跳过已配对的开仓交易
                if df.loc[open_idx, '交易对ID'] != '':
                    continue
                
                open_time = df.loc[open_idx, '交易时间']
                open_qty = df.loc[open_idx, '成交数量_数值']
                
                # 查找该开仓交易之后的平仓交易
                valid_close_trades = close_trades[
                    (close_trades['交易时间'] >= open_time) & 
                    (close_trades['交易对ID'] == '')  # 未被配对的平仓交易
                ].copy()
                
                if len(valid_close_trades) == 0:
                    # 没有找到匹配的平仓交易
                    df.loc[open_idx, '交易对ID'] = '未配对'
                    unpaired_count += 1
                    continue
                
                # 累计平仓数量，直到等于开仓数量
                remaining_qty = open_qty
                paired_close_indices = []
                
                for close_idx in valid_close_trades.index:
                    close_qty_val = df.loc[close_idx, '成交数量_数值']
                    
                    if remaining_qty <= 0:
                        break
                    
                    if close_qty_val <= remaining_qty:
                        # 这笔平仓完全匹配
                        paired_close_indices.append(close_idx)
                        remaining_qty -= close_qty_val
                    elif close_qty_val > remaining_qty:
                        # 这笔平仓数量大于剩余需要量，跳过（保持精确匹配）
                        # 只有在剩余数量很小时才允许部分匹配
                        continue
                
                # 为配对的交易分配相同的ID（要求精确匹配或接近精确匹配）
                if len(paired_close_indices) > 0 and abs(remaining_qty) < 0.01:
                    pair_id = f'P{pair_id_counter:04d}'
                    df.loc[open_idx, '交易对ID'] = pair_id
                    for close_idx in paired_close_indices:
                        df.loc[close_idx, '交易对ID'] = pair_id
                    
                    paired_count += len(paired_close_indices) + 1  # 开仓+平仓
                    pair_id_counter += 1
                    
                    if len(paired_close_indices) > 1:
                        print(f"  1开多平匹配: {target} {direction} 1笔开仓({open_qty:.0f}手) 匹配 {len(paired_close_indices)}笔平仓({sum([df.loc[idx, '成交数量_数值'] for idx in paired_close_indices]):.0f}手) -> {pair_id}")
                elif len(paired_close_indices) > 0:
                    # 部分匹配，发出警告但不配对
                    print(f"  警告: {target} {direction} 开仓在 {open_time} 有 {remaining_qty:.2f} 未配对，跳过配对")
                    df.loc[open_idx, '交易对ID'] = '未配对'
                    unpaired_count += 1
                else:
                    # 没有配对成功
                    df.loc[open_idx, '交易对ID'] = '未配对'
                    unpaired_count += 1
    
    # 统计信息
    print(f"\n配对完成:")
    print(f"  已配对交易: {paired_count} 条")
    print(f"  未配对交易: {unpaired_count} 条")
    print(f"  生成交易对: {pair_id_counter - 1} 对")
    
    # 后处理：修复不完整配对
    df = fix_incomplete_pairs(df)
    
    return df


def extract_symbol_core(symbol):
    """
    从标的字符串中提取标的核心字母

    参数:
        symbol (str): 标的字符串，如"10年期国债期货(T2006.CCFX)"

    返回:
        tuple: (括号内完整代码, 标的核心字母)
    """
    try:
        # 提取括号内的内容
        match = re.search(r'\(([^)]+)\)', symbol)
        if match:
            full_code = match.group(1)
            # 去掉后面的9位获取标的核心字母
            core_symbol = full_code[:-9] if len(full_code) > 9 else full_code
            return full_code, core_symbol
        else:
            return symbol, symbol
    except:
        return symbol, symbol


def identify_continuous_trade_pairs(df):
    """
    识别连续交易对

    参数:
        df (pandas.DataFrame): 包含交易对ID的交易数据

    返回:
        pandas.DataFrame: 添加了连续交易对ID的DataFrame
    """
    print("\n开始识别连续交易对...")

    df = df.copy()
    df['连续交易对ID'] = 'N/A'  # 初始化连续交易对ID列

    # 提取标的核心字母
    df['标的核心字母'] = df['标的'].apply(lambda x: extract_symbol_core(x)[1])

    # 获取所有已配对的交易对ID
    paired_mask = df['交易对ID'].str.startswith('P', na=False)
    paired_df = df[paired_mask].copy()

    if len(paired_df) == 0:
        print("没有已配对的交易")
        return df

    # 按交易对ID分组
    pair_groups = paired_df.groupby('交易对ID')

    # 存储连续交易对关系
    continuous_groups = []  # 每个元素是一组连续的交易对ID
    processed_pairs = set()  # 已处理的交易对ID

    for pair_id, group in pair_groups:
        if pair_id in processed_pairs:
            continue

        # 获取当前交易对的开仓和平仓记录
        open_trades = group[group['仓位操作'] == '开仓'].copy()
        close_trades = group[group['仓位操作'] == '平仓'].copy()

        if len(open_trades) == 0 or len(close_trades) == 0:
            continue

        # 获取当前交易对的关键信息
        current_core_symbol = group['标的核心字母'].iloc[0]
        current_direction = group['方向'].iloc[0]
        current_close_date = close_trades['日期'].iloc[0]
        current_close_time = close_trades['委托时间'].iloc[0]
        current_close_qty = close_trades['成交数量_数值'].sum()

        # 查找匹配的连续交易对
        matching_pairs = []

        for other_pair_id, other_group in pair_groups:
            if other_pair_id == pair_id or other_pair_id in processed_pairs:
                continue

            # 获取另一个交易对的开仓和平仓记录
            other_open_trades = other_group[other_group['仓位操作'] == '开仓'].copy()
            other_close_trades = other_group[other_group['仓位操作'] == '平仓'].copy()

            if len(other_open_trades) == 0 or len(other_close_trades) == 0:
                continue

            # 检查条件1：平仓和开仓的日期、委托时间完全一致
            other_open_date = other_open_trades['日期'].iloc[0]
            other_open_time = other_open_trades['委托时间'].iloc[0]

            # 由于可能有多个开仓，检查是否有至少一个与平仓时间完全一致
            time_match_found = False
            for _, open_trade in other_open_trades.iterrows():
                if (open_trade['日期'] == current_close_date and
                    open_trade['委托时间'] == current_close_time):
                    time_match_found = True
                    break

            if not time_match_found:
                continue

            # 检查条件2：交易类型匹配（平多对应开多，平空对应开空）
            other_direction = other_group['方向'].iloc[0]
            if current_direction != other_direction:
                continue

            # 检查条件3：标的核心字母一致
            other_core_symbol = other_group['标的核心字母'].iloc[0]
            if current_core_symbol != other_core_symbol:
                continue

            # 检查条件4：成交数量绝对值一致
            other_open_qty = other_open_trades['成交数量_数值'].sum()
            if abs(current_close_qty - other_open_qty) > 0.01:
                continue

            # 所有条件都满足，这是一个连续交易对
            matching_pairs.append(other_pair_id)
            processed_pairs.add(other_pair_id)

        # 如果找到匹配的连续交易对
        if matching_pairs:
            # 创建连续交易对组（包含当前交易对和所有匹配的交易对）
            continuous_group = [pair_id] + matching_pairs
            continuous_groups.append(continuous_group)
            processed_pairs.add(pair_id)

            print(f"  发现连续交易对组: {continuous_group}")
            print(f"    核心标的: {current_core_symbol}, 方向: {current_direction}")
            print(f"    平仓时间: {current_close_date} {current_close_time}")
            print(f"    平仓数量: {current_close_qty:.2f}, 开仓数量: {other_open_qty:.2f}")

    # 为连续交易对分配ID
    for i, continuous_group in enumerate(continuous_groups):
        continuous_id = f'C{i+1:04d}'
        for pair_id in continuous_group:
            mask = df['交易对ID'] == pair_id
            df.loc[mask, '连续交易对ID'] = continuous_id

    print(f"\n识别完成，共发现 {len(continuous_groups)} 组连续交易对")

    # 清理临时列
    df = df.drop('标的核心字母', axis=1)

    return df


def save_result(df, output_path):
    """
    保存配对结果到CSV文件

    参数:
        df (pandas.DataFrame): 包含交易对ID的DataFrame
        output_path (str): 输出文件路径
    """
    df = df.copy()

    # 添加"开仓时间"列
    # 对于每个交易对ID，找到对应的开仓记录的"最后更新时间"
    df['开仓时间'] = ''

    # 添加"交易盈亏"列，根据相同的交易对ID对平仓盈亏进行求和
    df['交易盈亏'] = ''

    # 添加"连续交易总盈亏"列
    df['连续交易总盈亏'] = 'N/A'

    # 先计算每个交易对的盈亏
    for pair_id in df['交易对ID'].unique():
        if pair_id and pair_id.startswith('P'):
            # 找到该交易对的所有记录
            pair_mask = df['交易对ID'] == pair_id
            pair_records = df[pair_mask]

            # 找到开仓记录（仓位操作为"开仓"）
            open_record = pair_records[pair_records['仓位操作'] == '开仓']

            if len(open_record) > 0:
                # 获取开仓记录的最后更新时间
                open_time = open_record.iloc[0]['最后更新时间']
                # 将开仓时间填充到该交易对的所有记录中
                df.loc[pair_mask, '开仓时间'] = open_time

            # 计算该交易对的总盈亏（对平仓盈亏求和）
            try:
                # 提取平仓盈亏列，转换为数值
                # 先转换为字符串，去掉千位分隔符（逗号），然后转换为数值
                close_profit_loss_str = pair_records['平仓盈亏'].astype(str).str.replace(',', '')
                # 尝试转换为数值，无法转换的设为0
                close_profit_loss_numeric = pd.to_numeric(close_profit_loss_str, errors='coerce').fillna(0)
                total_profit_loss = close_profit_loss_numeric.sum()
                # 将总盈亏填充到该交易对的所有记录中
                df.loc[pair_mask, '交易盈亏'] = total_profit_loss
            except Exception as e:
                # 如果计算失败，设为0
                df.loc[pair_mask, '交易盈亏'] = 0

    # 计算连续交易总盈亏
    for continuous_id in df['连续交易对ID'].unique():
        if continuous_id != 'N/A' and pd.notna(continuous_id):
            # 找到该连续交易组的所有记录
            continuous_mask = df['连续交易对ID'] == continuous_id
            continuous_records = df[continuous_mask]

            # 计算该连续交易组的总盈亏
            try:
                # 提取平仓盈亏列，转换为数值
                close_profit_loss_str = continuous_records['平仓盈亏'].astype(str).str.replace(',', '')
                # 尝试转换为数值，无法转换的设为0
                close_profit_loss_numeric = pd.to_numeric(close_profit_loss_str, errors='coerce').fillna(0)
                total_continuous_profit = close_profit_loss_numeric.sum()
                # 将连续交易总盈亏填充到该组的所有记录中
                df.loc[continuous_mask, '连续交易总盈亏'] = total_continuous_profit
            except Exception as e:
                # 如果计算失败，设为0
                df.loc[continuous_mask, '连续交易总盈亏'] = 0

    # 移除中间处理列
    columns_to_remove = ['标的_完整', '交易类型_标准', '仓位操作', '方向', '成交数量_数值', '交易时间']
    output_columns = [col for col in df.columns if col not in columns_to_remove]

    # 调整列顺序，确保交易对ID、连续交易对ID、开仓时间、交易盈亏和连续交易总盈亏在最后
    if '交易对ID' in output_columns:
        output_columns.remove('交易对ID')
    if '连续交易对ID' in output_columns:
        output_columns.remove('连续交易对ID')
    if '开仓时间' in output_columns:
        output_columns.remove('开仓时间')
    if '交易盈亏' in output_columns:
        output_columns.remove('交易盈亏')
    if '连续交易总盈亏' in output_columns:
        output_columns.remove('连续交易总盈亏')
    output_columns.append('交易对ID')
    output_columns.append('连续交易对ID')
    output_columns.append('开仓时间')
    output_columns.append('交易盈亏')
    output_columns.append('连续交易总盈亏')
    
    # 按交易对ID和日期升序排序
    # 创建排序辅助列：未配对的排在最后，其他按ID数字排序
    def get_sort_key(pair_id):
        if pd.isna(pair_id) or pair_id == '' or pair_id == '未配对':
            return (1, '')  # 未配对排在最后
        elif isinstance(pair_id, str) and pair_id.startswith('P'):
            try:
                # 提取数字部分用于排序
                num = int(pair_id[1:])
                return (0, num)  # 已配对的排在前面，按数字排序
            except:
                return (1, pair_id)
        else:
            return (1, str(pair_id))
    
    df['_sort_key_id'] = df['交易对ID'].apply(get_sort_key)
    
    # 确保日期列可以排序（转换为datetime类型）
    if '日期' in df.columns:
        df['_sort_date'] = pd.to_datetime(df['日期'], errors='coerce')
    else:
        df['_sort_date'] = pd.NaT
    
    # 先按交易对ID排序，再按日期排序
    df = df.sort_values(['_sort_key_id', '_sort_date'], ascending=[True, True]).reset_index(drop=True)
    df = df.drop(['_sort_key_id', '_sort_date'], axis=1)
    
    # 保存到CSV
    try:
        df[output_columns].to_csv(output_path, index=False, encoding='utf-8-sig')
        print(f"\n结果已保存到: {output_path}")
        
        # 获取文件大小
        file_size = os.path.getsize(output_path) / 1024  # KB
        print(f"文件大小: {file_size:.2f} KB")
    except Exception as e:
        print(f"保存文件时出错: {str(e)}")


def print_statistics(df):
    """
    打印配对统计信息

    参数:
        df (pandas.DataFrame): 包含交易对ID的DataFrame
    """
    print("\n" + "=" * 60)
    print("配对统计信息")
    print("=" * 60)

    # 统计已配对和未配对
    paired = df[df['交易对ID'].str.startswith('P', na=False)]
    unpaired = df[df['交易对ID'] == '未配对']

    print(f"\n总交易记录: {len(df)} 条")
    print(f"已配对交易: {len(paired)} 条 ({len(paired)/len(df)*100:.1f}%)")
    print(f"未配对交易: {len(unpaired)} 条 ({len(unpaired)/len(df)*100:.1f}%)")

    # 统计交易对数量
    unique_pairs = paired['交易对ID'].nunique()
    print(f"\n交易对数量: {unique_pairs} 对")

    # 统计连续交易对
    if '连续交易对ID' in df.columns:
        continuous_pairs = df[df['连续交易对ID'] != 'N/A']
        unique_continuous_pairs = continuous_pairs['连续交易对ID'].nunique()
        print(f"\n连续交易对统计:")
        print(f"  连续交易对数量: {unique_continuous_pairs} 组")
        print(f"  涉及交易记录: {len(continuous_pairs)} 条")
        if len(continuous_pairs) > 0:
            # 统计每组连续交易对的交易对数量
            continuous_stats = continuous_pairs.groupby('连续交易对ID')['交易对ID'].nunique()
            print(f"  每组连续交易对包含的交易对数量分布:")
            for continuous_id, pair_count in continuous_stats.items():
                print(f"    {continuous_id}: {pair_count} 个交易对")

    # 统计每个交易对的平仓次数分布
    if len(paired) > 0:
        pair_counts = paired.groupby('交易对ID').size()
        print(f"\n交易对组成分布:")
        distribution = pair_counts.value_counts().sort_index()
        for count, freq in distribution.items():
            if count == 2:
                print(f"  1开1平: {freq} 对")
            else:
                print(f"  1开{count-1}平: {freq} 对")

    # 按标的统计
    print(f"\n按标的统计:")
    target_stats = df.groupby('标的_完整')['交易对ID'].apply(
        lambda x: f"总:{len(x)}条, 已配对:{len(x[x.str.startswith('P', na=False)])}条"
    )
    for target, stats in target_stats.items():
        print(f"  {target}: {stats}")


def analyze_transaction_pairs(csv_filename=None, output_filename=None):
    """
    主函数：分析交易配对
    
    参数:
        csv_filename (str): 输入CSV文件名
        output_filename (str): 输出CSV文件名（可选）
    """
    print("=" * 60)
    print("交易配对分析工具")
    print("=" * 60)
    
    # 设置文件路径
    if csv_filename is None:
        csv_filename = 'transaction.csv'
    
    current_dir = _get_current_directory()
    csv_path = os.path.join(current_dir, csv_filename)
    
    if not os.path.exists(csv_path):
        print(f"错误: 文件不存在 - {csv_path}")
        return
    
    # 设置输出文件名
    if output_filename is None:
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        base_name = os.path.splitext(csv_filename)[0]
        output_filename = f"{base_name}_paired_{timestamp}.csv"
    
    output_path = os.path.join(current_dir, output_filename)
    
    # 步骤1: 读取CSV
    print(f"\n步骤1: 读取CSV文件")
    print(f"文件路径: {csv_path}")
    df = read_transaction_csv(csv_path)
    
    if len(df) == 0:
        print("错误: 无法读取数据")
        return
    
    # 步骤2: 解析数据
    print(f"\n步骤2: 解析交易数据")
    df = parse_transaction_data(df)
    
    if len(df) == 0:
        print("错误: 没有有效的交易记录")
        return
    
    # 步骤3: 配对交易
    print(f"\n步骤3: 配对交易")
    df = pair_transactions(df)

    # 步骤4: 识别连续交易对
    print(f"\n步骤4: 识别连续交易对")
    df = identify_continuous_trade_pairs(df)

    # 步骤5: 保存结果
    print(f"\n步骤5: 保存结果")
    save_result(df, output_path)
    
    # 步骤6: 打印统计信息
    print_statistics(df)

    print("\n" + "=" * 60)
    print("分析完成")
    print("=" * 60)


# 使用示例
if __name__ == "__main__":
    # 可以指定CSV文件名，如果不指定则使用默认的 transaction.csv
    analyze_transaction_pairs()
    # 或者指定特定文件: analyze_transaction_pairs('transaction.csv')