【数据分析】电商用户画像（python实现）

【数据分析】电商用户画像（python实现）

用户画像（User Profile），作为大数据的根基，它完美地抽象出一个用户的信息全貌，为进一步精准、快速地分析用户行为习惯、消费习惯等重要信息，提供了足够的数据基础，奠定了大数据时代的基石。本文探讨了一个基于python实现电商用户画像的项目实例。

用户画像，即用户信息标签化，就是企业通过收集与分析消费者社会属性、生活习惯、消费行为等主要信息的数据之后，完美地抽象出一个用户的商业全貌作是企业应用大数据技术的基本方式。用户画像为企业提供了足够的信息基础，能够帮助企业快速找到精准用户群体以及用户需求等更为广泛的反馈信息。

用户画像有很多的的标签组成，每个标签都规定了观察、认识、描述用户的角度。标签根据企业业务的发展情况，或多或少，对外而言都是一个整体，这个整体称之为用户画像。

用户画像的核心工作就是给用户打标签。
标签通常是人为规定的高度精炼的特征标识，如年龄、性别、兴趣等。这些标签集合就能抽象出一个用户的信息全貌，每个标签分别描述了该用户的一个维度，各个维度之间相互联系，共同构成对用户的一个整体描述。

一、数据背景

以淘宝APP数据为原始数据集，通过行业常见行业指标对淘宝用户行为进行分析，从而构建用户画像。

二、数据来源

数据来源：淘宝官方数据 2014.11.18-2014.12.18

数据集下载：https://pan.baidu.com/link/zhihu/7dhGzNuchRi0Y1YlZUQIF2BlV6SqxUQwdY1m==

三、数据解释

数据集共计2300多万数据量，时间范围为2014-11-18~2014-12-18，共计6个字段，字段释义如下：

字段名	释义
user_id	用户ID
item_id	商品ID
behavior_type	用户行为类型（1：点击，2：收藏，3：加购物车，4：支付)
user_geohash	地理位置信息
item_category	商品类别
time	用户行为发生时间

四、分析过程

1.数据预处理

#导入所需库
import numpy as np
import pandas as pd
import warnings
warnings.filterwarnings('ignore')
from datetime import datetime
%matplotlib inline
from matplotlib import pyplot as plt
plt.rcParams['font.sans-serif'] = 'SimHei'  # 设置中文显示
plt.rcParams['axes.unicode_minus'] = False

# 导入数据集，查看数据量
df = pd.read_csv('taobao_persona.csv')
df.shape

(23291027, 6)

可以看到数据量总计2300多万，因此抽样选取部分样本进行后续分析

# 数据抽样，并预览数据结构
df = df.sample(frac=0.3,random_state=None).reset_index()
df.head()

由于数据集太大，为了提高运行效率，使用sample函数随机抽取30%的数据。

DataFrame.sample()是Pandas中的函数，DataFrame是一种数据格式，代指df。frac(fraction)是抽取多少数据，random_state是随机数种子，目的是保证每次随机抽取的数据一样，防止执行命令时使用不一样的数据。

查看字段缺失情况

# 查看是否存在缺失值
df.isnull().sum()

index 0
user_id 0
item_id 0
behavior_type 0
user_geohash 4773102
item_category 0
time 0
dtype: int64

地理信息字段存在大量缺失，且对后续分析无用，因此我们删除此字段

# 删除缺失字段
df.drop('user_geohash',axis=1,inplace=True)

同时在数据预览中可以看到time字段是由日期和小时组成，为了后续分析，在此将其拆分为两个字段

# 将time日期拆分为日期和时间
df['date'] = df['time'].str[0:10]
df['date'] = pd.to_datetime(df['date'],format='%Y-%m-%d')
df['time'] = df['time'].str[11:]
df['time'] = df['time'].astype(int)
df.head()

为了后续的用户标签，在此基于time字段构造面板数据

# 构造面板数据，将时段分为凌晨，上午，中午，下午，晚上
df['hour'] = pd.cut(df['time'],bins=[-1,5,10,13,18,24],
                    labels=['凌晨','上午','中午','下午','晚上'])
df.head()

生成用户标签

# 生成用户标签列表
users = df['user_id'].unique()
labels = pd.DataFrame(users,columns=['user_id'])

pd.DataFrame()： 其中数据填充的是users，列名为user_id。

结果如图所示：

之后分析后的内容都会放置在此表中，相当于建立了一个空白表，将自己分析后的结论一一加入。

2.1 构建用户行为标签

2.1.1 用户浏览活跃时间段标签

选取出各用户浏览次数最多的时段，看看用户到底在什么时间浏览商品比较多。

# 对用户和时段进行分组，统计浏览次数
time_browse = df[df['behavior_type']==1].groupby(['user_id','hour']).item_id.count().reset_index()
time_browse.rename(columns={'item_id':'hour_counts'},inplace=True)
time_browse.head()

说明：

• groupby([‘key1’,‘key2’])： 多列聚合，分组键为列名。

• reset_index()： 默认drop=False，可以获得新的index，原来的index变成数据列保留下来，第一列会添加计数的数字，不会使用数据中的index。

• rename()： 进行重命名，此处将item_id替换成hour_counts，inplace为是否原地填充。

# 统计每个用户浏览次数最多的时间段
time_browse_max = time_browse.groupby('user_id').hour_counts.max().reset_index()
time_browse_max.rename(columns={'hour_counts':'read_counts_max'},inplace=True)

# 两个结果做连接
time_browse = pd.merge(time_browse,time_browse_max,how='left',on='user_id')
time_browse.head()

说明：

• pd.merge()： 将两个表合并在一起，横向合并，on代表通过某个主键，how指左合并，每行一一对应。

# 选取每个用户浏览次数最多的时间段
time_browse_hour = time_browse.loc[time_browse['hour_counts']==time_browse['read_counts_max'],'hour']

# 存在并列多个时用逗号连接，得到用户活跃时间段标签
time_browse_hour = time_browse_hour.groupby(time_browse['user_id']).aggregate(lambda x:','.join(x)).reset_index()
time_browse_hour.head()

说明：

• loc函数： 通过行索引Index中的具体值来取指定数据。
• aggregate函数： groupby分组之后会返回多个子数据帧，该函数可以实现数据聚合，可以得到每个子数据帧的某些列的某些信息。
• lambda函数： 可以定义一个匿名函数，lambda [arg1[, arg2, … argN]]: expression，其中参数是函数的输入，是可选的，后面的表达式则为输出，此处和join()函数一起用，其中每个x值能被“,”隔开;

# 将用户浏览活跃时间加入用户标签中
labels = pd.merge(labels,time_browse_hour,how='left',on='user_id')
labels.rename(columns={'hour':'time_browse'},inplace=True)
labels.head()

2.1.2 用户购买活跃时间段标签

time_buy = df[df['behavior_type']==4].groupby(['user_id','hour']).item_id.count().reset_index().rename(columns={'item_id':'hour_counts'})
time_buy_max = time_buy.groupby('user_id').hour_counts.max().reset_index().rename(columns={'hour_counts':'buy_counts_max'})
time_buy = pd.merge(time_buy,time_buy_max,how='left',on='user_id')
time_buy_hour = time_buy.loc[time_buy['hour_counts']==time_buy['buy_counts_max'],'hour']
time_buy_hour = time_buy_hour.groupby(time_buy['user_id']).aggregate(lambda x:','.join(x)).reset_index()
time_buy_hour.head()

# 将用户购买活跃时间段加入到用户标签表中
labels = pd.merge(labels,time_buy_hour,how='left',on='user_id').rename(columns={'hour':'time_buy'})
labels.head()

2.1.3 用户浏览最多的商品类别

# 对用户与类别进行分组，统计浏览次数

df_browse = df.loc[df['behavior_type']==1,['user_id','item_id','item_category']]
df_cate_most_browse = df_browse.groupby(['user_id','item_category']).item_id.count().reset_index()
df_cate_most_browse.rename(columns={'item_id':'item_category_counts'},inplace=True)

# 每个用户浏览最多的商品类别

df_cate_most_browse_max = df_cate_most_browse.groupby('user_id').item_category_counts.max().reset_index()
df_cate_most_browse_max.rename(columns={'item_category_counts':'item_category_counts_max'},inplace=True)
df_cate_most_browse = pd.merge(df_cate_most_browse,df_cate_most_browse_max,how='left',on='user_id')
df_cate_most_browse['item_category'] = df_cate_most_browse['item_category'].astype(str)

# 选取每个用户浏览次数最多的类别，存在并列时，用逗号连接

df_cate_browse = df_cate_most_browse.loc[df_cate_most_browse['item_category_counts']==
                                        df_cate_most_browse['item_category_counts_max'],
                                        'item_category'].groupby(df_cate_most_browse['user_id']).aggregate(lambda x:','.join(x)).reset_index()

# 将用户浏览量最多的类目加入到用户标签中

labels = pd.merge(labels,df_cate_browse,how='left',on='user_id')
labels.rename(columns={'item_category':'cate_most_browse'},inplace=True)
labels.head()

2.1.4 用户收藏最多的商品类别

# 过程与上述类似
df_collect = df.loc[df['behavior_type']==2,['user_id','item_id','item_category']]
df_cate_most_collect = df_collect.groupby(['user_id','item_category']).item_id.count().reset_index()
df_cate_most_collect.rename(columns={'item_id':'item_category_counts'},inplace=True)
df_cate_most_collect_max = df_cate_most_collect.groupby('user_id').item_category_counts.max().reset_index()
df_cate_most_collect_max.rename(columns={'item_category_counts':'item_category_counts_max'},inplace=True)
df_cate_most_collect = pd.merge(df_cate_most_collect,df_cate_most_collect_max,how='left',on='user_id')
df_cate_most_collect['item_category'] = df_cate_most_collect['item_category'].astype(str)
df_cate_collect = df_cate_most_collect.loc[
    df_cate_most_collect['item_category_counts']==df_cate_most_collect[
        'item_category_counts_max'],'item_category'].groupby(
    df_cate_most_collect['user_id']).aggregate(lambda x:','.join(x)).reset_index()
labels = pd.merge(labels,df_cate_collect,how='left',on='user_id')
labels.rename(columns={'item_category':'cate_most_collect'},inplace=True)
labels.head()

2.1.5 用户加购物车最多的商品类别

# 同上
df_cart = df.loc[df['behavior_type']==3,['user_id','item_id','item_category']]
df_cate_most_cart = df_cart.groupby(['user_id','item_category']).item_id.count().reset_index()
df_cate_most_cart.rename(columns={'item_id':'item_category_counts'},inplace=True)
df_cate_most_cart_max = df_cate_most_cart.groupby('user_id').item_category_counts.max().reset_index()
df_cate_most_cart_max.rename(columns={'item_category_counts':'item_category_counts_max'},inplace=True)
df_cate_most_cart = pd.merge(df_cate_most_cart,df_cate_most_cart_max,how='left',on='user_id')
df_cate_most_cart['item_category'] = df_cate_most_cart['item_category'].astype(str)
df_cate_cart = df_cate_most_cart.loc[df_cate_most_cart['item_category_counts']==df_cate_most_cart['item_category_counts_max'],'item_category'].groupby(df_cate_most_cart['user_id']).aggregate(lambda x:','.join(x)).reset_index()
labels = pd.merge(labels,df_cate_cart,how='left',on='user_id')
labels.rename(columns={'item_category':'cate_most_cart'},inplace=True)
labels.head()

2.1.6 用户购买最多的商品类别

# 同上
df_buy = df.loc[df['behavior_type']==4,['user_id','item_id','item_category']]
df_cate_most_buy = df_buy.groupby(['user_id','item_category']).item_id.count().reset_index()
df_cate_most_buy.rename(columns={'item_id':'item_category_counts'},inplace=True)
df_cate_most_buy_max = df_cate_most_buy.groupby('user_id').item_category_counts.max().reset_index()
df_cate_most_buy_max.rename(columns={'item_category_counts':'item_category_counts_max'},inplace=True)
df_cate_most_buy = pd.merge(df_cate_most_buy,df_cate_most_buy_max,how='left',on='user_id')
df_cate_most_buy['item_category'] = df_cate_most_buy['item_category'].astype(str)
df_cate_buy = df_cate_most_buy.loc[df_cate_most_buy['item_category_counts']==df_cate_most_buy['item_category_counts_max'],'item_category'].groupby(df_cate_most_buy['user_id']).aggregate(lambda x:','.join(x)).reset_index()
labels = pd.merge(labels,df_cate_buy,how='left',on='user_id')
labels.rename(columns={'item_category':'cate_most_buy'},inplace=True)
labels.head()

从整理的数据中可以看出，浏览、加购物车、收藏、购买之前其实不一定存在明显的必然关系，我们还需要进一步分析得到一些规律。

2.2 关于时间的用户行为标签

2.2.1 近30天用户行为

2.2.1.1 近30天购买次数

# 近30天购买次数
# 将购买行为按用户进行分组，统计次数
df_counts_30_buy = df[df['behavior_type']==4].groupby('user_id').item_id.count().reset_index()
labels = pd.merge(labels,df_counts_30_buy,how='left',on='user_id').rename(columns={'item_id':'counts_30_buy'})
labels.head()

2.2.1.2 近30天加购物车次数

df_counts_30_cart = df[df['behavior_type']==3].groupby('user_id').item_id.count().reset_index()
labels = pd.merge(labels,df_counts_30_cart,how='left',on='user_id')
labels.rename(columns={'item_id':'counts_30_cart'},inplace=True)

2.2.1.3 近30天活跃天数

counts_30_active = df.groupby('user_id')['date'].agg(['nunique']).reset_index()
labels = pd.merge(labels,counts_30_active,how='left',on='user_id')
labels.rename(columns={'nunique':'counts_30_active'},inplace=True)
labels.head()

近30天用户行为分析属于中长期的用户行为，我们可以依此判断是否需要调整营销策略，类似可以得到短期的7天用户行为分析，观察中短期或一个小周期内，用户的行为是何种情况。

2.2.2 近7天用户行为

2.2.2.1 近7天购买次数

# 取出最后7天的数据
df_near_7 = df[df['date']>datetime.strptime('2014-12-11','%Y-%m-%d')]

# 近7天购买次数
df_counts_7_buy = df_near_7[df_near_7['behavior_type']==4].groupby('user_id').item_id.count().reset_index()
labels = pd.merge(labels,df_counts_7_buy,how='left',on='user_id')
labels.rename(columns={'item_id':'counts_7_buy'},inplace=True)
labels.head(10)

2.2.2.2 近7天加购物车次数

# 近七天加购物车次数
df_counts_7_cart = df_near_7[df_near_7['behavior_type']==3].groupby('user_id').item_id.count().reset_index()
labels = pd.merge(labels,df_counts_7_cart,how='left',on='user_id')
labels.rename(columns={'item_id':'counts_7_cart'},inplace=True)
labels.head(10)

2.2.2.3 近7天活跃天数

# 近7天活跃天数
counts_7_active = df_near_7.groupby('user_id')['date'].agg(['nunique']).reset_index()
labels = pd.merge(labels,counts_7_active,how='left',on='user_id')
labels.rename(columns={'nunique':'counts_7_active'},inplace=True)
labels.head(10)

2.2.3 最后一次行为距今天数

2.2.3.1 最后一次浏览距今天数

# 最后一次浏览距今的天数
days_browse = df[df['behavior_type']==1].groupby('user_id')['date'].max().agg([lambda x:(datetime.strptime('2014-12-19','%Y-%m-%d')-x).days]).reset_index()
labels= pd.merge(labels,days_browse,how='left',on='user_id')
labels.rename(columns={'':'days_browse'},inplace=True)
labels.head(10)

2.2.3.2 最后一次加购物车距今天数

# 最后一次加购物车距今的天数
days_cart = df[df['behavior_type']==3].groupby('user_id')['date'].max().agg([lambda x:(datetime.strptime('2014-12-19','%Y-%m-%d')-x).days]).reset_index()
labels= pd.merge(labels,days_cart,how='left',on='user_id')
labels.rename(columns={'':'days_cart'},inplace=True)
labels.head()

说明：

• datetime.strptime(‘2014-12-19’,’%Y-%m-%d’)-x).days： 该部分属于lambda中的函数表达式部分，即计算规则，此处最后取相减后的天数总和。

2.2.3.3 最后一次购买距今天数

# 最后一次购买距今天数
days_buy = df[df['behavior_type']==4].groupby('user_id')['date'].max().agg([lambda x:(datetime.strptime('2014-12-19','%Y-%m-%d')-x).days])
labels = pd.merge(labels,days_buy,how='left',on='user_id')
labels.rename(columns={'':'days_buy'},inplace=True)
labels.head()

2.2.3.4 最后两次购买的时间间隔天数

# 最近两次购买间隔天数
df_interval_buy = df[df['behavior_type']==4].groupby(['user_id','date']).item_id.count().reset_index()
interval_buy = df_interval_buy.groupby('user_id')['date'].apply(lambda x:x.sort_values().diff(1).dropna().head(1)).reset_index()
interval_buy['date'] = interval_buy['date'].apply(lambda x:x.days)
interval_buy.drop('level_1',axis=1,inplace=True)
interval_buy.rename(columns={'date':'interval_buy'},inplace=True)
labels = pd.merge(labels,interval_buy,how='left',on='user_id')
labels.head()

2.3 关于是否购买的用户行为

2.3.1 用户是否存在浏览未下单行为

# 用户是否存在浏览未下单行为
df_browse_buy = df.loc[(df['behavior_type']==1) | (df['behavior_type']==4),['user_id','item_id','behavior_type','time']]
browse_not_buy = pd.pivot_table(df_browse_buy,index=['user_id','item_id'],columns=['behavior_type'],values=['time'],aggfunc=['count'])
browse_not_buy.fillna(0,inplace=True)
browse_not_buy.columns=['browse','buy']

# 添加了一列browse_not_buy，初始值为0。
browse_not_buy['browse_not_buy']=0

# 浏览数>0,购买数=0的数据输出1.
browse_not_buy.loc[(browse_not_buy['browse']>0) & (browse_not_buy['buy']==0),'browse_not_buy']=1
browse_not_buy = browse_not_buy.groupby('user_id')['browse_not_buy'].sum().reset_index()
labels = pd.merge(labels,browse_not_buy,how='left',on='user_id')
labels['browse_not_buy'] = labels['browse_not_buy'].apply(lambda x:'是' if x>0 else '否')
labels.head()

说明：

• |： 在Python语句中表示或，&表示且。
• pd.pivot_table()： 透视表功能，df_browse_buy为data块，values可以对需要的计算数据进行筛选，aggfunc参数可以设置我们对数据聚合时进行的函数操作。
• fillna： 会填充NaN数据，返回填充后的结果，inplace=True代表原地填充。

2.3.2 用户是否存在加购物车未下单行为

# 是否存在加购物车未下单行为
df_cart_buy = df.loc[(df['behavior_type']==3) | (df['behavior_type']==4),['user_id','item_id','behavior_type','time']]
cart_not_buy = pd.pivot_table(df_cart_buy,index=['user_id','item_id'],columns=['behavior_type'],values=['time'],aggfunc=['count'])
cart_not_buy.columns = ['cart','buy']
cart_not_buy.fillna(0,inplace=True)
cart_not_buy['cart_not_buy']=0
cart_not_buy.loc[(cart_not_buy['cart']>0) & (cart_not_buy['buy']==0),'cart_not_buy']=1
cart_not_buy = cart_not_buy.groupby('user_id')['cart_not_buy'].sum().reset_index()
labels = pd.merge(labels,cart_not_buy,how='left',on='user_id')
labels['cart_not_buy'] = labels['cart_not_buy'].apply(lambda x: '是' if x>0 else '否')
labels.head()

制定营销策略时，要重点注意这部分人群，因为加购未下单的购买转化率是最大的，有成功下单、最大潜力的客户就在这里。

2.4 用户属性标签

2.4.1 是否复购用户

# 是否复购用户
buy_again = df[df['behavior_type']==4].groupby('user_id')['item_id'].count().reset_index()
buy_again.rename(columns={'item_id':'buy_again'},inplace=True)
labels=pd.merge(labels,buy_again,how='left',on='user_id')
labels['buy_again'].fillna(-1,inplace=True)
labels['buy_again'] = labels['buy_again'].apply(lambda x:'是' if x>1 else '否' if x==1 else '未购买')
labels.head()

2.4.2 访问活跃度

# 访问活跃度
user_active_level = labels['counts_30_active'].value_counts().sort_index(ascending=False)
plt.figure(figsize=(16,9))
user_active_level.plot(title='30天内访问次数与访问人数的关系',fontsize=18)
plt.xlabel('访问次数',fontsize=15)
plt.ylabel('访问人数',fontsize=15)

说明：

• value_counts()： 查看表格某列中有多少个不同值，并计算每个不同值在该列中有多少重复值。
• sort_index()： 按照某一列的大小进行排序，ascending=False是按照从大到小排序。
• plt.figure(figsize=(a,b))： 创建画板，figsize代表宽为a，高为b的图形，单位为英寸。
• plt.ylabel： 设置y轴，fontsize是字体大小。
• plt.xlabel： 设置x轴。

从图中可以看出，访问次数和访问人数成正相关关系，这里取访问次数20以上的定义为活跃用户。此定义只是从用户的角度出发，工作中当从业务角度定义。访问次数多的访客比访问次数少的访客数量多，与绝大多数的产品访问规律相反，从侧面反映了用户黏性之强。

labels['user_active_level']='高'
labels.loc[labels['counts_30_active']<=20,'user_active_level'] = '低'
labels.head()

2.4.3 购买活跃度

# 购买活跃度
buy_active_level = labels['counts_30_buy'].value_counts().sort_index(ascending=False)
plt.figure(figsize=(16,9))
buy_active_level.plot(title='30天内购买次数与购买人数的关系',fontsize=18)
plt.xlabel('购买次数',fontsize=15)
plt.ylabel('购买人数',fontsize=15)

从图中曲线可以看出拐点大约是15，因此定义购买次数在15次以下为低活跃度，15次以上为高活跃度。

# 定义购买活跃度标签
labels['buy_active_level'] = '高'
labels.loc[labels['counts_30_buy']<=15,'buy_active_level'] = '低'
labels.head()

2.4.4购买品类是否单一

# 购买品类是否单一
buy_single = df[df['behavior_type']==4].groupby('user_id').item_category.nunique().reset_index()
buy_single.rename(columns={'item_category':'buy_single'},inplace=True)
labels = pd.merge(labels,buy_single,how='left',on='user_id')
labels['buy_single'].fillna(-1,inplace=True)
labels['buy_single'] = labels['buy_single'].apply(lambda x:'是' if x>1 else '否' if x==1 else '未购买')
labels.head()

了解用户购买的品类有利于构建用户群体行为，比如该群体统一对化妆品消费占比巨大，则该用户群体的主要特征标签之一就是化妆品。

2.4.5 用户价值分组RFM

# 用户价值分组RFM
last_buy_days = labels['days_buy'].value_counts().sort_index()
plt.figure(figsize=(16,9))
last_buy_days.plot(title='最后一次购买距今天数与购买人数的关系',fontsize=18)
plt.xlabel('距今天数',fontsize=15)
plt.ylabel('购买人数',fontsize=15)

从图中可以看出，最后一次购买距今天数为7天的购买人数最多，分析其原因是因为当天双十二促销活动，因此定义最后一次购买行为距今8天以上的为低活跃用户。

labels['buy_days_level'] = '高'
labels.loc[labels['days_buy']>8,'buy_days_level'] = '低'
labels.head()

# 利用用户活跃程度和最近购买两个指标来计算RFM
labels['rfm_value'] = labels['user_active_level'].str.cat(labels['buy_days_level'])
def trans_value(x):
    if x=='高高':
        return '重要价值客户'
    elif x=='低高':
        return '重要深耕客户'
    elif x=='高低':
        return '重要召回客户'
    else:
        return '即将流失客户'
    
labels['rfm'] = labels['rfm_value'].apply(trans_value)
labels.head()

labels.drop(['buy_days_level','rfm_value'],axis=1,inplace=True)
labels['rfm'].value_counts()

说明：

• str.cat() 是指将两个独立的字符串拼接，此处将’user_active_level’和’buy_days_level’ 拼接。如果要在两个合并的列中间加一个分隔符号，可在cat括号内加：sep=’-’，用-连接合并内容。

将user_active_level和buy_days_level组合，形成“高高”或者“高低”等。将两个重要指标合并后，每个user_id进入不同的分类组。RFM模型是衡量客户价值和客户创利能力的重要工具和手段，其中，R(recently)：最近一次消费；F（Frequently）：消费频率；M（Monetary）：消费金额。

# 作柱状图
labels['rfm'].value_counts().plot.bar()
plt.xticks(rotation=0)

可以看到淘宝用户高价值客户较多。
对最后输出的用户群体制定不同的营销策略。针对重要价值客户要予以关注并维护；针对重要深耕用户，予以相应的价格刺激，如折扣和捆绑销售等增加用户的购买频率，提高黏性；针对重要召回客户，要在特定时间点进行刺激，比如进行产品卖点刺激、品牌灌输等，不断加强他们对品牌的认可，提高忠诚度；针对流失客户，需进一步分析得出流失原因。