pandas数据如何实现合并与聚合分析？

🏆本文收录于 《全栈Bug调优(实战版)》 专栏，该专栏专注于分享我在真实项目开发中遇到的各类疑难Bug及其深层成因，并系统提供高效、可复现的解决思路和实操方案。无论你是刚入行的新手开发者，还是拥有多年项目经验的资深工程师，本专栏都将为你提供一条系统化、高质量的问题排查与优化路径，助力你加速成长，攻克技术壁垒，迈向技术价值最大化与职业发展的更高峰🚀！
  
📌 特别说明： 文中部分技术问题来源于真实生产环境及网络公开案例，均经过精挑细选与系统化整理，并结合多位一线资深架构师和工程师多年实战经验沉淀，提炼出多种经过验证的高可行性解决方案，供开发者们参考与借鉴。
  
欢迎 关注、收藏并订阅本专栏，持续更新的干货内容将与您同行，让我们携手精进，技术跃迁，步步高升！

📢 问题描述

问题来源：https://ask.csdn.net/questions/xxx

问题描述：

pandas计算：如何实现？

df1：

df2：

计算过程：
把df1和df2合并到df3，对搜索词进行分类，比如合并后搜索词A共有3条数据，把3条数据合并成1条数据，开始时间值是选择3条原始数最早的，结束时间值是选择3条原始数最晚的，平台的值忽略/空值，搜索词值还是A，点击量和订单量值3个原始数据求和，转化率值=订单量/点击量；如果合并数据只有1条数据，比如C和D，df3中的C和D的所有数据保持不变。

代码计算后的结果：
Df3：

📣 请知悉：如下方案不保证一定适配你的问题！

  如下是针对上述问题进行专业角度剖析答疑，不喜勿喷，仅供参考：

✅️问题理解

题主遇到的是一个典型的pandas数据合并与聚合分析问题，具体需求包括：

1. 数据合并：将两个具有相同结构的DataFrame（df1和df2）进行纵向合并

2. 按搜索词分组：以"搜索词"字段作为分组键进行数据聚合

3. 复杂聚合规则：不同字段采用不同的聚合策略

   • 时间字段：开始时间取最小值，结束时间取最大值
   • 平台字段：多条记录时设为none，单条记录保持原值
   • 数值字段：点击量和订单量求和
   • 计算字段：转化率需要重新计算（订单量总和/点击量总和）

这个问题的核心挑战在于如何在pandas中实现条件性的聚合逻辑，特别是平台字段的处理需要根据分组内记录数量来决定取值策略。

✅️问题解决方案

1. 完整解决方案代码

import pandas as pd
import numpy as np
from datetime import datetime

def merge_and_aggregate_dataframes(df1, df2):
    """
    合并两个DataFrame并按搜索词进行聚合
    
    Args:
        df1, df2: 输入的DataFrame
        
    Returns:
        df3: 聚合后的DataFrame
    """
    
    # 1. 数据预处理 - 确保时间列为datetime类型
    def preprocess_dataframe(df):
        df_copy = df.copy()
        df_copy['开始时间'] = pd.to_datetime(df_copy['开始时间'])
        df_copy['结束时间'] = pd.to_datetime(df_copy['结束时间'])
        return df_copy
    
    # 预处理两个DataFrame
    df1_processed = preprocess_dataframe(df1)
    df2_processed = preprocess_dataframe(df2)
    
    # 2. 合并DataFrame
    df_combined = pd.concat([df1_processed, df2_processed], ignore_index=True)
    
    print("合并后的数据：")
    print(df_combined)
    print("\n" + "="*50 + "\n")
    
    # 3. 按搜索词分组并应用自定义聚合函数
    def custom_aggregation(group):
        """
        自定义聚合函数
        """
        result = {}
        
        # 开始时间取最早
        result['开始时间'] = group['开始时间'].min()
        
        # 结束时间取最晚  
        result['结束时间'] = group['结束时间'].max()
        
        # 平台字段处理：多条记录时设为none，单条记录保持原值
        if len(group) > 1:
            result['平台'] = 'none'
        else:
            result['平台'] = group['平台'].iloc[0]
        
        # 搜索词保持不变
        result['搜索词'] = group['搜索词'].iloc[0]
        
        # 数值字段求和
        result['点击量'] = group['点击量'].sum()
        result['订单量'] = group['订单量'].sum()
        
        # 转化率重新计算
        result['转化率'] = round(result['订单量'] / result['点击量'], 2) if result['点击量'] > 0 else 0
        
        return pd.Series(result)
    
    # 4. 执行分组聚合
    df3 = df_combined.groupby('搜索词').apply(custom_aggregation).reset_index(drop=True)
    
    # 5. 格式化日期显示
    df3['开始时间'] = df3['开始时间'].dt.strftime('%Y/%m/%d')
    df3['结束时间'] = df3['结束时间'].dt.strftime('%Y/%m/%d')
    
    # 6. 按搜索词排序
    df3 = df3.sort_values('搜索词').reset_index(drop=True)
    
    return df3

# 创建示例数据
def create_sample_data():
    """
    创建示例数据
    """
    # df1数据
    df1_data = {
        '开始时间': ['2025/3/1', '2025/5/1', '2025/4/1'],
        '结束时间': ['2025/4/1', '2025/6/1', '2025/4/30'],
        '平台': ['淘宝', '淘宝', '京东'],
        '搜索词': ['A', 'B', 'A'],
        '点击量': [125, 60, 70],
        '订单量': [13, 10, 14],
        '转化率': [0.1, 0.3, 0.2]
    }
    
    # df2数据
    df2_data = {
        '开始时间': ['2025/4/10', '2025/5/1', '2025/7/1', '2025/6/12'],
        '结束时间': ['2025/5/1', '2025/6/1', '2025/7/30', '2025/6/25'],
        '平台': ['淘宝', '京东', '淘宝', '京东'],
        '搜索词': ['A', 'C', 'B', 'D'],
        '点击量': [89, 60, 200, 150],
        '订单量': [18, 10, 10, 15],
        '转化率': [0.2, 0.3, 0.05, 0.1]
    }
    
    df1 = pd.DataFrame(df1_data)
    df2 = pd.DataFrame(df2_data)
    
    return df1, df2

# 执行主程序
def main():
    """
    主程序执行函数
    """
    # 创建示例数据
    df1, df2 = create_sample_data()
    
    print("原始数据 df1：")
    print(df1)
    print("\n原始数据 df2：")
    print(df2)
    print("\n" + "="*50 + "\n")
    
    # 执行合并和聚合
    df3 = merge_and_aggregate_dataframes(df1, df2)
    
    print("最终结果 df3：")
    print(df3)
    
    return df1, df2, df3

# 运行程序
if __name__ == "__main__":
    df1, df2, df3 = main()

2. 高级版本 - 面向对象实现

class DataFrameMerger:
    """
    DataFrame合并和聚合处理类
    """
    
    def __init__(self, date_format='%Y/%m/%d'):
        self.date_format = date_format
        self.aggregation_rules = {
            '开始时间': 'min',
            '结束时间': 'max', 
            '点击量': 'sum',
            '订单量': 'sum'
        }
    
    def preprocess_data(self, df):
        """
        数据预处理
        """
        df_copy = df.copy()
        
        # 转换时间列
        time_columns = ['开始时间', '结束时间']
        for col in time_columns:
            if col in df_copy.columns:
                df_copy[col] = pd.to_datetime(df_copy[col])
        
        # 数据验证
        self._validate_data(df_copy)
        
        return df_copy
    
    def _validate_data(self, df):
        """
        数据验证
        """
        required_columns = ['开始时间', '结束时间', '平台', '搜索词', '点击量', '订单量']
        missing_columns = [col for col in required_columns if col not in df.columns]
        
        if missing_columns:
            raise ValueError(f"缺少必要的列: {missing_columns}")
        
        # 检查数据类型
        if df['点击量'].dtype not in ['int64', 'float64']:
            raise ValueError("点击量必须为数值类型")
        
        if df['订单量'].dtype not in ['int64', 'float64']:
            raise ValueError("订单量必须为数值类型")
    
    def custom_platform_aggregation(self, group):
        """
        平台字段的自定义聚合逻辑
        """
        if len(group) > 1:
            return 'none'
        else:
            return group.iloc[0]
    
    def calculate_conversion_rate(self, orders, clicks):
        """
        计算转化率
        """
        if clicks == 0:
            return 0
        return round(orders / clicks, 2)
    
    def aggregate_by_search_term(self, df_combined):
        """
        按搜索词进行聚合
        """
        # 基础聚合
        agg_dict = {
            '开始时间': 'min',
            '结束时间': 'max',
            '平台': self.custom_platform_aggregation,
            '点击量': 'sum',
            '订单量': 'sum'
        }
        
        # 执行聚合
        df_aggregated = df_combined.groupby('搜索词').agg(agg_dict).reset_index()
        
        # 计算转化率
        df_aggregated['转化率'] = df_aggregated.apply(
            lambda row: self.calculate_conversion_rate(row['订单量'], row['点击量']), 
            axis=1
        )
        
        return df_aggregated
    
    def format_output(self, df):
        """
        格式化输出
        """
        df_formatted = df.copy()
        
        # 格式化日期
        df_formatted['开始时间'] = df_formatted['开始时间'].dt.strftime(self.date_format)
        df_formatted['结束时间'] = df_formatted['结束时间'].dt.strftime(self.date_format)
        
        # 重新排列列顺序
        column_order = ['开始时间', '结束时间', '平台', '搜索词', '点击量', '订单量', '转化率']
        df_formatted = df_formatted[column_order]
        
        return df_formatted
    
    def merge_and_process(self, df1, df2):
        """
        完整的合并和处理流程
        """
        try:
            # 预处理
            df1_processed = self.preprocess_data(df1)
            df2_processed = self.preprocess_data(df2)
            
            # 合并
            df_combined = pd.concat([df1_processed, df2_processed], ignore_index=True)
            
            # 聚合
            df_aggregated = self.aggregate_by_search_term(df_combined)
            
            # 格式化
            df_final = self.format_output(df_aggregated)
            
            # 排序
            df_final = df_final.sort_values('搜索词').reset_index(drop=True)
            
            return df_final
            
        except Exception as e:
            print(f"处理过程中发生错误: {e}")
            raise

# 使用示例
def advanced_example():
    """
    高级版本使用示例
    """
    # 创建合并器实例
    merger = DataFrameMerger()
    
    # 创建示例数据
    df1, df2 = create_sample_data()
    
    # 执行合并处理
    result = merger.merge_and_process(df1, df2)
    
    print("高级版本处理结果：")
    print(result)
    
    return result

# 运行高级版本
# advanced_result = advanced_example()

3. 性能优化版本

def optimized_merge_process(df1, df2):
    """
    性能优化版本 - 适用于大数据量
    """
    # 使用更高效的数据类型
    dtype_optimization = {
        '点击量': 'int32',
        '订单量': 'int32', 
        '平台': 'category',
        '搜索词': 'category'
    }
    
    # 优化数据类型
    for df in [df1, df2]:
        for col, dtype in dtype_optimization.items():
            if col in df.columns:
                df[col] = df[col].astype(dtype)
    
    # 使用pd.concat的高效模式
    df_combined = pd.concat([df1, df2], ignore_index=True, copy=False)
    
    # 使用agg进行批量聚合（更高效）
    aggregation_functions = {
        '开始时间': lambda x: pd.to_datetime(x).min(),
        '结束时间': lambda x: pd.to_datetime(x).max(),
        '平台': lambda x: 'none' if len(x) > 1 else x.iloc[0],
        '点击量': 'sum',
        '订单量': 'sum'
    }
    
    # 执行聚合
    result = df_combined.groupby('搜索词').agg(aggregation_functions).reset_index()
    
    # 批量计算转化率
    result['转化率'] = (result['订单量'] / result['点击量']).round(2)
    
    return result

✅️问题延伸

1. 数据质量检查和异常处理

class DataQualityChecker:
    """
    数据质量检查器
    """
    
    @staticmethod
    def check_time_consistency(df):
        """
        检查时间一致性
        """
        issues = []
        
        # 检查开始时间是否早于结束时间
        invalid_time = df[df['开始时间'] > df['结束时间']]
        if not invalid_time.empty:
            issues.append(f"发现 {len(invalid_time)} 条记录的开始时间晚于结束时间")
        
        # 检查时间是否为未来时间
        current_date = pd.Timestamp.now()
        future_records = df[df['结束时间'] > current_date]
        if not future_records.empty:
            issues.append(f"发现 {len(future_records)} 条记录的结束时间为未来时间")
        
        return issues
    
    @staticmethod  
    def check_data_ranges(df):
        """
        检查数据范围合理性
        """
        issues = []
        
        # 检查负数
        if (df['点击量'] < 0).any():
            issues.append("发现负数点击量")
        
        if (df['订单量'] < 0).any():
            issues.append("发现负数订单量")
        
        # 检查转化率是否超过100%
        if (df['转化率'] > 1).any():
            issues.append("发现转化率超过100%的记录")
        
        # 检查订单量是否大于点击量
        invalid_conversion = df[df['订单量'] > df['点击量']]
        if not invalid_conversion.empty:
            issues.append(f"发现 {len(invalid_conversion)} 条记录的订单量大于点击量")
        
        return issues

def enhanced_merge_with_validation(df1, df2):
    """
    带数据验证的增强版合并函数
    """
    checker = DataQualityChecker()
    
    # 数据质量检查
    for i, df in enumerate([df1, df2], 1):
        print(f"检查 df{i} 的数据质量...")
        
        time_issues = checker.check_time_consistency(df)
        range_issues = checker.check_data_ranges(df)
        
        all_issues = time_issues + range_issues
        
        if all_issues:
            print(f"df{i} 发现以下问题:")
            for issue in all_issues:
                print(f"  - {issue}")
        else:
            print(f"df{i} 数据质量检查通过")
    
    # 执行合并
    merger = DataFrameMerger()
    result = merger.merge_and_process(df1, df2)
    
    return result

2. 多维度分析扩展

def multi_dimensional_analysis(df_result):
    """
    多维度分析
    """
    analysis_report = {}
    
    # 1. 搜索词效果分析
    analysis_report['搜索词效果'] = df_result.nlargest(3, '转化率')[['搜索词', '转化率']]
    
    # 2. 点击量分布分析
    analysis_report['点击量统计'] = {
        '总点击量': df_result['点击量'].sum(),
        '平均点击量': df_result['点击量'].mean(),
        '点击量标准差': df_result['点击量'].std()
    }
    
    # 3. 时间跨度分析
    df_temp = df_result.copy()
    df_temp['开始时间'] = pd.to_datetime(df_temp['开始时间'])
    df_temp['结束时间'] = pd.to_datetime(df_temp['结束时间'])
    df_temp['时间跨度'] = (df_temp['结束时间'] - df_temp['开始时间']).dt.days
    
    analysis_report['时间跨度分析'] = {
        '平均时间跨度': df_temp['时间跨度'].mean(),
        '最长时间跨度': df_temp['时间跨度'].max(),
        '最短时间跨度': df_temp['时间跨度'].min()
    }
    
    return analysis_report

# 可视化支持
def create_visualization(df_result):
    """
    创建可视化图表
    """
    import matplotlib.pyplot as plt
    import matplotlib
    
    # 设置中文字体
    matplotlib.rcParams['font.sans-serif'] = ['SimHei']
    matplotlib.rcParams['axes.unicode_minus'] = False
    
    fig, axes = plt.subplots(2, 2, figsize=(15, 10))
    
    # 1. 转化率对比
    axes[0, 0].bar(df_result['搜索词'], df_result['转化率'])
    axes[0, 0].set_title('各搜索词转化率对比')
    axes[0, 0].set_ylabel('转化率')
    
    # 2. 点击量对比
    axes[0, 1].bar(df_result['搜索词'], df_result['点击量'])
    axes[0, 1].set_title('各搜索词点击量对比')
    axes[0, 1].set_ylabel('点击量')
    
    # 3. 订单量对比
    axes[1, 0].bar(df_result['搜索词'], df_result['订单量'])
    axes[1, 0].set_title('各搜索词订单量对比')
    axes[1, 0].set_ylabel('订单量')
    
    # 4. 转化率与点击量散点图
    axes[1, 1].scatter(df_result['点击量'], df_result['转化率'])
    axes[1, 1].set_xlabel('点击量')
    axes[1, 1].set_ylabel('转化率')
    axes[1, 1].set_title('点击量与转化率关系')
    
    # 添加搜索词标签
    for i, txt in enumerate(df_result['搜索词']):
        axes[1, 1].annotate(txt, (df_result['点击量'].iloc[i], df_result['转化率'].iloc[i]))
    
    plt.tight_layout()
    plt.show()
    
    return fig

✅️问题预测

1. 可能遇到的问题及解决方案

内存使用问题：

def memory_efficient_processing(df1, df2, chunk_size=10000):
    """
    内存高效的大数据处理
    """
    if len(df1) + len(df2) > chunk_size:
        # 分块处理
        chunks = []
        combined_df = pd.concat([df1, df2])
        
        for i in range(0, len(combined_df), chunk_size):
            chunk = combined_df.iloc[i:i+chunk_size]
            processed_chunk = process_chunk(chunk)
            chunks.append(processed_chunk)
        
        return pd.concat(chunks).groupby('搜索词').agg({
            '开始时间': 'min',
            '结束时间': 'max',
            '点击量': 'sum',
            '订单量': 'sum'
        }).reset_index()
    else:
        return standard_processing(df1, df2)

并发处理支持：

from concurrent.futures import ThreadPoolExecutor
import threading

class ConcurrentDataMerger:
    """
    支持并发处理的数据合并器
    """
    
    def __init__(self, max_workers=4):
        self.max_workers = max_workers
        self.lock = threading.Lock()
    
    def parallel_group_processing(self, df_combined):
        """
        并行处理不同的搜索词组
        """
        search_terms = df_combined['搜索词'].unique()
        
        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
            futures = []
            
            for term in search_terms:
                future = executor.submit(
                    self.process_single_group, 
                    df_combined[df_combined['搜索词'] == term]
                )
                futures.append(future)
            
            results = [future.result() for future in futures]
        
        return pd.concat(results, ignore_index=True)
    
    def process_single_group(self, group):
        """
        处理单个搜索词组
        """
        # 单个组的处理逻辑
        result = {
            '开始时间': group['开始时间'].min(),
            '结束时间': group['结束时间'].max(),
            '平台': 'none' if len(group) > 1 else group['平台'].iloc[0],
            '搜索词': group['搜索词'].iloc[0],
            '点击量': group['点击量'].sum(),
            '订单量': group['订单量'].sum()
        }
        
        result['转化率'] = round(result['订单量'] / result['点击量'], 2)
        
        return pd.DataFrame([result])

2. 扩展应用场景

实时数据流处理：

class RealTimeDataMerger:
    """
    实时数据流合并处理器
    """
    
    def __init__(self):
        self.accumulated_data = pd.DataFrame()
        self.last_update = None
    
    def add_new_data(self, new_df):
        """
        添加新的数据流
        """
        if self.accumulated_data.empty:
            self.accumulated_data = new_df.copy()
        else:
            self.accumulated_data = pd.concat([self.accumulated_data, new_df], ignore_index=True)
        
        self.last_update = pd.Timestamp.now()
        
        # 自动触发重新聚合
        return self.get_current_aggregation()
    
    def get_current_aggregation(self):
        """
        获取当前聚合结果
        """
        if self.accumulated_data.empty:
            return pd.DataFrame()
        
        merger = DataFrameMerger()
        return merger.aggregate_by_search_term(self.accumulated_data)

多文件批处理：

def batch_file_processing(file_paths, output_path):
    """
    批量处理多个文件
    """
    all_dataframes = []
    
    for file_path in file_paths:
        try:
            if file_path.endswith('.csv'):
                df = pd.read_csv(file_path)
            elif file_path.endswith('.xlsx'):
                df = pd.read_excel(file_path)
            else:
                print(f"不支持的文件格式: {file_path}")
                continue
                
            all_dataframes.append(df)
            
        except Exception as e:
            print(f"读取文件 {file_path} 时出错: {e}")
            continue
    
    if len(all_dataframes) < 2:
        raise ValueError("至少需要两个有效的数据文件")
    
    # 逐步合并所有DataFrame
    result = all_dataframes[0]
    merger = DataFrameMerger()
    
    for df in all_dataframes[1:]:
        result = merger.merge_and_process(result, df)
    
    # 保存结果
    result.to_csv(output_path, index=False, encoding='utf-8-sig')
    print(f"批处理结果已保存到: {output_path}")
    
    return result

✅️小结

本问题的核心在于pandas的高级聚合操作和自定义聚合函数的应用。解决方案的关键技术点包括：

1. 灵活的数据聚合策略：使用pandas的groupby配合自定义聚合函数，实现不同字段采用不同聚合规则的复杂需求

2. 条件性字段处理：通过自定义函数实现平台字段根据分组记录数量的条件性取值逻辑

3. 计算字段的重新计算：在聚合后重新计算转化率，确保数据的准确性

4. 数据类型处理：正确处理时间类型的聚合操作，确保日期比较的准确性

5. 代码的可扩展性：采用面向对象设计，支持数据验证、性能优化、并发处理等高级功能

核心优势：

• 精确性高：严格按照业务逻辑进行数据聚合，确保结果准确
• 性能优良：使用pandas的原生聚合函数，处理效率高
• 可维护性强：模块化设计，易于修改和扩展
• 鲁棒性好：包含完善的数据验证和异常处理机制

应用价值：此解决方案不仅适用于您当前的搜索词数据分析场景，还可以扩展到财务数据汇总、用户行为分析、商品销售统计等多个数据分析领域，是pandas数据处理的典型应用案例。

  希望如上措施及解决方案能够帮到有需要的你。

  PS：如若遇到采纳如下方案还是未解决的同学，希望不要抱怨&&急躁，毕竟影响因素众多，我写出来也是希望能够尽最大努力帮助到同类似问题的小伙伴，即把你未解决或者产生新Bug黏贴在评论区，我们大家一起来努力，一起帮你看看，可以不咯。

  若有对当前Bug有与如下提供的方法不一致，有个不情之请，希望你能把你的新思路或新方法分享到评论区，一起学习，目的就是帮助更多所需要的同学，正所谓「赠人玫瑰，手留余香」。

🧧🧧 文末福利，等你来拿！🧧🧧

  如上问题有的来自我自身项目开发，有的收集网站，有的来自读者…如有侵权，立马删除。再者，针对此专栏中部分问题及其问题的解答思路或步骤等，存在少部分搜集于全网社区及人工智能问答等渠道，若最后实在是没能帮助到你，还望见谅！并非所有的解答都能解决每个人的问题，在此希望屏幕前的你能够给予宝贵的理解，而不是立刻指责或者抱怨！如果你有更优解，那建议你出教程写方案，一同学习！共同进步。

  ok，以上就是我这期的Bug修复内容啦，如果还想查找更多解决方案，你可以看看我专门收集Bug及提供解决方案的专栏《全栈Bug调优(实战版)》，都是实战中碰到的Bug，希望对你有所帮助。到此，咱们下期拜拜。

码字不易，如果这篇文章对你有所帮助，帮忙给 bug菌 来个一键三连(关注、点赞、收藏) ，您的支持就是我坚持写作分享知识点传播技术的最大动力。

同时也推荐大家关注我的硬核公众号:「猿圈奇妙屋」 ；以第一手学习bug菌的首发干货，不仅能学习更多技术硬货，还可白嫖最新BAT大厂面试真题、4000G Pdf技术书籍、万份简历/PPT模板、技术文章Markdown文档等海量资料，你想要的我都有！

🫵 Who am I?

我是bug菌，CSDN | 掘金 | InfoQ | 51CTO | 华为云 | 阿里云 | 腾讯云 等社区博客专家，C站博客之星Top30，华为云多年度十佳博主，掘金多年度人气作者Top40，掘金等各大社区平台签约作者，51CTO年度博主Top12，掘金/InfoQ/51CTO等社区优质创作者；全网粉丝合计 30w+；更多精彩福利点击这里；硬核微信公众号「猿圈奇妙屋」，欢迎你的加入！免费白嫖最新BAT互联网公司面试真题、4000G PDF电子书籍、简历模板等海量资料，你想要的我都有，关键是你不来拿。

-End-