项目2：用户行为分析与RFM模型，我用Python精准识别高价值客户

github star gitee star atomgit star PyPI Downloads AI 编程 AI 交流群

大家好，我是正在实战各种AI项目的程序员晚枫。

欢迎来到第二个实战项目！这次我们要聊的是用户行为分析，核心工具是经典的RFM模型。

做运营的朋友都知道，用户不是铁板一块。有的用户天天买，有的买完就跑；有的出手阔绰，有的只薅羊毛。RFM模型就是帮你把用户分层的利器，让你知道该对谁重点投入，该放弃谁。

项目背景

需求场景

你是某电商平台的用户运营负责人，面临这些问题：

  1. 用户数量庞大，不知道谁是核心用户
  2. 营销预算有限，想把钱花在刀刃上
  3. 想针对不同用户制定差异化策略

目标产出

用RFM模型对用户进行分层，输出可执行的运营策略建议。

什么是RFM模型？

RFM是三个英文单词的首字母：

指标含义业务意义
R (Recency)最近一次消费距今天数R越小越活跃
F (Frequency)消费频次F越大越忠诚
M (Monetary)消费金额M越大价值越高

核心逻辑：最近买过、经常买、花得多的用户，就是最值钱的用户。

准备数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

# 生成模拟用户交易数据
np.random.seed(42)

def generate_user_transactions(n_users=1000, days=365):
    """生成用户交易记录"""
    end_date = datetime(2024, 12, 31)
    
    data = []
    for user_id in range(1, n_users + 1):
        # 随机决定这个用户的活跃度类型
        user_type = np.random.choice(
            ['高频高价值', '高频低价值', '低频高价值', '流失风险', '新用户'],
            p=[0.15, 0.25, 0.15, 0.30, 0.15]
        )
        
        if user_type == '高频高价值':
            n_orders = np.random.randint(20, 50)
            avg_amount = np.random.randint(500, 2000)
        elif user_type == '高频低价值':
            n_orders = np.random.randint(15, 40)
            avg_amount = np.random.randint(50, 200)
        elif user_type == '低频高价值':
            n_orders = np.random.randint(3, 8)
            avg_amount = np.random.randint(1000, 5000)
        elif user_type == '流失风险':
            n_orders = np.random.randint(1, 5)
            avg_amount = np.random.randint(100, 800)
        else:  # 新用户
            n_orders = np.random.randint(1, 3)
            avg_amount = np.random.randint(200, 1000)
        
        # 生成订单日期（集中在不同时间段）
        if user_type == '流失风险':
            # 流失用户：订单都在早期
            dates = pd.date_range(end=end_date - timedelta(days=180), periods=n_orders, freq='D')
        elif user_type == '新用户':
            # 新用户：订单都在近期
            dates = pd.date_range(end=end_date, periods=n_orders, freq='D')
        else:
            # 其他用户：分散在全年
            dates = pd.date_range(end=end_date, periods=n_orders, freq=f'{365//n_orders}D')
        
        for date in dates[:n_orders]:
            data.append({
                '用户ID': f'USER{user_id:05d}',
                '订单日期': date,
                '订单金额': max(10, int(np.random.normal(avg_amount, avg_amount * 0.3))),
                '用户类型': user_type
            })
    
    return pd.DataFrame(data)

# 生成数据
df = generate_user_transactions(n_users=1000)
df.to_csv('user_transactions.csv', index=False, encoding='utf-8-sig')
print(f"生成了 {len(df)} 条交易记录，涉及 {df['用户ID'].nunique()} 个用户")

计算RFM指标

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class RFMAnalyzer:
    def __init__(self, data_path, analysis_date=None):
        self.df = pd.read_csv(data_path, encoding='utf-8-sig')
        self.df['订单日期'] = pd.to_datetime(self.df['订单日期'])
        self.analysis_date = analysis_date or self.df['订单日期'].max()
        print(f"分析基准日期: {self.analysis_date.strftime('%Y-%m-%d')}")
        print(f"共 {self.df['用户ID'].nunique()} 个用户，{len(self.df)} 笔交易")
    
    def calculate_rfm(self):
        """计算每个用户的RFM指标"""
        rfm = self.df.groupby('用户ID').agg({
            '订单日期': lambda x: (self.analysis_date - x.max()).days,  # Recency
            '订单金额': ['count', 'sum']  # Frequency, Monetary
        }).reset_index()
        
        # 重命名列
        rfm.columns = ['用户ID', 'R', 'F', 'M']
        
        # 确保数据类型正确
        rfm['R'] = rfm['R'].astype(int)
        rfm['F'] = rfm['F'].astype(int)
        rfm['M'] = rfm['M'].astype(float)
        
        self.rfm = rfm
        return rfm
    
    def rfm_summary(self):
        """RFM指标统计摘要"""
        return self.rfm[['R', 'F', 'M']].describe()

RFM评分与分层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
def score_rfm(self, r_bins=5, f_bins=5, m_bins=5):
    """
    给RFM打分（1-5分）
    注意：R越小越好，所以分数要倒序
    """
    # 使用分位数进行打分
    self.rfm['R_score'] = pd.qcut(self.rfm['R'], q=r_bins, labels=[5,4,3,2,1])
    self.rfm['F_score'] = pd.qcut(self.rfm['F'].rank(method='first'), q=f_bins, labels=[1,2,3,4,5])
    self.rfm['M_score'] = pd.qcut(self.rfm['M'], q=m_bins, labels=[1,2,3,4,5])
    
    # 转换为数值型
    self.rfm['R_score'] = self.rfm['R_score'].astype(int)
    self.rfm['F_score'] = self.rfm['F_score'].astype(int)
    self.rfm['M_score'] = self.rfm['M_score'].astype(int)
    
    # 综合RFM得分
    self.rfm['RFM_score'] = (self.rfm['R_score'].astype(str) + 
                              self.rfm['F_score'].astype(str) + 
                              self.rfm['M_score'].astype(str))
    
    return self.rfm

def segment_users(self):
    """根据RFM进行用户分层"""
    def get_segment(row):
        r, f, m = row['R_score'], row['F_score'], row['M_score']
        
        # 定义分层规则
        if r >= 4 and f >= 4 and m >= 4:
            return '重要价值客户'
        elif r >= 4 and f >= 4 and m <= 2:
            return '重要保持客户'
        elif r >= 4 and f <= 2 and m >= 4:
            return '重要发展客户'
        elif r <= 2 and f >= 4 and m >= 4:
            return '重要挽留客户'
        elif r >= 4 and f <= 2 and m <= 2:
            return '新客户'
        elif r <= 2 and f >= 4 and m <= 2:
            return '一般保持客户'
        elif r <= 2 and f <= 2 and m >= 4:
            return '潜力客户'
        elif r <= 2 and f <= 2 and m <= 2:
            return '流失客户'
        else:
            return '一般客户'
    
    self.rfm['客户分层'] = self.rfm.apply(get_segment, axis=1)
    return self.rfm

可视化分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
import matplotlib.pyplot as plt
import seaborn as sns

class RFMVisualizer:
    def __init__(self, analyzer):
        self.analyzer = analyzer
        plt.style.use('seaborn-v0_8')
    
    def plot_rfm_distribution(self):
        """RFM指标分布图"""
        fig, axes = plt.subplots(1, 3, figsize=(15, 4))
        
        # R分布
        axes[0].hist(self.analyzer.rfm['R'], bins=30, color='skyblue', edgecolor='black')
        axes[0].set_title('Recency Distribution\n(Last Purchase Days)', fontsize=12)
        axes[0].set_xlabel('Days Since Last Purchase')
        axes[0].set_ylabel('Number of Users')
        axes[0].axvline(self.analyzer.rfm['R'].mean(), color='red', linestyle='--', 
                       label=f'Mean: {self.analyzer.rfm["R"].mean():.0f}')
        axes[0].legend()
        
        # F分布
        axes[1].hist(self.analyzer.rfm['F'], bins=30, color='lightgreen', edgecolor='black')
        axes[1].set_title('Frequency Distribution\n(Purchase Count)', fontsize=12)
        axes[1].set_xlabel('Number of Purchases')
        axes[1].set_ylabel('Number of Users')
        axes[1].axvline(self.analyzer.rfm['F'].mean(), color='red', linestyle='--',
                       label=f'Mean: {self.analyzer.rfm["F"].mean():.1f}')
        axes[1].legend()
        
        # M分布
        axes[2].hist(self.analyzer.rfm['M'], bins=30, color='salmon', edgecolor='black')
        axes[2].set_title('Monetary Distribution\n(Total Spent)', fontsize=12)
        axes[2].set_xlabel('Total Amount')
        axes[2].set_ylabel('Number of Users')
        axes[2].axvline(self.analyzer.rfm['M'].mean(), color='red', linestyle='--',
                       label=f'Mean: ¥{self.analyzer.rfm["M"].mean():.0f}')
        axes[2].legend()
        
        plt.tight_layout()
        plt.savefig('rfm_distribution.png', dpi=300, bbox_inches='tight')
        plt.show()
    
    def plot_segment_pie(self):
        """客户分层饼图"""
        segment_counts = self.analyzer.rfm['客户分层'].value_counts()
        
        colors = plt.cm.Set3(np.linspace(0, 1, len(segment_counts)))
        
        plt.figure(figsize=(10, 8))
        wedges, texts, autotexts = plt.pie(
            segment_counts, 
            labels=segment_counts.index,
            autopct='%1.1f%%',
            colors=colors,
            startangle=90
        )
        
        plt.title('User Segmentation Distribution', fontsize=16, fontweight='bold')
        plt.axis('equal')
        plt.savefig('segment_pie.png', dpi=300, bbox_inches='tight')
        plt.show()
        
        return segment_counts
    
    def plot_segment_comparison(self):
        """各分层对比柱状图"""
        segment_stats = self.analyzer.rfm.groupby('客户分层').agg({
            'R': 'mean',
            'F': 'mean', 
            'M': 'mean',
            '用户ID': 'count'
        }).rename(columns={'用户ID': '用户数'}).round(2)
        
        fig, axes = plt.subplots(2, 2, figsize=(14, 10))
        
        # 用户数
        axes[0,0].barh(segment_stats.index, segment_stats['用户数'], color='steelblue')
        axes[0,0].set_title('User Count by Segment', fontsize=12)
        axes[0,0].set_xlabel('Number of Users')
        
        # 平均R值
        axes[0,1].barh(segment_stats.index, segment_stats['R'], color='coral')
        axes[0,1].set_title('Average Recency by Segment', fontsize=12)
        axes[0,1].set_xlabel('Days Since Last Purchase')
        
        # 平均F值
        axes[1,0].barh(segment_stats.index, segment_stats['F'], color='lightgreen')
        axes[1,0].set_title('Average Frequency by Segment', fontsize=12)
        axes[1,0].set_xlabel('Average Purchase Count')
        
        # 平均M值
        axes[1,1].barh(segment_stats.index, segment_stats['M'], color='gold')
        axes[1,1].set_title('Average Monetary by Segment', fontsize=12)
        axes[1,1].set_xlabel('Average Total Spent')
        
        plt.tight_layout()
        plt.savefig('segment_comparison.png', dpi=300, bbox_inches='tight')
        plt.show()
        
        return segment_stats

运营策略建议

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
def generate_strategy_report(analyzer):
    """生成运营策略报告"""
    
    strategies = {
        '重要价值客户': {
            '特征': '最近购买、高频、高消费',
            '占比': '',
            '策略': [
                'VIP专属服务，提供1对1客服',
                '新品优先体验权',
                '积分翻倍、生日特权',
                '邀请成为品牌大使'
            ]
        },
        '重要保持客户': {
            '特征': '最近购买、高频、但消费低',
            '占比': '',
            '策略': [
                '推送高客单价商品',
                '满减券刺激消费升级',
                '组合套餐推荐',
                '会员等级激励'
            ]
        },
        '重要发展客户': {
            '特征': '最近购买、消费高、但频次低',
            '占比': '',
            '策略': [
                '定期复购提醒',
                '订阅制服务推荐',
                '个性化推荐算法',
                '限时优惠促活'
            ]
        },
        '重要挽留客户': {
            '特征': '曾经高频高消费，但很久没来了',
            '占比': '',
            '策略': [
                '大额优惠券召回',
                '短信/电话关怀',
                '老客专属活动',
                '了解流失原因'
            ]
        },
        '新客户': {
            '特征': '最近才来，消费少',
            '占比': '',
            '策略': [
                '新手引导教程',
                '首单优惠',
                '新人专享礼包',
                '快速建立信任'
            ]
        },
        '一般保持客户': {
            '特征': '以前常来但消费低，现在不来了',
            '占比': '',
            '策略': [
                '低成本触达（邮件/推送）',
                '小额优惠券',
                '随缘维护'
            ]
        },
        '潜力客户': {
            '特征': '消费高但很久没来，且次数少',
            '占比': '',
            '策略': [
                '分析首次购买体验',
                '针对性改进产品',
                '定向广告投放'
            ]
        },
        '流失客户': {
            '特征': '很久没来、消费少、次数少',
            '占比': '',
            '策略': [
                '放弃治疗，减少投入',
                '极低成本的偶尔触达',
                '资源投入到其他群体'
            ]
        }
    }
    
    # 计算各层占比
    segment_counts = analyzer.rfm['客户分层'].value_counts()
    total_users = len(analyzer.rfm)
    
    print("="*60)
    print("【RFM用户分层运营策略报告】")
    print("="*60)
    
    for segment, info in strategies.items():
        count = segment_counts.get(segment, 0)
        percentage = count / total_users * 100
        info['占比'] = f"{percentage:.1f}%"
        
        print(f"\n📊 {segment} ({count}人, {percentage:.1f}%)")
        print(f"   特征: {info['特征']}")
        print(f"   策略:")
        for i, strategy in enumerate(info['策略'], 1):
            print(f"      {i}. {strategy}")
    
    return strategies

主程序运行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
def main():
    """主程序"""
    print("="*60)
    print("RFM用户行为分析系统")
    print("="*60)
    
    # 1. 初始化分析器
    print("\n[1/5] 加载数据...")
    analyzer = RFMAnalyzer('user_transactions.csv')
    
    # 2. 计算RFM
    print("[2/5] 计算RFM指标...")
    rfm = analyzer.calculate_rfm()
    print("\nRFM指标统计:")
    print(analyzer.rfm_summary())
    
    # 3. 评分与分层
    print("\n[3/5] RFM评分与用户分层...")
    analyzer.score_rfm()
    analyzer.segment_users()
    print("\n各分层人数:")
    print(analyzer.rfm['客户分层'].value_counts())
    
    # 4. 可视化
    print("\n[4/5] 生成可视化图表...")
    visualizer = RFMVisualizer(analyzer)
    visualizer.plot_rfm_distribution()
    visualizer.plot_segment_pie()
    visualizer.plot_segment_comparison()
    print("  ✓ 图表已保存")
    
    # 5. 策略报告
    print("\n[5/5] 生成运营策略...")
    generate_strategy_report(analyzer)
    
    # 导出结果
    output_file = 'rfm_analysis_result.csv'
    analyzer.rfm.to_csv(output_file, index=False, encoding='utf-8-sig')
    print(f"\n  ✓ 详细结果已保存: {output_file}")
    
    print("\n" + "="*60)
    print("分析完成！")
    print("="*60)

if __name__ == "__main__":
    main()

项目总结

学到的技能

  • ✅ RFM模型的原理与应用
  • ✅ 用户分层的量化方法
  • ✅ 基于数据的运营决策
  • ✅ 多维度数据可视化

RFM的价值

  1. 精准营销：钱花在刀刃上
  2. 资源优化：识别最有价值的用户
  3. 策略差异化：不同用户不同对待
  4. 效果可衡量：分层后追踪转化率

扩展方向

  • 结合机器学习预测用户LTV
  • 构建用户流失预警模型
  • A/B测试验证策略效果
  • 实时RFM看板开发

下节预告

下一项目是库存分析与预测，学习如何用时间序列方法预测商品销量，优化库存管理。

👉 继续阅读：项目3-库存分析与销量预测

💬 加入学习交流群

扫码加入Python学习交流群，和数千名同学一起进步：

👉 点击加入交流群

群里不定期分享：

  • 数据分析实战案例
  • Python学习资料
  • 求职面试经验
  • 行业最新动态

推荐：AI Python数据分析实战营

🎁 限时福利：送《利用Python进行数据分析》实体书

👉 点击了解详情

课程导航

上一篇： 项目1-销售数据分析报表自动化

下一篇： 项目3-库存分析与销量预测

PS：RFM模型是用户运营的核武器。掌握它，你就掌握了精细化运营的核心能力。

进群

嗨，扫码 进群

微信

扫一扫，分享到微信

微信分享二维码
本站总访问量次

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置：

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

编程博主，全网粉丝30w+，开源项目：python-office，我的微信：python-office