Jelly-ha

python数据分析[CDNow网站用户消费行为]

数据来源于CDNow网站，是用户在一家CD网站的消费记录。

数据集包含的字段

user_id:用户ID
order_dt:购买日期
order_products：购买产品数
order_amount：购买金额

导入相关库，加载数据

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime
%matplotlib inline

columns = ['user_id','order_dt','order_products','order_amount']

df=pd.read_table('CDNOW_master.txt',names=columns,sep='\s+')

1. 探索性分析

df.head()

	user_id	order_dt	order_products	order_amount
0	1	19970101	1	11.77
1	2	19970112	1	12.00
2	2	19970112	5	77.00
3	3	19970102	2	20.76
4	3	19970330	2	20.76

df.info()


RangeIndex: 69659 entries, 0 to 69658
Data columns (total 4 columns):
user_id           69659 non-null int64
order_dt          69659 non-null int64
order_products    69659 non-null int64
order_amount      69659 non-null float64
dtypes: float64(1), int64(3)
memory usage: 2.1 MB

可以看到order_dt字段中数据类型是int,需要将其转化为日期类型,利用datetime模块中的to_datetime方法将其转换

df['order_dt']=pd.to_datetime(df.order_dt,format='%Y%m%d')
df['order_dt']

0       1997-01-01
1       1997-01-12
2       1997-01-12
3       1997-01-02
4       1997-03-30
           ...    
69654   1997-04-05
69655   1997-04-22
69656   1997-03-25
69657   1997-03-25
69658   1997-03-26
Name: order_dt, Length: 69659, dtype: datetime64[ns]

现在打算把上述日期中的月份提取出来，对用户行为按月进行分析

df.order_dt.values  # 现将df.order_dt.values 转化为数组，然后再利用 数组的astype函数进行转换，否则会发生错误

array(['1997-01-01T00:00:00.000000000', '1997-01-12T00:00:00.000000000',
       '1997-01-12T00:00:00.000000000', ...,
       '1997-03-25T00:00:00.000000000', '1997-03-25T00:00:00.000000000',
       '1997-03-26T00:00:00.000000000'], dtype='datetime64[ns]')

df['month']=df.order_dt.values.astype('datetime64[M]')
df['month']

0       1997-01-01
1       1997-01-01
2       1997-01-01
3       1997-01-01
4       1997-03-01
           ...    
69654   1997-04-01
69655   1997-04-01
69656   1997-03-01
69657   1997-03-01
69658   1997-03-01
Name: month, Length: 69659, dtype: datetime64[ns]

df.head()

	user_id	order_dt	order_products	order_amount	month
0	1	1997-01-01	1	11.77	1997-01-01
1	2	1997-01-12	1	12.00	1997-01-01
2	2	1997-01-12	5	77.00	1997-01-01
3	3	1997-01-02	2	20.76	1997-01-01
4	3	1997-03-30	2	20.76	1997-03-01

2.进行用户消费趋势的分析（按月）

每月的消费总金额
每月的消费次数
每月的产品购买量
每月的消费人数

2.1 每月的消费总金额

grouped_month = df.groupby('month') # 将用户按月进行分组
order_month_amount = grouped_month.order_amount.sum() # 计算每位用户购买CD所花费的总金额

order_month_amount.head()

month
1997-01-01    299060.17
1997-02-01    379590.03
1997-03-01    393155.27
1997-04-01    142824.49
1997-05-01    107933.30
Name: order_amount, dtype: float64

print( plt.style.available)  # matplotlib的绘图风格有多种

['bmh', 'classic', 'dark_background', 'fast', 'fivethirtyeight', 'ggplot', 'grayscale', 'seaborn-bright', 'seaborn-colorblind', 'seaborn-dark-palette', 'seaborn-dark', 'seaborn-darkgrid', 'seaborn-deep', 'seaborn-muted', 'seaborn-notebook', 'seaborn-paper', 'seaborn-pastel', 'seaborn-poster', 'seaborn-talk', 'seaborn-ticks', 'seaborn-white', 'seaborn-whitegrid', 'seaborn', 'Solarize_Light2', 'tableau-colorblind10', '_classic_test']

plt.style.use("ggplot")
order_month_amount.plot()

由上图可知，消费金额在前三个月达到最高峰，后续消费金额较为稳定，略有下降

2.2 每月消费次数

grouped_month.user_id.count().plot()

前三个月的消费订单数在10000笔左右，后续消费订单在2500左右

2.3 每月消费人数

对每月重复消费用户的记录用drop_duplicates进行去重，然后用len函数对去重后的对每月用户数进行统计

df.groupby('month').user_id.apply(lambda x:len(x.drop_duplicates())).plot()  # 每月去重的个数

可以看出每月消费人数低于每月消费次数
前三个月每个月的消费人数在8000—10000左右，后续月份，平均消费人数不到2000

3.用户个体消费分析

用户消费金额，消费次数的描述统计
用户消费金额和购买产品数的散点图
用户消费金额的分布图
用户累计消费金额占比（百分之多少的用户占了百分之多少的消费额）

3.1 用户消费金额，消费次数的描述统计

grouped_user = df.groupby('user_id') # 按照用户ID对消费情况进行分组

grouped_user.sum().describe()

	order_products	order_amount
count	23570.000000	23570.000000
mean	7.122656	106.080426
std	16.983531	240.925195
min	1.000000	0.000000
25%	1.000000	19.970000
50%	3.000000	43.395000
75%	7.000000	106.475000
max	1033.000000	13990.930000

用户平均购买了7张CD,但是中位数只有3，说明小部分用户购买了大量的CD
用户平均消费106元，中位数只有43，判断同上，说明有极值干扰

3.2用户消费金额和购买产品数的散点图

grouped_user.sum().plot.scatter(x='order_amount',y='order_products')

发现有异常值点，需要将其过滤掉

grouped_user.sum().query('order_amount<4000').plot.scatter(x='order_amount',y='order_products')

在排除异常值点后，发现用户购买产品数和购买金额成正比

3.3 用户消费金额的分布图

grouped_user.sum().order_amount #各用户消费总金额

user_id
1         11.77
2         89.00
3        156.46
4        100.50
5        385.61
          ...  
23566     36.00
23567     20.97
23568    121.70
23569     25.74
23570     94.08
Name: order_amount, Length: 23570, dtype: float64

grouped_user.sum().order_amount.plot.hist(bins=20)

横轴表示消费金额，纵轴表示消费相应金额的用户数
从直方图可知，用户消费金额，绝大部分呈集中趋势，小部分异常值干扰了判断。可以使用过滤操作排除异常

grouped_user.sum().query('order_products<100').order_products#.plot.hist(bins=20)

user_id
1         1
2         6
3        16
4         7
5        29
         ..
23566     2
23567     1
23568     6
23569     2
23570     5
Name: order_products, Length: 23491, dtype: int64

grouped_user.sum().query('order_products<100').order_products.plot.hist(bins=20)

使用切比雪夫定理过滤掉异常值，计算94%的购买产品数的数据分布情况，可以看出消费者的消费能力不是很高。

4.用户消费行为

用户第一次消费（首购）
用户最后一次消费
新老客户消费比
- 多少用户仅消费了一次？

4.1 用户第一次消费

grouped_user.min().order_dt # 用户的最早消费日期

user_id
1       1997-01-01
2       1997-01-12
3       1997-01-02
4       1997-01-01
5       1997-01-01
           ...    
23566   1997-03-25
23567   1997-03-25
23568   1997-03-25
23569   1997-03-25
23570   1997-03-25
Name: order_dt, Length: 23570, dtype: datetime64[ns]

grouped_user.min().order_dt.value_counts().plot()

用户第一次购买分布，集中在前三个月
其中在2月11日到2月15日有较大的波动

4.2 用户最后一次消费

grouped_user.max().order_dt.value_counts().plot()

用户最后一次购买的分布比第一次分布广
大部分购买，集中在前三个月，说明有很多用户购买了一次用户后就不再进行购买
随着时间的递增，最后一次购买数也在递增，消费总体呈现流失上升的状况

5.复购率和回购率分析

复购率
- 自然月内，购买多次的用户比一段时间内，购买2次及以上客户人数，占该时间段内购买过的总人数的比重
回购率 (当月消费过，在次月仍然消费）
- 在一定时间段内，购买的过的客户在下一个时间段内还会购买的比例。例如：1月消费用户1000个，他们中有300个2月依然消费，回购率是30%。与复购率的区别是两个时间窗口，而复购率是一个时间窗口的多次购买行为。

5.1 复购率

pivoted_counts = df.pivot_table(index='user_id',columns = 'month',values= 'order_products',aggfunc='count').fillna(0)
pivoted_counts.head()# 用户每月购买产品数

month	1997-01-01	1997-02-01	1997-03-01	1997-04-01	1997-05-01	1997-06-01	1997-07-01	1997-08-01	1997-09-01	1997-10-01	1997-11-01	1997-12-01	1998-01-01	1998-02-01	1998-03-01	1998-04-01	1998-05-01	1998-06-01
user_id
1	1.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
2	2.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
3	1.0	0.0	1.0	1.0	0.0	0.0	0.0	0.0	0.0	0.0	2.0	0.0	0.0	0.0	0.0	0.0	1.0	0.0
4	2.0	0.0	0.0	0.0	0.0	0.0	0.0	1.0	0.0	0.0	0.0	1.0	0.0	0.0	0.0	0.0	0.0	0.0
5	2.0	1.0	0.0	1.0	1.0	1.0	1.0	0.0	1.0	0.0	0.0	2.0	1.0	0.0	0.0	0.0	0.0	0.0

下面将购买一件以上的产品数统一用1表示，仅消费一件产品的产品数统一用0表示，没有消费产品数的用np.NaN代替

purchase_r = pivoted_counts.applymap(lambda x: 1 if x>1 else np.NaN if x==0 else 0) #else后面为一个整体 即另一个完整的循环
purchase_r.head()

month	1997-01-01	1997-02-01	1997-03-01	1997-04-01	1997-05-01	1997-06-01	1997-07-01	1997-08-01	1997-09-01	1997-10-01	1997-11-01	1997-12-01	1998-01-01	1998-02-01	1998-03-01	1998-04-01	1998-05-01	1998-06-01
user_id
1	0.0	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
2	1.0	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
3	0.0	NaN	0.0	0.0	NaN	NaN	NaN	NaN	NaN	NaN	1.0	NaN	NaN	NaN	NaN	NaN	0.0	NaN
4	1.0	NaN	NaN	NaN	NaN	NaN	NaN	0.0	NaN	NaN	NaN	0.0	NaN	NaN	NaN	NaN	NaN	NaN
5	1.0	0.0	NaN	0.0	0.0	0.0	0.0	NaN	0.0	NaN	NaN	1.0	0.0	NaN	NaN	NaN	NaN	NaN

(purchase_r.sum()/purchase_r.count()).plot(figsize=(10,4)) # 复购率  注意count 0 和1 都会计算 但是又排除掉空值  而sum 只计算 1

复购率稳定在20%左右，前三个月因为有大量新用户涌入，而这批用户只购买了一次，所以导致复购率降低

5.2 回购率

现在将购买过产品数的相应值统一记为1，表示消费过，否则记为0

df_purchase = pivoted_counts.applymap(lambda x: 1 if x > 0 else 0) # applymap 指的是要对数据框中的每一个数据调用函数
df_purchase.head()

month	1997-01-01	1997-02-01	1997-03-01	1997-04-01	1997-05-01	1997-06-01	1997-07-01	1997-08-01	1997-09-01	1997-10-01	1997-11-01	1997-12-01	1998-01-01	1998-02-01	1998-03-01	1998-04-01	1998-05-01	1998-06-01
user_id
1	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
2	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
3	1	0	1	1	0	0	0	0	0	0	1	0	0	0	0	0	1	0
4	1	0	0	0	0	0	0	1	0	0	0	1	0	0	0	0	0	0
5	1	1	0	1	1	1	1	0	1	0	0	1	1	0	0	0	0	0

若当月消费，次月继续消费，则记为会回购，对上述消费情况进行处理

def purchase_back(data):
    status = []
    for i in range(17):
        if data[i] == 1:
            if data[i+1] == 1:
                status.append(1)
            if data[i+1] ==0:
                status.append(0)
        else:
            status.append(np.NaN)
    status.append(np.NaN) # 将最后一个月填充好，因为无法得知下月情况
    return pd.Series(status,index=data.index)           
purchase_b=df_purchase.apply(purchase_back,axis=1)
purchase_b.head()

month	1997-01-01	1997-02-01	1997-03-01	1997-04-01	1997-05-01	1997-06-01	1997-07-01	1997-08-01	1997-09-01	1997-10-01	1997-11-01	1997-12-01	1998-01-01	1998-02-01	1998-03-01	1998-04-01	1998-05-01	1998-06-01
user_id
1	0.0	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
2	0.0	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
3	0.0	NaN	1.0	0.0	NaN	NaN	NaN	NaN	NaN	NaN	0.0	NaN	NaN	NaN	NaN	NaN	0.0	NaN
4	0.0	NaN	NaN	NaN	NaN	NaN	NaN	0.0	NaN	NaN	NaN	0.0	NaN	NaN	NaN	NaN	NaN	NaN
5	1.0	0.0	NaN	1.0	1.0	1.0	0.0	NaN	0.0	NaN	NaN	1.0	0.0	NaN	NaN	NaN	NaN	NaN

(purchase_b.sum()/purchase_b.count()).plot(figsize=(10,4))

从图中可以看出回购率高于复购率，稳定在30%左右，而复购率稳定在20%左右。
说明老客整体上质量高于新客，即老客的忠诚度比较好。

6.用户分层

RFM（人工的使用象限法去把数据分成几个立方体，这写立方体都有相应的标签，这些标签可以直接把它应用到业务层面上，比如“重要发展客户”和“重要挽留客户”有一段时间没有消费了，那如何把他们拉回来）
新、活跃、回流、流失

6.1 利用RFM对用户分层

R：最近一次消费
F：消费频率（限定的时间内购买的次数）
M：消费金额

rfm = df.pivot_table(index='user_id',values=['order_amount','order_products','order_dt'],
                     aggfunc={
     'order_dt':'max','order_products':'sum','order_amount':'sum'})   # 不变的是用户id
rfm.head()

	order_amount	order_dt	order_products
user_id
1	11.77	1997-01-01	1
2	89.00	1997-01-12	6
3	156.46	1998-05-28	16
4	100.50	1997-12-12	7
5	385.61	1998-01-03	29

-(rfm.order_dt - rfm.order_dt.max()) # 计算距离今天最近一次消费间隔天数 ，这里采用用户最后一次消费时间作为“今天”

user_id
1       545 days
2       534 days
3        33 days
4       200 days
5       178 days
          ...   
23566   462 days
23567   462 days
23568   434 days
23569   462 days
23570   461 days
Name: order_dt, Length: 23570, dtype: timedelta64[ns]

rfm['R']=-(rfm.order_dt - rfm.order_dt.max())/np.timedelta64(1,'D') # 把days去掉
rfm['R']

user_id
1        545.0
2        534.0
3         33.0
4        200.0
5        178.0
         ...  
23566    462.0
23567    462.0
23568    434.0
23569    462.0
23570    461.0
Name: R, Length: 23570, dtype: float64

rfm.rename(columns={
     'order_products':'F','order_amount':'M'},inplace=True)

rfm

	M	order_dt	F	R
user_id
1	11.77	1997-01-01	1	545.0
2	89.00	1997-01-12	6	534.0
3	156.46	1998-05-28	16	33.0
4	100.50	1997-12-12	7	200.0
5	385.61	1998-01-03	29	178.0
...	...	...	...	...
23566	36.00	1997-03-25	2	462.0
23567	20.97	1997-03-25	1	462.0
23568	121.70	1997-04-22	6	434.0
23569	25.74	1997-03-25	2	462.0
23570	94.08	1997-03-26	5	461.0

23570 rows × 4 columns

def rfm_func(x):
    level = x.apply(lambda x: '1' if x>0 else '0')
    return level
level=rfm[['R','F','M']].apply(lambda x: x-x.mean()).apply(rfm_func)
str_label = level.R + level.F + level.M
d = {
     '111':'重要价值客户','011':'重要保持客户','101':'重要挽留客户',
     '001':'重要发展客户','110':'一般价值客户',
     '010':'一般保持客户','100':'一般挽留客户',
     '000':'一般发展客户'}
rfm['label']=str_label.map(d)
rfm

	M	order_dt	F	R	label
user_id
1	11.77	1997-01-01	1	545.0	一般挽留客户
2	89.00	1997-01-12	6	534.0	一般挽留客户
3	156.46	1998-05-28	16	33.0	重要保持客户
4	100.50	1997-12-12	7	200.0	一般发展客户
5	385.61	1998-01-03	29	178.0	重要保持客户
...	...	...	...	...	...
23566	36.00	1997-03-25	2	462.0	一般挽留客户
23567	20.97	1997-03-25	1	462.0	一般挽留客户
23568	121.70	1997-04-22	6	434.0	重要挽留客户
23569	25.74	1997-03-25	2	462.0	一般挽留客户
23570	94.08	1997-03-26	5	461.0	一般挽留客户

23570 rows × 5 columns

rfm.groupby('label').sum()

	M	F	R
label
一般价值客户	7181.28	650	36295.0
一般保持客户	19937.45	1712	29448.0
一般发展客户	196971.23	13977	591108.0
一般挽留客户	438291.81	29346	6951815.0
重要价值客户	167080.83	11121	358363.0
重要保持客户	1592039.62	107789	517267.0
重要发展客户	45785.01	2023	56636.0
重要挽留客户	33028.40	1263	114482.0

从RFM分层可知，大部分用户为重要保持客户，但是这是由于极值的影响，所以RFM的划分标准应该以业务为标准

尽量用小部分的用户覆盖大部分的额度（因为会出现极值干扰，对其均值有干扰，小部分是指去除掉极值后的小部分用户）
不要为了数据好看划分等级

rfm.loc[rfm.label=='重要价值客户','color']='g'
rfm.loc[rfm.label!='重要价值客户','color']='r'

rfm

	M	order_dt	F	R	label	color
user_id
1	11.77	1997-01-01	1	545.0	一般挽留客户	r
2	89.00	1997-01-12	6	534.0	一般挽留客户	r
3	156.46	1998-05-28	16	33.0	重要保持客户	r
4	100.50	1997-12-12	7	200.0	一般发展客户	r
5	385.61	1998-01-03	29	178.0	重要保持客户	r
...	...	...	...	...	...	...
23566	36.00	1997-03-25	2	462.0	一般挽留客户	r
23567	20.97	1997-03-25	1	462.0	一般挽留客户	r
23568	121.70	1997-04-22	6	434.0	重要挽留客户	r
23569	25.74	1997-03-25	2	462.0	一般挽留客户	r
23570	94.08	1997-03-26	5	461.0	一般挽留客户	r

23570 rows × 6 columns

rfm.plot.scatter('F','R',color=rfm.color)

可以看出重要价值客户和非重要价值客户的分布情况

6.2 利用新、活跃、回流、流失用户进行分层

我们按照用户的消费行为，简单划分成几个维度：新用户、活跃用户、不活跃用户、回流用户。

新用户的定义是第一次消费，也可以看成未注册用户。
活跃用户即老客，在某一个时间窗口内有过消费。
不活跃用户则是时间窗口内没有消费过的老客
回流用户是在上一个窗口中没有消费，而在当前时间窗口内有过消费。

以上的时间窗口都是按月统计。
比如某用户在1月第一次消费，那么他在1月的分层就是新用户；他在2月消费国，则是活跃用户；3月没有消费，此时是不活跃用户；4月再次消费，此时是回流用户，5月还是消费，是活跃用户。

df_purchase.tail() # 每月的消费次数

month	1997-01-01	1997-02-01	1997-03-01	1997-04-01	1997-05-01	1997-06-01	1997-07-01	1997-08-01	1997-09-01	1997-10-01	1997-11-01	1997-12-01	1998-01-01	1998-02-01	1998-03-01	1998-04-01	1998-05-01	1998-06-01
user_id
23566	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
23567	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
23568	0	0	1	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0
23569	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
23570	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0

def active_status(data):
    status=[]
    for i in range (18):
        # 若本月没有消费
        if data[i]==0:
            if len(status)>0:
                if status[i-1] == 'unreg':
                    status.append('unreg')
                else:
                    status.append('unactive')
            else:
                status.append('unreg')
        # 若本月有消费
        else:
            if len(status) == 0:
                status.append('new')
            else:
                if status[i-1]=='unactive':
                    status.append('return')
                elif status[i-1] == 'unreg':
                    status.append('new')
                else:
                    status.append('active')
    return pd.Series(status,index=data.index)

若本月没有消费

若之前是未注册，则依旧为未注册用户
若之前有消费，则为流失/活跃用户
其它情况，则为未注册用户

若本月有消费

若是第一次消费，则为新用户
若上个月不活跃，则为回流客户
若上个月是未注册，则为新客户
除此之外为活跃用户

purchase_status = df_purchase.apply(active_status,axis=1)  # apply 指的是对数据框进行“行”或“列”处理
purchase_status.head()

month	1997-01-01	1997-02-01	1997-03-01	1997-04-01	1997-05-01	1997-06-01	1997-07-01	1997-08-01	1997-09-01	1997-10-01	1997-11-01	1997-12-01	1998-01-01	1998-02-01	1998-03-01	1998-04-01	1998-05-01	1998-06-01
user_id
1	new	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive
2	new	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive	unactive
3	new	unactive	return	active	unactive	unactive	unactive	unactive	unactive	unactive	return	unactive	unactive	unactive	unactive	unactive	return	unactive
4	new	unactive	unactive	unactive	unactive	unactive	unactive	return	unactive	unactive	unactive	return	unactive	unactive	unactive	unactive	unactive	unactive
5	new	active	unactive	return	active	active	active	unactive	return	unactive	unactive	return	active	unactive	unactive	unactive	unactive	unactive

status_update = purchase_status.replace('unreg',np.NaN).apply(pd.value_counts)#.T.fillna(0).plot.area()
status_update

month	1997-01-01	1997-02-01	1997-03-01	1997-04-01	1997-05-01	1997-06-01	1997-07-01	1997-08-01	1997-09-01	1997-10-01	1997-11-01	1997-12-01	1998-01-01	1998-02-01	1998-03-01	1998-04-01	1998-05-01	1998-06-01
active	NaN	1157.0	1681	1773.0	852.0	747.0	746.0	604.0	528.0	532.0	624.0	632.0	512.0	472.0	571.0	518.0	459.0	446.0
new	7846.0	8476.0	7248	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
return	NaN	NaN	595	1049.0	1362.0	1592.0	1434.0	1168.0	1211.0	1307.0	1404.0	1232.0	1025.0	1079.0	1489.0	919.0	1029.0	1060.0
unactive	NaN	6689.0	14046	20748.0	21356.0	21231.0	21390.0	21798.0	21831.0	21731.0	21542.0	21706.0	22033.0	22019.0	21510.0	22133.0	22082.0	22064.0

status_update.fillna(0).T.apply(lambda x: x/x.sum(),axis=1).plot.area()

可以看到后期不活跃的用户（流失用户）越来越多，回流用户一直稳定在1000左右，且没有新增用户，说明运营状况不佳
只看紫色回流和活跃两个分层，用户数比较稳定，这两个分层相加，就是每月消费用户占比情况

st_ratio=status_update.fillna(0).apply(lambda x: x/x.sum(),axis=1)  # 统计不同分层用户各月份所占比例
st_ratio

month	1997-01-01	1997-02-01	1997-03-01	1997-04-01	1997-05-01	1997-06-01	1997-07-01	1997-08-01	1997-09-01	1997-10-01	1997-11-01	1997-12-01	1998-01-01	1998-02-01	1998-03-01	1998-04-01	1998-05-01	1998-06-01
active	0.000000	0.090011	0.130776	0.137934	0.066283	0.058114	0.058036	0.046989	0.041077	0.041388	0.048545	0.049168	0.039832	0.036720	0.044422	0.040299	0.035709	0.034697
new	0.332881	0.359610	0.307510	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000
return	0.000000	0.000000	0.031390	0.055342	0.071854	0.083988	0.075653	0.061620	0.063888	0.068953	0.074070	0.064996	0.054075	0.056924	0.078554	0.048483	0.054286	0.055922
unactive	0.000000	0.019337	0.040606	0.059981	0.061739	0.061377	0.061837	0.063017	0.063112	0.062823	0.062276	0.062751	0.063696	0.063655	0.062184	0.063985	0.063838	0.063786

st_ratio.loc[['return','active']].T.plot()

用户回流占比在5%到8%，有下降趋势
活跃用户的下降趋势更明显，占比在3%～5%间。这里用户活跃可以看作连续消费用户，质量在一定程度上高于回流用户
结合回流用户和活跃用户看，在后期的消费用户中，60%是回流用户，40%是活跃用户/连续消费用户，整体质量还好，但是针对这两个分层依旧有改进的空间，可以继续细化数据

7.用户质量分析

因为消费行为有明显的二八倾向，我们需要知道高质量用户为消费贡献了多少份额

用户购买周期（按订单）
- 用户消费周期描述
- 用户消费周期分布
用户购买产品数分布

7.1 用户购买周期

user_cumsum = grouped_user.sum().sort_values('order_amount').apply(lambda x:x.cumsum()/x.sum())  # 先进行排序再计算累计频率
user_cumsum

	order_products	order_amount
user_id
10175	0.000006	0.000000
4559	0.000012	0.000000
1948	0.000018	0.000000
925	0.000024	0.000000
10798	0.000030	0.000000
...	...	...
7931	0.982940	0.985405
19339	0.985192	0.988025
7983	0.988385	0.990814
14048	0.994538	0.994404
7592	1.000000	1.000000

23570 rows × 2 columns

user_cumsum.reset_index().order_amount.plot()   # 必须加上reset_index 重新更换索引否则作图失败

绘制趋势图，横坐标是按贡献金额大小排序而成，纵坐标则是用户累计贡献。
可以很清楚的看到，前20000个用户贡献了40%的消费。后面4000位用户贡献了60%，确实呈现28倾向。

7.2 用户购买产品数分布

user_cumsum1= grouped_user.sum().sort_values('order_products').apply(lambda x:x.cumsum()/x.sum())  # 先进行排序再计算累计频率
user_cumsum1.reset_index().order_amount.plot()

统计一下销量，前两万个用户贡献了40%的销量，高消费用户贡献了60%的销量。

8. 用户生命周期（时间跨度从第一次到最后一次消费）

用户生命周期描述
用户生命周期分布

user_life = grouped_user.order_dt.agg(['min','max']) # 用户的第一次消费和最后一次消费日期
user_life.head()

	min	max
user_id
1	1997-01-01	1997-01-01
2	1997-01-12	1997-01-12
3	1997-01-02	1998-05-28
4	1997-01-01	1997-12-12
5	1997-01-01	1998-01-03

(user_life['max'] - user_life['min']).describe()

count                       23570
mean     134 days 20:55:36.987696
std      180 days 13:46:43.039788
min               0 days 00:00:00
25%               0 days 00:00:00
50%               0 days 00:00:00
75%             294 days 00:00:00
max             544 days 00:00:00
dtype: object

中位数为0天，表示用户只购买了一次

(user_life['min'] == user_life['max']).value_counts()

True     12054
False    11516
dtype: int64

有一半用户，就消费了一次

((user_life['max'] - user_life['min'])/np.timedelta64(1,'D')).hist(bins=20)

横轴表示用户生命周期，纵轴表示用户ID
用户的生命周期收只购买一次的用户影响比较厉害（可以作为特殊情况过滤掉）
用户均消费134天，中位数仅0天

max((user_life['max'] - user_life['min'])/np.timedelta64(1,'D'))

544.0

用户最长生命周期为544天

update_1 =(user_life['max'] - user_life['min']).reset_index()[0]/np.timedelta64(1,'D')
update_1[update_1>0].hist(bins=40)

横轴表示用户生命周期，纵轴表示用户ID
排除了仅消费一次的人做直方图
普通用户的生命周期在50-300天，高质量用户的生命周期在400天以上，也就是忠诚用户。

update_2=update_1[update_1>0]
update_2.mean()

276.0448072247308

用户消费2次及以上的生命周期是276天，高于总体134天。因此用户首次消费后应该引导其进行第二次消费，会带来更多的收益

update_3= update_1[update_1>400]
update_3.sum()/update_2.sum()

0.5292126412266761

update_3.count()/update_1.count()

0.15490029698769622

可以看到用户生命周期在400天以上的用户数占总用户的15.49%，但是其用户生命周期却占总的生命周期的52.92%，超过半数。说明用户的消费收入是取决于这一小撮人，符合二八定律。

9.留存率分析

指用户在第一次消费后有多少比例进行第二次消费

order_dt_min=grouped_user.order_dt.min() # 用户第一次消费时间

min_reindex = order_dt_min.reset_index()
min_reindex.head()

	user_id	order_dt
0	1	1997-01-01
1	2	1997-01-12
2	3	1997-01-02
3	4	1997-01-01
4	5	1997-01-01

user_purchase=df[['user_id','order_dt','order_products','order_amount']]
user_purchase.head()

	user_id	order_dt	order_products	order_amount
0	1	1997-01-01	1	11.77
1	2	1997-01-12	1	12.00
2	2	1997-01-12	5	77.00
3	3	1997-01-02	2	20.76
4	3	1997-03-30	2	20.76

user_purchase_retention=pd.merge(left=user_purchase,right=min_reindex,on='user_id',how='inner',suffixes=('','_min')) #suffix是区分重复列
user_purchase_retention.head()

	user_id	order_dt	order_products	order_amount	order_dt_min
0	1	1997-01-01	1	11.77	1997-01-01
1	2	1997-01-12	1	12.00	1997-01-12
2	2	1997-01-12	5	77.00	1997-01-12
3	3	1997-01-02	2	20.76	1997-01-02
4	3	1997-03-30	2	20.76	1997-01-02

user_purchase_retention['order_diff']=user_purchase_retention['order_dt']-user_purchase_retention['order_dt_min'] # 表示用户每一次消费与第一次消费的时间间隔

user_purchase_retention['order_diff']=user_purchase_retention['order_diff'].apply(lambda x:x/np.timedelta64(1,'D')) # 去除days

user_purchase_retention.order_diff.max()

544.0

研究用户留存一年的消费分布情况，将留存时间分为几个区间。

bin = [0,3,7,15,30,60,90,180,365] 
user_purchase_retention['order_diff_bin'] = pd.cut(user_purchase_retention.order_diff,bins = bin)
user_purchase_retention.head(20)

	user_id	order_dt	order_products	order_amount	order_dt_min	order_diff	order_diff_bin
0	1	1997-01-01	1	11.77	1997-01-01	0.0	NaN
1	2	1997-01-12	1	12.00	1997-01-12	0.0	NaN
2	2	1997-01-12	5	77.00	1997-01-12	0.0	NaN
3	3	1997-01-02	2	20.76	1997-01-02	0.0	NaN
4	3	1997-03-30	2	20.76	1997-01-02	87.0	(60.0, 90.0]
5	3	1997-04-02	2	19.54	1997-01-02	90.0	(60.0, 90.0]
6	3	1997-11-15	5	57.45	1997-01-02	317.0	(180.0, 365.0]
7	3	1997-11-25	4	20.96	1997-01-02	327.0	(180.0, 365.0]
8	3	1998-05-28	1	16.99	1997-01-02	511.0	NaN
9	4	1997-01-01	2	29.33	1997-01-01	0.0	NaN
10	4	1997-01-18	2	29.73	1997-01-01	17.0	(15.0, 30.0]
11	4	1997-08-02	1	14.96	1997-01-01	213.0	(180.0, 365.0]
12	4	1997-12-12	2	26.48	1997-01-01	345.0	(180.0, 365.0]
13	5	1997-01-01	2	29.33	1997-01-01	0.0	NaN
14	5	1997-01-14	1	13.97	1997-01-01	13.0	(7.0, 15.0]
15	5	1997-02-04	3	38.90	1997-01-01	34.0	(30.0, 60.0]
16	5	1997-04-11	3	45.55	1997-01-01	100.0	(90.0, 180.0]
17	5	1997-05-31	3	38.71	1997-01-01	150.0	(90.0, 180.0]
18	5	1997-06-16	2	26.14	1997-01-01	166.0	(90.0, 180.0]
19	5	1997-07-22	2	28.14	1997-01-01	202.0	(180.0, 365.0]

pivoted_retention = user_purchase_retention.pivot_table(index='user_id',values='order_amount',columns='order_diff_bin',aggfunc='sum')
pivoted_retention.head()

order_diff_bin	(0, 3]	(3, 7]	(7, 15]	(15, 30]	(30, 60]	(60, 90]	(90, 180]	(180, 365]
user_id
3	NaN	NaN	NaN	NaN	NaN	40.3	NaN	78.41
4	NaN	NaN	NaN	29.73	NaN	NaN	NaN	41.44
5	NaN	NaN	13.97	NaN	38.90	NaN	110.40	155.54
7	NaN	NaN	NaN	NaN	NaN	NaN	NaN	97.43
8	NaN	NaN	NaN	NaN	13.97	NaN	45.29	104.17

pivoted_retention.mean()

order_diff_bin
(0, 3]        35.905798
(3, 7]        36.385121
(7, 15]       42.669895
(15, 30]      45.964649
(30, 60]      50.215070
(60, 90]      48.975277
(90, 180]     67.223297
(180, 365]    91.960059
dtype: float64

计算一下用户在后续各时间段的平均消费额,可以就看到用户随着留存的时间变长，消费金额也增多。

pivoted_retention_trans = pivoted_retention.fillna(0).applymap(lambda x: 1 if x>0 else 0)

pivoted_retention_trans

order_diff_bin	(0, 3]	(3, 7]	(7, 15]	(15, 30]	(30, 60]	(60, 90]	(90, 180]	(180, 365]
user_id
3	0	0	0	0	0	1	0	1
4	0	0	0	1	0	0	0	1
5	0	0	1	0	1	0	1	1
7	0	0	0	0	0	0	0	1
8	0	0	0	0	1	0	1	1
...	...	...	...	...	...	...	...	...
23561	0	0	0	0	0	0	0	1
23563	0	0	0	0	0	0	0	1
23564	0	0	0	0	1	0	0	1
23568	0	0	1	1	0	0	0	0
23570	1	0	0	0	0	0	0	0

10810 rows × 8 columns

(pivoted_retention_trans.sum()/pivoted_retention_trans.count()).plot.bar()

只有2.5%的用户在第一次消费的次日至3天内有过消费，3%的用户在3～7天内有过消费。有20%的用户在第一次消费后的一个月到半年之间有过购买，23%的用户在半年后至1年内有过购买。从运营角度看，CD机营销在注重新用户的增长同时，应该注重用户忠诚度的培养，在一定时间内召回用户购买。

10.用户平均购买周期

df.order_dt

0       1997-01-01
1       1997-01-12
2       1997-01-12
3       1997-01-02
4       1997-03-30
           ...    
69654   1997-04-05
69655   1997-04-22
69656   1997-03-25
69657   1997-03-25
69658   1997-03-26
Name: order_dt, Length: 69659, dtype: datetime64[ns]

df.order_dt.shift()

0              NaT
1       1997-01-01
2       1997-01-12
3       1997-01-12
4       1997-01-02
           ...    
69654   1997-03-25
69655   1997-04-05
69656   1997-04-22
69657   1997-03-25
69658   1997-03-25
Name: order_dt, Length: 69659, dtype: datetime64[ns]

order_diff=grouped_user.apply(lambda x:x.order_dt-x.order_dt.shift()) # 用户每笔订单日期相差时间

order_diff

user_id       
1        0           NaT
2        1           NaT
         2        0 days
3        3           NaT
         4       87 days
                   ...  
23568    69654   11 days
         69655   17 days
23569    69656       NaT
23570    69657       NaT
         69658    1 days
Name: order_dt, Length: 69659, dtype: timedelta64[ns]

order_diff.describe()

count                      46089
mean     68 days 23:22:13.567662
std      91 days 00:47:33.924168
min              0 days 00:00:00
25%             10 days 00:00:00
50%             31 days 00:00:00
75%             89 days 00:00:00
max            533 days 00:00:00
Name: order_dt, dtype: object

用户平均每单所需用的时间为68天

(order_diff/np.timedelta64(1,'D')).hist(bins=20)

订单周期呈指数分布
绝大部分用户的购买周期都低于100天

看一下直方图，典型的长尾分布，大部分用户的消费间隔确实比较短。不妨将时间召回点设为消费后立即赠送优惠券，消费后10天询问用户CD怎么样，消费后30天提醒优惠券到期，消费后60天短信推送。这便是数据的应用了。

你可能感兴趣的:(python)

理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
python os.environ 江湖偌大 python 深度学习
os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
Python中os.environ基本介绍及使用方法鹤冲天Pro #Python python 服务器开发语言
文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
Pyecharts数据可视化大屏：打造沉浸式数据分析体验我的运维人生信息可视化数据分析数据挖掘运维开发技术共享
Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 python os.environ
>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
使用Faiss进行高效相似度搜索 llzwxh888 faiss python
在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
python是什么意思中文-在python中%是什么意思编程大乐趣
Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
python八股文面试题分享及解析(1) Shawn________ python
#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
Python快速入门 —— 第三节：类与对象孤华暗香 Python快速入门 python 开发语言
第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
pyecharts——绘制柱形图折线图 2224070247 信息可视化 python java 数据可视化
一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
Python 实现图片裁剪（附代码） | Python工具剑客阿良_ALiang
前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
python os 环境变量 CV矿工 python 开发语言 numpy
环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
《Python数据分析实战终极指南》 xjt921122 python 数据分析开发语言
对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
Python中深拷贝与浅拷贝的区别 yuxiaoyu.
转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
Python编译器鹿鹿~ Python编译器 Python python 开发语言后端
嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt
一文掌握python面向对象魔术方法（二）程序员neil python python 开发语言
接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
一文掌握python常用的list（列表）操作程序员neil python python 开发语言
目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
Python实现简单的机器学习算法 master_chenchengg python python 办公效率 python开发 IT
Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
python中的深拷贝与浅拷贝 anshejd70787 python
深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis
用Python实现简单的猜数字游戏程序媛了了 python 游戏 java
猜数字游戏代码：importrandomdefpythonit():a=random.randint(1,100)n=int(input("输入你猜想的数字："))whilen!=a:ifn>a:print("很遗憾，猜大了")n=int(input("请再次输入你猜想的数字："))elifna::如果玩家猜的数字n大于随机数字a，则输出"很遗憾，猜大了"，并提示玩家再次输入。elifn
用Python实现读取统计单词个数程序媛了了 python 游戏 java
完整实例代码：fromcollectionsimportCounterdefpythonit():danci={}withopen("pythonit.txt","r",encoding="utf-8")asf:foriinf:words=i.strip().split()forwordinwords:ifwordnotindanci:danci[word]=1else:danci[word]+=
设计模式介绍 tntxia 设计模式
设计模式来源于土木工程师克里斯托弗亚历山大（http://en.wikipedia.org/wiki/Christopher_Alexander）的早期作品。他经常发表一些作品，内容是总结他在解决设计问题方面的经验，以及这些知识与城市和建筑模式之间有何关联。有一天，亚历山大突然发现，重复使用这些模式可以让某些设计构造取得我们期望的最佳效果。亚历山大与萨拉-石川佳纯和穆雷西乐弗斯坦合作
android高级组件使用(一) 百合不是茶 android RatingBar Spinner
1、自动完成文本框（AutoCompleteTextView） AutoCompleteTextView从EditText派生出来，实际上也是一个文本编辑框，但它比普通编辑框多一个功能：当用户输入一个字符后，自动完成文本框会显示一个下拉菜单，供用户从中选择，当用户选择某个菜单项之后，AutoCompleteTextView按用户选择自动填写该文本框。使用AutoCompleteTex
[网络与通讯]路由器市场大有潜力可挖掘 comsci 网络
如果国内的电子厂商和计算机设备厂商觉得手机市场已经有点饱和了,那么可以考虑一下交换机和路由器市场的进入问题..... 这方面的技术和知识,目前处在一个开放型的状态,有利于各类小型电子企业进入 &nbs
自写简单Redis内存统计shell 商人shang Linux shell 统计Redis内存
#!/bin/bash address="192.168.150.128:6666,192.168.150.128:6666" hosts=(${address//,/ }) sfile="staticts.log" for hostitem in ${hosts[@]} do ipport=(${hostitem
单例模式(饿汉 vs懒汉) oloz 单例模式
package 单例模式; /* * 应用场景:保证在整个应用之中某个对象的实例只有一个 * 单例模式种的《懒汉模式》 * */ public class Singleton { //01 将构造方法私有化，外界就无法用new Singleton()的方式获得实例 private Singleton(){}; //02 申明类得唯一实例 priva
springMvc json支持杨白白 json springmvc
1.Spring mvc处理json需要使用jackson的类库，因此需要先引入jackson包 2在spring mvc中解析输入为json格式的数据:使用@RequestBody来设置输入 @RequestMapping("helloJson") public @ResponseBody JsonTest helloJson() {
android播放，掃描添加本地音頻文件小桔子
最近幾乎沒有什麽事情，繼續鼓搗我的小東西。想在項目中加入一個簡易的音樂播放器功能，就像華為p6桌面上那麼大小的音樂播放器。用過天天動聽或者QQ音樂播放器的人都知道，可已通過本地掃描添加歌曲。不知道他們是怎麼實現的，我覺得應該掃描設備上的所有文件，過濾出音頻文件，每個文件實例化為一個實體，記錄文件名、路徑、歌手、類型、大小等信息。具體算法思想，
oracle常用命令 aichenglong oracle dba 常用命令
1 创建临时表空间 create temporary tablespace user_temp tempfile 'D:\oracle\oradata\Oracle9i\user_temp.dbf' size 50m autoextend on next 50m maxsize 20480m extent management local
25个Eclipse插件 AILIKES eclipse插件
提高代码质量的插件1. FindBugsFindBugs可以帮你找到Java代码中的bug，它使用Lesser GNU Public License的自由软件许可。2. CheckstyleCheckstyle插件可以集成到Eclipse IDE中去，能确保Java代码遵循标准代码样式。3. ECLemmaECLemma是一款拥有Eclipse Public License许可的免费工具，它提供了
Spring MVC拦截器+注解方式实现防止表单重复提交 baalwolf spring mvc
原理：在新建页面中Session保存token随机码，当保存时验证，通过后删除，当再次点击保存时由于服务器端的Session中已经不存在了，所有无法验证通过。 1.新建注解： ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
《Javascript高级程序设计(第3版)》闭包理解 bijian1013 JavaScript
“闭包是指有权访问另一个函数作用域中的变量的函数。”--《Javascript高级程序设计(第3版)》看以下代码： <script type="text/javascript"> function outer() { var i = 10; return f
AngularJS Module类的方法 bijian1013 JavaScript AngularJS Module
AngularJS中的Module类负责定义应用如何启动，它还可以通过声明的方式定义应用中的各个片段。我们来看看它是如何实现这些功能的。一.Main方法在哪里如果你是从Java或者Python编程语言转过来的，那么你可能很想知道AngularJS里面的main方法在哪里？这个把所
[Maven学习笔记七]Maven插件和目标 bit1129 maven插件
插件(plugin)和目标(goal) Maven，就其本质而言，是一个插件执行框架，Maven的每个目标的执行逻辑都是由插件来完成的，一个插件可以有1个或者几个目标，比如maven-compiler-plugin插件包含compile和testCompile，即maven-compiler-plugin提供了源代码编译和测试源代码编译的两个目标使用插件和目标使得我们可以干预
【Hadoop八】Yarn的资源调度策略 bit1129 hadoop
1. Hadoop的三种调度策略 Hadoop提供了3中作业调用的策略， FIFO Scheduler Fair Scheduler Capacity Scheduler 以上三种调度算法，在Hadoop MR1中就引入了，在Yarn中对它们进行了改进和完善.Fair和Capacity Scheduler用于多用户共享的资源调度 2. 多用户资源共享的调度
Nginx使用Linux内存加速静态文件访问 ronin47
Nginx是一个非常出色的静态资源web服务器。如果你嫌它还不够快，可以把放在磁盘中的文件，映射到内存中，减少高并发下的磁盘IO。先做几个假设。nginx.conf中所配置站点的路径是/home/wwwroot/res，站点所对应文件原始存储路径：/opt/web/res shell脚本非常简单，思路就是拷贝资源文件到内存中，然后在把网站的静态文件链接指向到内存中即可。具体如下：
关于Unity3D中的Shader的知识 brotherlamp unity unity资料 unity教程 unity视频 unity自学
首先先解释下Unity3D的Shader，Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader还是使用标准的Cg/HLSL 编程语言编写的。因此Unity文档里面的Shader，都是指用ShaderLab编写的代码，然后我们来看下Unity3D自带的60多个S
CopyOnWriteArrayList vs ArrayList bylijinnan java
package com.ljn.base; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; /** * 总述： * 1.ArrayListi不是线程安全的，CopyO
内存中栈和堆的区别 chicony 内存
1、内存分配方面：堆：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式是类似于链表。可能用到的关键字如下：new、malloc、delete、free等等。栈：由编译器(Compiler)自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中
回答一位网友对Scala的提问 chenchao051 scala map
本来准备在私信里直接回复了，但是发现不太方便，就简要回答在这里。问题写道对于scala的简洁十分佩服，但又觉得比较晦涩，例如一例，Map("a" -> List(11,111)).flatMap(_._2)，可否说下最后那个函数做了什么，真正在开发的时候也会如此简洁？谢谢先回答一点，在实际使用中，Scala毫无疑问就是这么简单。
mysql 取每组前几条记录 daizj mysql 分组最大值最小值每组三条记录
一、对分组的记录取前N条记录：例如：取每组的前3条最大的记录 1.用子查询： SELECT * FROM tableName a WHERE 3> (SELECT COUNT(*) FROM tableName b WHERE b.id=a.id AND b.cnt>a. cnt) ORDER BY a.id,a.account DE
HTTP深入浅出 http请求 dcj3sjt126com http
HTTP(HyperText Transfer Protocol)是一套计算机通过网络进行通信的规则。计算机专家设计出HTTP，使HTTP客户（如Web浏览器）能够从HTTP服务器(Web服务器)请求信息和服务，HTTP目前协议的版本是1.1.HTTP是一种无状态的协议，无状态是指Web浏览器和Web服务器之间不需要建立持久的连接，这意味着当一个客户端向服务器端发出请求，然后We
判断MySQL记录是否存在方法比较 dcj3sjt126com mysql
把数据写入到数据库的时，常常会碰到先要检测要插入的记录是否存在，然后决定是否要写入。　　我这里总结了判断记录是否存在的常用方法：　　sql语句： select count ( * ) from tablename; 　　然后读取count(*)的值判断记录是否存在。对于这种方法性能上有些浪费，我们只是想判断记录记录是否存在，没有必要全部都查出来。
对HTML XML的一点认识 e200702084 html xml
感谢http://www.w3school.com.cn提供的资料 HTML 文档中的每个成分都是一个节点。节点根据 DOM，HTML 文档中的每个成分都是一个节点。 DOM 是这样规定的：整个文档是一个文档节点每个 HTML 标签是一个元素节点包含在 HTML 元素中的文本是文本节点每一个 HTML 属性是一个属性节点注释属于注释节点 Node 层次
jquery分页插件 genaiwei jquery Web 前端分页插件
//jquery页码控件// 创建一个闭包 (function($) { // 插件的定义 $.fn.pageTool = function(options) { var totalPa
Mybatis与Ibatis对照入门于学习 Josh_Persistence mybatis ibatis 区别联系
一、为什么使用IBatis/Mybatis 对于从事 Java EE 的开发人员来说，iBatis 是一个再熟悉不过的持久层框架了，在 Hibernate、JPA 这样的一站式对象 / 关系映射（O/R Mapping）解决方案盛行之前，iBaits 基本是持久层框架的不二选择。即使在持久层框架层出不穷的今天，iBatis 凭借着易学易用、
C中怎样合理决定使用那种整数类型？秋风扫落叶 c 数据类型
如果需要大数值(大于32767或小于32767), 使用long 型。否则, 如果空间很重要 (如有大数组或很多结构), 使用 short 型。除此之外, 就使用 int 型。如果严格定义的溢出特征很重要而负值无关紧要, 或者你希望在操作二进制位和字节时避免符号扩展的问题, 请使用对应的无符号类型。但是, 要注意在表达式中混用有符号和无符号值的情况。 &nbs
maven问题 zhb8015 maven问题
问题1： Eclipse 中新建maven项目无法添加src/main/java 问题 eclipse创建maevn web项目，在选择maven_archetype_web原型后，默认只有src/main/resources这个Source Floder。按照maven目录结构，添加src/main/ja
(二)androidpn-server tomcat版源码解析之--push消息处理 spjich java androdipn 推送
在 (一)androidpn-server tomcat版源码解析之--项目启动这篇中，已经描述了整个推送服务器的启动过程，并且把握到了消息的入口即XmppIoHandler这个类，今天我将继续往下分析下面的核心代码，主要分为3大块，链接创建，消息的发送，链接关闭。先贴一段XmppIoHandler的部分代码 /** * Invoked from an I/O proc
用js中的formData类型解决ajax提交表单时文件不能被serialize方法序列化的问题中华好儿孙 JavaScript Ajax Web 上传文件 FormData
var formData = new FormData($("#inputFileForm")[0]); $.ajax({ type:'post', url:webRoot+"/electronicContractUrl/webapp/uploadfile", data:formData, async: false, ca
mybatis常用jdbcType数据类型 ysj5125094 mybatis mapper jdbcType
MyBatis 通过包含的jdbcType 类型 BIT FLOAT CHAR