影刀RPA实战：自动分析视频号用户消费行为，让数据驱动决策！🚀
大家好，我是林焱，影刀RPA的资深开发与布道者。今天要分享一个让电商运营和数据分析师都"眼前一亮"的自动化方案——使用影刀RPA自动分析视频号用户消费行为。如果你还在为手动整理用户数据、制作消费报表而熬夜加班，或者因为数据分析不及时而错失商机，那这篇文章绝对能让你如获至宝！🤖
还在手动分析用户消费行为？ 每天从不同平台导出数据，在Excel里各种VLOOKUP、数据透视表，只为搞清楚用户喜欢什么、什么时候购买、客单价多少——这种原始的数据处理方式，不仅让你沦为"表哥表姐"，还经常因为数据更新不及时导致决策滞后！更扎心的是，当你还在埋头做报表时，竞争对手已经通过自动化分析发现了新的增长机会……😫
但别担心，今天我就带你用影刀RPA打造一个智能、实时、多维度的用户行为分析系统，让数据洞察变得"丝滑"流畅！本文全程保姆级教程，从痛点分析到代码实现，手把手教你构建企业级数据分析方案。废话不多说，咱们直接开搞！💪
一、背景痛点：为什么用户行为分析必须自动化？
先来场"灵魂拷问"：手动分析用户消费行为到底有多反人类？
-
数据源分散碎片化：用户数据分散在视频号后台、支付系统、CRM系统等多个平台，手动整合就像玩拼图
-
处理效率极其低下：从数据收集、清洗到分析，一个完整的行为分析报表需要4-6小时，时效性差
-
分析维度受限：手动分析只能关注基础指标，难以进行复杂的用户分群、行为路径分析
-
人为错误频发：数据复制粘贴容易出错，公式设置错误导致结论失真
-
洞察发现滞后：等报表做出来，市场机会可能已经消失，分析成了"马后炮"
据统计，一个中等规模的视频号店铺，每月在用户行为分析上要投入80-120小时！这相当于半个数据分析师的成本完全消耗在了机械性数据处理上。正因如此，RPA自动化成了最佳解决方案。影刀RPA能够自动收集多源数据、智能清洗整合、深度分析挖掘，让数据真正成为决策的"指南针"！
二、解决方案：影刀RPA智能分析架构设计
我们的目标是构建一个全自动、多维度、可预测的用户行为分析系统，整体架构基于影刀RPA的核心能力，结合数据分析算法。先来看整体方案：
系统架构图
多源数据采集 → 数据清洗整合 → 行为分析引擎 → 可视化报表 → 智能洞察
-
自动化数据采集：从视频号后台、支付系统、用户数据库自动提取原始数据
-
智能数据清洗：自动处理缺失值、异常值，标准化数据格式
-
多维行为分析：从时间、商品、用户等多个维度深度分析消费行为
-
自动化报表生成：自动生成可视化报表，支持实时更新
-
智能洞察发现：基于分析结果自动发现业务洞察和建议
方案核心优势
-
分析效率提升10倍：从手动4-6小时压缩到自动20-30分钟
-
分析维度全面：支持用户画像、购买路径、复购分析等多个维度
-
实时数据更新：支持定时自动运行，确保数据时效性
-
预测分析能力：基于历史数据预测未来趋势，指导业务决策
-
零技术门槛：业务人员也能通过预设模板获得深度分析
三、代码实现：手把手构建用户行为分析机器人
下面进入最硬核的部分——代码实现。我会用影刀RPA的设计器配合Python脚本，详细展示每个步骤。放心，代码都有详细注释，小白也能轻松上手！
步骤1：多源数据自动化采集
首先构建数据采集模块，从各个平台自动提取用户行为数据。
# 影刀RPA Python脚本：多源数据自动化采集
from yda import web, excel, database
import time
import datetime
import pandas as pd
import os
class DataCollector:
def __init__(self):
self.collected_data = {}
def collect_video_channel_data(self):
"""从视频号后台收集用户行为数据"""
try:
print("开始收集视频号用户行为数据...")
# 登录视频号后台
self.login_video_channel()
# 收集用户基础数据
user_data = self.extract_user_data()
# 收集购买行为数据
purchase_data = self.extract_purchase_data()
# 收集浏览行为数据
browse_data = self.extract_browse_data()
self.collected_data['video_channel'] = {
'user_data': user_data,
'purchase_data': purchase_data,
'browse_data': browse_data
}
print(f"视频号数据收集完成: 用户{len(user_data)}条, 购买{len(purchase_data)}条, 浏览{len(browse_data)}条")
return True
except Exception as e:
print(f"视频号数据收集失败: {str(e)}")
return False
def login_video_channel(self):
"""登录视频号后台"""
try:
web.open_browser("https://channels.weixin.qq.com/shop/analysis")
web.wait(5)
# 检查登录状态，如果未登录则执行登录
if not web.is_element_present("class=user-center"):
username = os.getenv("VIDEO_USERNAME")
password = os.getenv("VIDEO_PASSWORD")
web.input_text("id=username", username)
web.input_text("id=password", password)
web.click("id=login-btn")
web.wait_for_element("class=analysis-dashboard", timeout=15)
print("视频号后台登录成功")
return True
except Exception as e:
print(f"视频号登录失败: {str(e)}")
return False
def extract_user_data(self):
"""提取用户基础数据"""
try:
# 导航到用户分析页面
web.click("class=user-analysis-tab")
web.wait(3)
# 设置时间范围（最近30天）
web.click("class=date-picker")
web.wait(1)
web.click("xpath=//div[text()='最近30天']")
web.wait(2)
# 提取用户数据表格
user_table = web.get_table_data("class=user-data-table")
# 转换数据格式
user_data = []
for row in user_table:
if len(row) >= 5: # 确保有足够的数据列
user_data.append({
'user_id': row[0],
'register_time': row[1],
'first_purchase_time': row[2],
'total_orders': int(row[3]),
'total_amount': float(row[4].replace('¥', '').replace(',', ''))
})
return user_data
except Exception as e:
print(f"提取用户数据失败: {str(e)}")
return []
def extract_purchase_data(self):
"""提取购买行为数据"""
try:
# 导航到交易分析页面
web.click("class=transaction-tab")
web.wait(3)
# 提取订单详情数据
purchase_data = []
page_count = 0
while page_count < 10: # 限制翻页次数，避免无限循环
order_table = web.get_table_data("class=order-table")
for row in order_table:
if len(row) >= 8:
purchase_data.append({
'order_id': row[0],
'user_id': row[1],
'product_id': row[2],
'product_name': row[3],
'purchase_time': row[4],
'amount': float(row[5].replace('¥', '').replace(',', '')),
'quantity': int(row[6]),
'payment_method': row[7]
})
# 检查是否有下一页
if web.is_element_present("class=next-page") and not web.get_attribute("class=next-page", "disabled"):
web.click("class=next-page")
web.wait(2)
page_count += 1
else:
break
return purchase_data
except Exception as e:
print(f"提取购买数据失败: {str(e)}")
return []
def extract_browse_data(self):
"""提取浏览行为数据"""
try:
# 导航到行为分析页面
web.click("class=behavior-analysis-tab")
web.wait(3)
# 提取浏览数据
browse_data = []
browse_table = web.get_table_data("class=browse-table")
for row in browse_table:
if len(row) >= 6:
browse_data.append({
'user_id': row[0],
'product_id': row[1],
'browse_time': row[2],
'duration_seconds': int(row[3]),
'page_url': row[4],
'device_type': row[5]
})
return browse_data
except Exception as e:
print(f"提取浏览数据失败: {str(e)}")
return []
def collect_payment_data(self):
"""从支付系统收集支付数据"""
try:
print("开始收集支付系统数据...")
# 这里可以集成微信支付、支付宝等支付平台的API
# 为了示例，我们使用模拟数据
payment_data = [
{
'payment_id': 'PY001',
'order_id': 'ORD001',
'user_id': 'USER001',
'payment_time': '2024-01-15 10:30:00',
'payment_amount': 299.00,
'payment_channel': 'wechat'
}
# 更多支付数据...
]
self.collected_data['payment'] = payment_data
print(f"支付数据收集完成: {len(payment_data)}条")
return True
except Exception as e:
print(f"支付数据收集失败: {str(e)}")
return False
def integrate_all_data(self):
"""整合所有数据源"""
try:
# 创建主数据框架
integrated_df = pd.DataFrame()
# 整合视频号数据
if 'video_channel' in self.collected_data:
video_data = self.collected_data['video_channel']
# 用户数据
user_df = pd.DataFrame(video_data['user_data'])
# 购买数据
purchase_df = pd.DataFrame(video_data['purchase_data'])
# 浏览数据
browse_df = pd.DataFrame(video_data['browse_data'])
# 数据合并逻辑
integrated_df = self.merge_data_sources(user_df, purchase_df, browse_df)
# 整合支付数据
if 'payment' in self.collected_data:
payment_df = pd.DataFrame(self.collected_data['payment'])
if not integrated_df.empty:
integrated_df = pd.merge(integrated_df, payment_df, on=['user_id', 'order_id'], how='left')
print(f"数据整合完成，总记录数: {len(integrated_df)}")
return integrated_df
except Exception as e:
print(f"数据整合失败: {str(e)}")
return pd.DataFrame()
def merge_data_sources(self, user_df, purchase_df, browse_df):
"""合并不同数据源"""
# 基于用户ID合并用户数据和购买数据
merged_df = pd.merge(user_df, purchase_df, on='user_id', how='left')
# 添加浏览行为数据（按用户和商品分组聚合）
browse_agg = browse_df.groupby(['user_id', 'product_id']).agg({
'duration_seconds': 'sum',
'browse_time': 'count'
}).reset_index()
browse_agg.columns = ['user_id', 'product_id', 'total_browse_seconds', 'browse_count']
merged_df = pd.merge(merged_df, browse_agg, on=['user_id', 'product_id'], how='left')
return merged_df
# 初始化数据收集器
collector = DataCollector()
技术要点：数据采集需要考虑各平台的API限制和反爬机制，合理设置请求频率。
步骤2：数据清洗与预处理引擎
构建数据清洗模块，确保数据质量。
# 数据清洗与预处理引擎
import numpy as np
from datetime import datetime, timedelta
class DataCleaner:
def __init__(self):
self.cleaning_rules = self.load_cleaning_rules()
def load_cleaning_rules(self):
"""加载数据清洗规则"""
rules = {
'user_data': {
'required_fields': ['user_id', 'register_time'],
'default_values': {
'total_orders': 0,
'total_amount': 0.0
}
},
'purchase_data': {
'required_fields': ['order_id', 'user_id', 'purchase_time', 'amount'],
'amount_range': (0.01, 100000.0), # 合理的金额范围
'date_range': (datetime.now() - timedelta(days=365), datetime.now())
}
}
return rules
def clean_integrated_data(self, raw_df):
"""清洗整合后的数据"""
try:
print("开始数据清洗...")
# 创建数据副本
cleaned_df = raw_df.copy()
# 处理缺失值
cleaned_df = self.handle_missing_values(cleaned_df)
# 处理异常值
cleaned_df = self.handle_outliers(cleaned_df)
# 数据格式标准化
cleaned_df = self.standardize_formats(cleaned_df)
# 数据去重
cleaned_df = self.remove_duplicates(cleaned_df)
# 特征工程
cleaned_df = self.feature_engineering(cleaned_df)
print(f"数据清洗完成，原始数据{len(raw_df)}条，清洗后{len(cleaned_df)}条")
return cleaned_df
except Exception as e:
print(f"数据清洗失败: {str(e)}")
return raw_df
def handle_missing_values(self, df):
"""处理缺失值"""
# 数值型字段用中位数填充
numeric_columns = ['total_orders', 'total_amount', 'amount', 'quantity', 'total_browse_seconds', 'browse_count']
for col in numeric_columns:
if col in df.columns:
df[col] = df[col].fillna(df[col].median())
# 分类型字段用众数填充
categorical_columns = ['payment_method', 'device_type', 'payment_channel']
for col in categorical_columns:
if col in df.columns and not df[col].isnull().all():
mode_value = df[col].mode()[0] if not df[col].mode().empty else '未知'
df[col] = df[col].fillna(mode_value)
# 时间字段用前后值填充
time_columns = ['register_time', 'first_purchase_time', 'purchase_time', 'browse_time']
for col in time_columns:
if col in df.columns:
df[col] = pd.to_datetime(df[col], errors='coerce')
df[col] = df[col].fillna(method='ffill').fillna(method='bfill')
return df
def handle_outliers(self, df):
"""处理异常值"""
try:
# 金额异常值处理（使用IQR方法）
if 'amount' in df.columns:
Q1 = df['amount'].quantile(0.25)
Q3 = df['amount'].quantile(0.75)
IQR = Q3 - Q1
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
# 将异常值缩放到边界值
df['amount'] = np.where(df['amount'] < lower_bound, lower_bound, df['amount'])
df['amount'] = np.where(df['amount'] > upper_bound, upper_bound, df['amount'])
# 浏览时长异常值处理
if 'total_browse_seconds' in df.columns:
# 假设单次浏览超过2小时为异常（可能是挂机）
df['total_browse_seconds'] = np.where(
df['total_browse_seconds'] > 7200, 7200, df['total_browse_seconds']
)
return df
except Exception as e:
print(f"异常值处理失败: {str(e)}")
return df
def standardize_formats(self, df):
"""数据格式标准化"""
try:
# 时间格式标准化
time_columns = ['register_time', 'first_purchase_time', 'purchase_time', 'browse_time']
for col in time_columns:
if col in df.columns:
df[col] = pd.to_datetime(df[col], errors='coerce')
# 金额格式标准化（确保都是数值型）
amount_columns = ['total_amount', 'amount', 'payment_amount']
for col in amount_columns:
if col in df.columns:
df[col] = pd.to_numeric(df[col], errors='coerce')
df[col] = df[col].fillna(0)
# 文本字段去除前后空格
text_columns = ['user_id', 'product_name', 'payment_method', 'device_type']
for col in text_columns:
if col in df.columns:
df[col] = df[col].astype(str).str.strip()
return df
except Exception as e:
print(f"格式标准化失败: {str(e)}")
return df
def remove_duplicates(self, df):
"""数据去重"""
# 基于订单ID去重（假设订单ID唯一）
if 'order_id' in df.columns:
df = df.drop_duplicates(subset=['order_id'], keep='first')
return df
def feature_engineering(self, df):
"""特征工程"""
try:
# 计算用户价值等级
if 'total_amount' in df.columns:
conditions = [
df['total_amount'] < 100,
(df['total_amount'] >= 100) & (df['total_amount'] < 500),
df['total_amount'] >= 500
]
choices = ['低价值', '中价值', '高价值']
df['user_value_level'] = np.select(conditions, choices, default='未知')
# 计算购买时间段（早、中、晚）
if 'purchase_time' in df.columns:
df['purchase_hour'] = df['purchase_time'].dt.hour
conditions = [
df['purchase_hour'] < 12,
(df['purchase_hour'] >= 12) & (df['purchase_hour'] < 18),
df['purchase_hour'] >= 18
]
choices = ['上午', '下午', '晚上']
df['purchase_period'] = np.select(conditions, choices, default='未知')
# 计算用户活跃度（基于浏览行为）
if 'browse_count' in df.columns:
df['user_activity'] = np.where(
df['browse_count'] > df['browse_count'].median(), '高活跃', '低活跃'
)
# 计算复购标志
if 'total_orders' in df.columns:
df['is_repeat_customer'] = df['total_orders'] > 1
print("特征工程完成")
return df
except Exception as e:
print(f"特征工程失败: {str(e)}")
return df
# 初始化数据清洗器
cleaner = DataCleaner()
数据质量：数据清洗是分析准确性的基础，需要根据业务逻辑制定合理的清洗规则。
步骤3：用户行为深度分析引擎
构建核心分析模块，挖掘用户行为洞察。
# 用户行为深度分析引擎
import matplotlib.pyplot as plt
import seaborn as sns
from collections import Counter
class BehaviorAnalyzer:
def __init__(self):
self.analysis_results = {}
def comprehensive_analysis(self, cleaned_df):
"""执行全面的用户行为分析"""
try:
print("开始用户行为深度分析...")
# 用户基础分析
self.user_base_analysis(cleaned_df)
# 购买行为分析
self.purchase_behavior_analysis(cleaned_df)
# 浏览行为分析
self.browse_behavior_analysis(cleaned_df)
# 用户分群分析
self.user_segmentation_analysis(cleaned_df)
# 关联分析
self.association_analysis(cleaned_df)
print("用户行为分析完成")
return self.analysis_results
except Exception as e:
print(f"行为分析失败: {str(e)}")
return {}
def user_base_analysis(self, df):
"""用户基础分析"""
try:
user_analysis = {}
# 用户增长趋势
if 'register_time' in df.columns:
df['register_date'] = df['register_time'].dt.date
daily_registers = df.groupby('register_date')['user_id'].nunique()
user_analysis['daily_registers'] = daily_registers.tail(30) # 最近30天
# 用户价值分布
if 'user_value_level' in df.columns:
value_distribution = df['user_value_level'].value_counts()
user_analysis['value_distribution'] = value_distribution
# 用户地域分布（如果有地域数据）
# 这里可以扩展地域分析逻辑
self.analysis_results['user_base'] = user_analysis
print("用户基础分析完成")
except Exception as e:
print(f"用户基础分析失败: {str(e)}")
def purchase_behavior_analysis(self, df):
"""购买行为分析"""
try:
purchase_analysis = {}
# 销售趋势分析
if 'purchase_time' in df.columns and 'amount' in df.columns:
df['purchase_date'] = df['purchase_time'].dt.date
daily_sales = df.groupby('purchase_date').agg({
'amount': 'sum',
'order_id': 'count'
}).rename(columns={'order_id': 'order_count'})
purchase_analysis['daily_sales'] = daily_sales.tail(30)
# 客单价分析
if 'amount' in df.columns:
avg_order_value = df['amount'].mean()
purchase_analysis['avg_order_value'] = avg_order_value
# 客单价分布
order_value_bins = [0, 50, 100, 200, 500, float('inf')]
order_value_labels = ['0-50', '50-100', '100-200', '200-500', '500+']
df['order_value_range'] = pd.cut(df['amount'], bins=order_value_bins, labels=order_value_labels)
purchase_analysis['order_value_distribution'] = df['order_value_range'].value_counts()
# 复购率分析
if 'is_repeat_customer' in df.columns:
repeat_rate = df['is_repeat_customer'].mean()
purchase_analysis['repeat_purchase_rate'] = repeat_rate
# 热门商品分析
if 'product_name' in df.columns:
top_products = df['product_name'].value_counts().head(10)
purchase_analysis['top_products'] = top_products
self.analysis_results['purchase_behavior'] = purchase_analysis
print("购买行为分析完成")
except Exception as e:
print(f"购买行为分析失败: {str(e)}")
def browse_behavior_analysis(self, df):
"""浏览行为分析"""
try:
browse_analysis = {}
# 浏览时长分析
if 'total_browse_seconds' in df.columns:
avg_browse_time = df['total_browse_seconds'].mean()
browse_analysis['avg_browse_seconds'] = avg_browse_time
# 浏览时长分布
browse_time_bins = [0, 30, 60, 180, 600, float('inf')]
browse_time_labels = ['0-30s', '30-60s', '1-3m', '3-10m', '10m+']
df['browse_time_range'] = pd.cut(df['total_browse_seconds'], bins=browse_time_bins, labels=browse_time_labels)
browse_analysis['browse_time_distribution'] = df['browse_time_range'].value_counts()
# 浏览次数分析
if 'browse_count' in df.columns:
avg_browse_count = df['browse_count'].mean()
browse_analysis['avg_browse_count'] = avg_browse_count
# 浏览-购买转化分析
if 'browse_count' in df.columns and 'total_orders' in df.columns:
# 简单的浏览到购买转化率
conversion_data = df.groupby('user_id').agg({
'browse_count': 'sum',
'total_orders': 'max'
})
conversion_data['has_purchased'] = conversion_data['total_orders'] > 0
browse_to_purchase_rate = conversion_data['has_purchased'].mean()
browse_analysis['browse_to_purchase_rate'] = browse_to_purchase_rate
self.analysis_results['browse_behavior'] = browse_analysis
print("浏览行为分析完成")
except Exception as e:
print(f"浏览行为分析失败: {str(e)}")
def user_segmentation_analysis(self, df):
"""用户分群分析"""
try:
segmentation = {}
# RFM分群（简化版）
if all(col in df.columns for col in ['purchase_time', 'total_orders', 'total_amount']):
# 计算RFM值
current_date = datetime.now()
# Recency: 最近购买时间
recency_data = df.groupby('user_id')['purchase_time'].max()
recency_days = (current_date - recency_data).dt.days
# Frequency: 购买频率
frequency_data = df.groupby('user_id')['order_id'].nunique()
# Monetary: 购买金额
monetary_data = df.groupby('user_id')['amount'].sum()
# RFM分群
rfm_df = pd.DataFrame({
'Recency': recency_days,
'Frequency': frequency_data,
'Monetary': monetary_data
})
# RFM打分（这里使用简单分位数分组）
rfm_df['R_Score'] = pd.qcut(rfm_df['Recency'], q=3, labels=[3, 2, 1])
rfm_df['F_Score'] = pd.qcut(rfm_df['Frequency'], q=3, labels=[1, 2, 3])
rfm_df['M_Score'] = pd.qcut(rfm_df['Monetary'], q=3, labels=[1, 2, 3])
# RFM总分
rfm_df['RFM_Score'] = rfm_df['R_Score'].astype(int) + rfm_df['F_Score'].astype(int) + rfm_df['M_Score'].astype(int)
# 用户分群
conditions = [
rfm_df['RFM_Score'] >= 8,
(rfm_df['RFM_Score'] >= 5) & (rfm_df['RFM_Score'] < 8),
rfm_df['RFM_Score'] < 5
]
choices = ['高价值用户', '中价值用户', '低价值用户']
rfm_df['User_Segment'] = np.select(conditions, choices, default='未知')
segmentation['rfm_analysis'] = rfm_df
segmentation['segment_distribution'] = rfm_df['User_Segment'].value_counts()
self.analysis_results['user_segmentation'] = segmentation
print("用户分群分析完成")
except Exception as e:
print(f"用户分群分析失败: {str(e)}")
def association_analysis(self, df):
"""关联分析"""
try:
association = {}
# 商品关联分析（哪些商品经常一起购买）
if all(col in df.columns for col in ['order_id', 'product_name']):
# 按订单分组商品
order_products = df.groupby('order_id')['product_name'].apply(list)
# 简单的关联规则（商品共现）
product_pairs = []
for products in order_products:
if len(products) >= 2:
for i in range(len(products)):
for j in range(i+1, len(products)):
product_pairs.append(tuple(sorted([products[i], products[j]])))
# 统计商品对出现次数
pair_counts = Counter(product_pairs)
top_pairs = pair_counts.most_common(10)
association['product_associations'] = top_pairs
# 时间关联分析（购买时间段偏好）
if 'purchase_period' in df.columns and 'user_value_level' in df.columns:
period_preference = pd.crosstab(df['purchase_period'], df['user_value_level'])
association['time_preference'] = period_preference
self.analysis_results['association'] = association
print("关联分析完成")
except Exception as e:
print(f"关联分析失败: {str(e)}")
# 初始化分析器
analyzer = BehaviorAnalyzer()
分析深度：这个分析框架支持从基础统计到复杂机器学习的多个层次分析。
步骤4：自动化报表生成与洞察发现
构建报表自动生成和智能洞察系统。
# 自动化报表生成与洞察发现
class ReportGenerator:
def __init__(self):
self.report_data = {}
def generate_comprehensive_report(self, analysis_results, output_path="用户行为分析报告.xlsx"):
"""生成综合用户行为分析报告"""
try:
print("开始生成分析报告...")
# 创建Excel工作簿
excel.create_workbook(output_path)
# 生成各维度分析报表
self.generate_summary_sheet(analysis_results)
self.generate_user_analysis_sheet(analysis_results)
self.generate_purchase_analysis_sheet(analysis_results)
self.generate_segmentation_sheet(analysis_results)
# 生成可视化图表
self.generate_charts(analysis_results)
# 生成业务洞察
self.generate_insights(analysis_results)
excel.save_workbook(output_path)
print(f"分析报告生成完成: {output_path}")
return True
except Exception as e:
print(f"报告生成失败: {str(e)}")
return False
def generate_summary_sheet(self, analysis_results):
"""生成摘要报表"""
try:
excel.create_sheet("数据摘要")
summary_data = []
# 用户基础数据摘要
if 'user_base' in analysis_results:
user_data = analysis_results['user_base']
if 'value_distribution' in user_data:
total_users = user_data['value_distribution'].sum()
summary_data.append(['总用户数', total_users])
# 购买行为数据摘要
if 'purchase_behavior' in analysis_results:
purchase_data = analysis_results['purchase_behavior']
if 'avg_order_value' in purchase_data:
summary_data.append(['平均客单价', f"¥{purchase_data['avg_order_value']:.2f}"])
if 'repeat_purchase_rate' in purchase_data:
summary_data.append(['复购率', f"{purchase_data['repeat_purchase_rate']*100:.1f}%"])
# 浏览行为数据摘要
if 'browse_behavior' in analysis_results:
browse_data = analysis_results['browse_behavior']
if 'avg_browse_seconds' in browse_data:
summary_data.append(['平均浏览时长', f"{browse_data['avg_browse_seconds']:.1f}秒"])
if 'browse_to_purchase_rate' in browse_data:
summary_data.append(['浏览购买转化率', f"{browse_data['browse_to_purchase_rate']*100:.1f}%"])
# 写入摘要数据
if summary_data:
excel.write_range("A1:B{}".format(len(summary_data)), summary_data)
excel.set_column_width("A:B", 20)
except Exception as e:
print(f"生成摘要报表失败: {str(e)}")
def generate_user_analysis_sheet(self, analysis_results):
"""生成用户分析报表"""
try:
excel.create_sheet("用户分析")
row_index = 1
# 用户价值分布
if 'user_base' in analysis_results and 'value_distribution' in analysis_results['user_base']:
value_data = analysis_results['user_base']['value_distribution']
excel.write_cell(f"A{row_index}", "用户价值分布")
row_index += 1
value_rows = [['价值等级', '用户数量']]
for level, count in value_data.items():
value_rows.append([level, count])
excel.write_range(f"A{row_index}:B{row_index+len(value_rows)-1}", value_rows)
row_index += len(value_rows) + 2
# 用户增长趋势
if 'user_base' in analysis_results and 'daily_registers' in analysis_results['user_base']:
growth_data = analysis_results['user_base']['daily_registers']
excel.write_cell(f"A{row_index}", "每日新增用户")
row_index += 1
growth_rows = [['日期', '新增用户']]
for date, count in growth_data.items():
growth_rows.append([date.strftime("%Y-%m-%d"), count])
excel.write_range(f"A{row_index}:B{row_index+len(growth_rows)-1}", growth_rows)
except Exception as e:
print(f"生成用户分析报表失败: {str(e)}")
def generate_purchase_analysis_sheet(self, analysis_results):
"""生成购买分析报表"""
try:
excel.create_sheet("购买分析")
row_index = 1
# 销售趋势
if 'purchase_behavior' in analysis_results and 'daily_sales' in analysis_results['purchase_behavior']:
sales_data = analysis_results['purchase_behavior']['daily_sales']
excel.write_cell(f"A{row_index}", "每日销售趋势")
row_index += 1
sales_rows = [['日期', '销售额', '订单数']]
for date, row in sales_data.iterrows():
sales_rows.append([date.strftime("%Y-%m-%d"), row['amount'], row['order_count']])
excel.write_range(f"A{row_index}:C{row_index+len(sales_rows)-1}", sales_rows)
row_index += len(sales_rows) + 2
# 热门商品
if 'purchase_behavior' in analysis_results and 'top_products' in analysis_results['purchase_behavior']:
top_products = analysis_results['purchase_behavior']['top_products']
excel.write_cell(f"A{row_index}", "热门商品TOP10")
row_index += 1
product_rows = [['商品名称', '购买次数']]
for product, count in top_products.items():
product_rows.append([product, count])
excel.write_range(f"A{row_index}:B{row_index+len(product_rows)-1}", product_rows)
except Exception as e:
print(f"生成购买分析报表失败: {str(e)}")
def generate_segmentation_sheet(self, analysis_results):
"""生成用户分群报表"""
try:
扫一扫
2911
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
