小桥流水78

这个屌丝很懒，什么也没留下！

热门标签

2024年最全实战干货｜Python数据分析消费者用户画像，面试数据库开发题目及答案_用户画像面试题csdn

作者：小桥流水78 | 2024-07-28 14:33:02

踩

用户画像面试题csdn

如果你也是看准了Python，想自学Python，在这里为大家准备了丰厚的免费学习大礼包，带大家一起学习，给大家剖析Python兼职、就业行情前景的这些事儿。

一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、全套PDF电子书

书籍的好处就在于权威和体系健全，刚开始学习的时候你可以只看视频或者听某个人讲课，但等你学完之后，你觉得你掌握了，这时候建议还是得去看一下书籍，看权威技术书籍也是每个程序员必经之路。

四、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

成为一个Python程序员专家或许需要花费数年时间，但是打下坚实的基础只要几周就可以，如果你按照我提供的学习路线以及资料有意识地去实践，你就有很大可能成功！
最后祝你好运！！！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！


In [4]:



1
2
3
4
5

df.columns


Out[4]:



1
2
3
4
5

Index([‘age’, ‘job’, ‘marital’, ‘education’, ‘default’, ‘balance’, ‘housing’,
‘loan’, ‘contact’, ‘day’, ‘month’, ‘duration’, ‘campaign’, ‘pdays’,
‘previous’, ‘poutcome’, ‘y’],
dtype=‘object’)


In [5]:



1
2
3
4
5

df.dtypes


Out[5]:



1
2
3
4
5

age int64
job object
marital object
education object
default object
balance int64
housing object
loan object
contact object
day int64
month object
duration int64
campaign int64
pdays int64
previous int64
poutcome object
y object
dtype: object


In [6]:



1
2
3
4
5

pd.Series.value_counts(df.dtypes)


Out[6]:



1
2
3
4
5

object 10
int64 7
Name: count, dtype: int64


In [7]:



1
2
3
4
5

缺失值信息

df.isnull().sum()


Out[7]:



1
2
3
4
5

age 0
job 0
marital 0
education 0
default 0
balance 0
housing 0
loan 0
contact 0
day 0
month 0
duration 0
campaign 0
pdays 0
previous 0
poutcome 0
y 0
dtype: int64


结果表明数据中没有缺失值。


In [8]:



1
2
3
4
5
6
7
8

取出前面8个特征进行建模

df = df.iloc[:, 0:8]


### 4 数据预处理Preprocessing


主要是针对分类型的数据进行编码工作：


In [9]:



1
2
3
4
5
6
7
8
9
10
11

1-独热码

categorical_transformer_onehot = Pipeline(
steps = [(“encoder”, OneHotEncoder(handle_unknown=“ignore”,drop=“first”, sparse=False))])

2-顺序编码

caterogorical_transformer_ordinal = Pipeline(
steps=[(“encoder”, OrdinalEncoder())]
)

3-数据转换（对数变换、标准化、归一化等）

num = Pipeline(
steps=[(“encoder”,PowerTransformer())]
)


In [10]:



1
2
3
4
5

df.dtypes


Out[10]:



1
2
3
4
5

age int64
job object
marital object
education object
default object
balance int64
housing object
loan object
dtype: object


设定数据预处理器：


In [11]:



1
2
3
4
5
6
7
8

preprocessor = ColumnTransformer(transformers=[
(“cat_onehot”, categorical_transformer_onehot, [“default”,“housing”,“loan”,“job”,“marital”]),
(“cat_ordinal”, caterogorical_transformer_ordinal, [“education”]),
(“num”, num, [“age”, “balance”])
])


### 5 创建pipeline


In [12]:



1
2
3
4
5
6
7
8

pipeline = Pipeline(
steps=[(“preprocessor”, preprocessor)]
)

训练

pipe_fit = pipeline.fit(df)


In [13]:



1
2
3
4
5

data = pd.DataFrame(pipe_fit.transform(df), columns=pipe_fit.get_feature_names_out().tolist())
data.shape


Out[13]:



1
2
3
4
5

(45211, 19)


In [14]:



1
2
3
4
5

data.columns


Out[14]:



1
2
3
4
5

Index([‘cat_onehot__default_yes’, ‘cat_onehot__housing_yes’,
‘cat_onehot__loan_yes’, ‘cat_onehot__job_blue-collar’,
‘cat_onehot__job_entrepreneur’, ‘cat_onehot__job_housemaid’,
‘cat_onehot__job_management’, ‘cat_onehot__job_retired’,
‘cat_onehot__job_self-employed’, ‘cat_onehot__job_services’,
‘cat_onehot__job_student’, ‘cat_onehot__job_technician’,
‘cat_onehot__job_unemployed’, ‘cat_onehot__job_unknown’,
‘cat_onehot__marital_married’, ‘cat_onehot__marital_single’,
‘cat_ordinal__education’, ‘num__age’, ‘num__balance’],
dtype=‘object’)


### 6 异常处理（ECOD）


基于Python Outlier Detection库进行异常值处理（Kmeans对异常值敏感）。


另外一种方法ECOD（empirical cumulative distribution functions for outlier detection）基于经验累积分布函数的异常值检测方法。


In [15]:



1
2
3
4
5
6
7
8
9
10
11
12
13
14

from pyod.models.ecod import ECOD

clf = ECOD()
clf.fit(data)

outliers = clf.predict(data)
outliers


Out[15]:



1
2
3
4
5

array([0, 0, 0, …, 1, 0, 0])


In [16]:



1
2
3
4
5

data[“outliers”] = outliers # 添加预测结果
df[“outliers”] = outliers # 原始数据添加预测结果


In [17]:



1
2
3
4
5

包含异常值和不含包单独处理

data无异常值

data_no_outliers = data[data[“outliers”] == 0]
data_no_outliers = data_no_outliers.drop([“outliers”],axis=1)

data有异常值

data_with_outliers = data.copy()
data_with_outliers = data_with_outliers.drop([“outliers”],axis=1)

原始数据无异常值

df_no_outliers = df[df[“outliers”] == 0]
df_no_outliers = df_no_outliers.drop([“outliers”], axis = 1)


In [18]:



1
2
3
4
5

data_no_outliers.head()


Out[18]:


![图片](https://img-blog.csdnimg.cn/img_convert/dbca9da46b04fad7d2c1f46e65fd1baf.jpeg)


查看数据量：


In [19]:



1
2
3
4
5
6
7
8
9
10
11
12
13
14

data_no_outliers.shape


Out[19]:



1
2
3
4
5

(40690, 19)


In [20]:



1
2
3
4
5

data_with_outliers.shape


Out[20]:



1
2
3
4
5

(45211, 19)


### 7 聚类建模（K-Means）


#### 7.1 肘图识别k值


聚类过程中的k值如何确定？介绍基于肘图的方法，详细参考：


https://www.geeksforgeeks.org/elbow-method-for-optimal-value-of-k-in-kmeans/


In [21]:



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

from yellowbrick.cluster import KElbowVisualizer

km = KMeans(init=“k-means++”, random_state=0, n_init=“auto”)
visualizer = KElbowVisualizer(km, k=(2,10))

visualizer.fit(data_no_outliers)
visualizer.show()


Out[21]:


![图片](https://img-blog.csdnimg.cn/img_convert/27809549127f2d27b4aaca135dd1c983.jpeg)



1
2
3
4
5
6
7
8

<Axes: title={‘center’: ‘Distortion Score Elbow for KMeans Clustering’}, xlabel=‘k’, ylabel=‘distortion score’>


我们可以看到k=6的时候是最好的。


#### 7.2 轮廓系数变化


In [22]:



1
2
3
4
5
6
7
8
9
10
11

from sklearn.metrics import davies_bouldin_score, silhouette_score, silhouette_samples
import matplotlib.cm as cm

def make_Silhouette_plot(X, n_clusters):
plt.xlim([-0.1, 1])
plt.ylim([0, len(X) + (n_clusters + 1) * 10])
# 建立聚类模型
clusterer = KMeans(n_clusters=n_clusters,
max_iter=1000,
n_init=10,
init=“k-means++”,
random_state=10)

# 聚类预测生成标签label
cluster_label = clusterer.fit_predict(X)
# 计算轮廓系数均值（整体数据样本）
silhouette_avg = silhouette_score(X,cluster_label)
print(f"n\_clusterers: {n\_clusters}, silhouette\_score\_avg:{silhouette\_avg}")

# 单个数据样本
sample_silhouette_value = silhouette_samples(X, cluster_label)
y_lower = 10

for i in range(n_clusters):
    # 第i个簇群的轮廓系数
    i_cluster_silhouette_value = sample_silhouette_value[cluster_label == i]
    # 进行排序
    i_cluster_silhouette_value.sort()
    size_cluster_i = i_cluster_silhouette_value.shape[0]
    y_upper = y_lower + size_cluster_i
    # 颜色设置
    color = cm.nipy_spectral(float(i) / n_clusters)
    
    # 边界填充
    plt.fill_betweenx(
        np.arange(y_lower, y_upper),
        0,
        i_cluster_silhouette_value,
        facecolor=color,
        edgecolor=color,
        alpha=0.7
    )
    # 添加文本信息
    plt.text(-0.05, y_lower + 0.5 \* size_cluster_i, str(i))
    y_lower = y_upper + 10
    plt.title(f"The Silhouette Plot for n\_cluster = {n\_clusters}", fontsize=26)
    plt.xlabel("The silhouette coefficient values", fontsize=24)
    plt.ylabel("Cluter Label", fontsize=24)
    plt.axvline(x=silhouette_avg, color="red", linestyle="--")
    # x-y轴的刻度标签
    plt.xticks([-0.1,0,0.2,0.4,0.6,0.8,1])
    plt.yticks([])
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

range_n_clusters = list(range(2, 10))

for n in range_n_clusters:
print(f"N cluster:{n}“)
make_Silhouette_plot(data_no_outliers, n)
plt.savefig(f"Silhouette_Plot_{n}.png”)
plt.close()
N cluster:2
n_clusterers: 2, silhouette_score_avg:0.18112038570087005
…
N cluster:9
n_clusterers: 9, silhouette_score_avg:0.1465020645956104


不同k值下的轮廓系数对比：


![图片](https://img-blog.csdnimg.cn/img_convert/4a8dac1d055ac5ba939812b09ad19fcb.jpeg)


![图片](https://img-blog.csdnimg.cn/img_convert/9083fcc198df5989062eb6ce3b0d9371.jpeg)


![图片](https://img-blog.csdnimg.cn/img_convert/e093b0f9b1e11eee9554ffc0e0403d16.jpeg)


![图片](https://img-blog.csdnimg.cn/img_convert/b4032775babf83da59b9697581d2fab0.jpeg)


![图片](https://img-blog.csdnimg.cn/img_convert/ee49146db9da555c1a80b5eee80aaca2.jpeg)


![图片](https://img-blog.csdnimg.cn/img_convert/405e5ea5e0b45b40d4341c341283429b.jpeg)


![图片](https://img-blog.csdnimg.cn/img_convert/66aca33258b69bf5c25afa48e2d5c9ed.jpeg)


![图片](https://img-blog.csdnimg.cn/img_convert/425614a4a23f385ba9a104c03ad9fb2f.jpeg)


#### 7.3 实施聚类


从结果来说，k=6或者5效果都还OK，在这里我们最终选择k=5进行聚类分群：


In [23]:



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

km = KMeans(n_clusters=5,
init=“k-means++”,
n_init=10,
max_iter=100,
random_state=42
)

对无离群点数据的聚类

clusters_predict = km.fit_predict(data_no_outliers)


#### 7.4 评价聚类效果


聚类效果如何评价？常用的三种评价指标：


* Davies-Bouldin指数
* Calinski-Harabasz Score
* Silhouette Score


In [24]:



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from sklearn.metrics import silhouette_score # 轮廓系数
from sklearn.metrics import calinski_harabasz_score
from sklearn.metrics import davies_bouldin_score # 戴维森堡丁指数（DBI）


##### Davies-Bouldin指数


Davies-Bouldin指数是聚类算法的一种评估方法，其值越小则表示聚类结果越好。该指数的原理是通过比较不同聚类簇之间的距离和不同聚类簇内部距离来测量聚类的效果。其计算方法如下：


* 对于每一个聚类簇，计算其中心点(centroid)。
* 计算每个聚类簇内点与其中心点的距离，并求其平均值，得到聚类内部距离(intra-cluster distance)。
* 计算不同聚类簇之间中心点的距离，并求其平均值，得到聚类间距离(inter-cluster distance)。
* 对于每个聚类簇，计算其Davies-Bouldin指数：除该簇外所有其他簇中心点与该簇中心点距离的平均值与该簇内部距离的比值。
* 对所有聚类簇的Davies-Bouldin指数求平均值，得到聚类总体的Davies-Bouldin指数。


通过Davies-Bouldin指数，我们可以比较不同聚类算法、不同参数下的聚类效果，从而选择最佳的聚类方案。Davies-Bouldin指数能够考虑到聚类结果的波动情况，对于相似的聚类结果，其Davies-Bouldin指数较大。因此，Davies-Bouldin指数能够区分不同聚类结果的相似程度。


此外，Davies-Bouldin指数没有假设聚类簇形状和大小的先验知识，因此可以适用于不同聚类场景。


##### Calinski-Harabasz Score


Calinski-Harabasz Score是一种用于评估聚类质量的指标，它基于聚类中心之间的方差和聚类内部的方差之比来计算。该指数越大，表示聚类效果越好。


Calinski-Harbasz Score是通过评估类之间方差和类内方差来计算得分，具体公式表示为：


其中，代表聚类类别数，代表全部数据数目，是类间方差，是类内方差。


的计算公式：


trace只考虑了矩阵对角上的元素，即类中所有数据点到类的欧几里得距离。


的计算公式为：


其中，是类中所有数据的集合，是类q的质点，是所有数据的中心点，是类数据点的总数。


##### Silhouette Score


Silhouette Score表示为轮廓系数。


Silhouette Score 是一种衡量聚类结果质量的指标，它结合了聚类内部的紧密度和不同簇之间的分离度。对于每个数据点，Silhouette Score 考虑了以下几个因素：


* a：数据点到同簇其他点的平均距离（簇内紧密度）
* b：数据点到最近不同簇的平均距离（簇间分离度）


具体而言，Silhouette Score 计算公式为：


轮廓系数的取值在 -1 到 1 之间，越接近 1 表示聚类效果越好，越接近 -1 则表示聚类结果较差。


In [25]:



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

print(f"Davies bouldin score: {davies_bouldin_score(data_no_outliers,clusters_predict)}“)
print(f"Calinski Score: {calinski_harabasz_score(data_no_outliers,clusters_predict)}”)
print(f"Silhouette Score: {silhouette_score(data_no_outliers,clusters_predict)}")
Davies bouldin score: 1.6775659296391374
Calinski Score: 6914.724747148267
Silhouette Score: 0.1672869940907178


### 8 降维（基于Prince.PCA）


参考官网学习地址：https://github.com/MaxHalford/prince


#### 8.1 降维函数


In [26]:



1
2
3
4
5
6
7
8
9
10
11
12
13
14

import prince
import plotly.express as px

def get_pca_2d(df, predict):
“”"
建立聚类模型，保留2个主成分
“”"
pca_2d_object = prince.PCA(
n_components=2, # 保留两个主成分
n_iter=3, # 迭代次数
rescale_with_mean=True, # 基于均值和标准差的尺度缩放
rescale_with_std=True,
copy=True,
check_input=True,
engine=“sklearn”,
random_state=42
)
# 模型训练
pca_2d_object.fit(df)
# 原数据转换
df_pca_2d = pca_2d_object.transform(df)
df_pca_2d.columns = [“comp1”, “comp2”]
# 添加聚类预测结果
df_pca_2d[“cluster”] = predict

return pca_2d_object, df_pca_2d
1

同样的方式创建保留3个主成分的功能函数

def get_pca_3d(df, predict):
“”"
保留3个主成分
“”"
pca_3d_object = prince.PCA(
n_components=3, # 保留3个主成分
n_iter=3,
rescale_with_mean=True,
rescale_with_std=True,
copy=True,
check_input=True,
engine=‘sklearn’,
random_state=42
)

pca_3d_object.fit(df)

df_pca_3d = pca_3d_object.transform(df)
df_pca_3d.columns = ["comp1", "comp2", "comp3"]
df_pca_3d["cluster"] = predict

return pca_3d_object, df_pca_3d
1
2
3
4
5
6
7


#### 8.2 降维可视化


下面是基于2个主成分的可视化绘图函数：


In [27]:



1
2
3
4
5
6
7
8
9
10
11

def plot_pca_2d(df, title=“PCA Space”, opacity=0.8, width_line=0.1):
“”"
2个主成分的降维可视化
“”"
df = df.astype({“cluster”: “object”}) # 指定字段的数据类型
df = df.sort_values(“cluster”)

columns = df.columns[0:3].tolist()

# 绘图
fig = px.scatter(
    df,
    x=columns[0], 
    y=columns[1], 
    color='cluster',
    template="plotly",
    color_discrete_sequence=px.colors.qualitative.Vivid,
     title=title
 )
    
# trace更新
fig.update_traces(marker={
    "size": 8,
    "opacity": opacity,
    "line":{"width": width_line,
            "color":"black"}
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

layout更新

fig.update_layout(
    width=800,  # 长宽
    height=700,
    autosize=False,
    showlegend = True,
    legend=dict(title_font_family="Times New Roman", font=dict(size= 20)),
    scene = dict(xaxis=dict(title = 'comp1', titlefont_color = 'black'),
                 yaxis=dict(title = 'comp2', titlefont_color = 'black')),
    font = dict(family = "Gilroy", color  = 'black', size = 15))

fig.show()    
1
2
3
4
5
6
7
8
9
10
11


下面是基于3个主成分的可视化绘图函数：


In [28]:



1
2
3
4
5
6
7
8

def plot_pca_3d(df, title=“PCA Space”, opacity=0.8, width_line=0.1):
“”"
3个主成分的降维可视化
“”"
df = df.astype({“cluster”: “object”})
df = df.sort_values(“cluster”)

# 定义fig
fig = px.scatter_3d(
    df,
    x='comp1', 
    y='comp2', 
    z='comp3',
    color='cluster',
    template="plotly",
    color_discrete_sequence=px.colors.qualitative.Vivid,
    title=title
)

# trace更新
fig.update_traces(marker={
    "size":4,
    "opacity":opacity,
    "line":{"width":width_line,
            "color":"black"}
})

# layout更新
fig.update_layout(
    width=800,  # 长宽
    height=800,
    autosize=True,
    showlegend = True,
    legend=dict(title_font_family="Times New Roman", font=dict(size= 20)),
    scene = dict(xaxis=dict(title = 'comp1', 
                            titlefont_color = 'black'),
                 yaxis=dict(title = 'comp2', 
                            titlefont_color = 'black'),
                 zaxis=dict(title = 'comp3', 
                            titlefont_color = 'black')),
    font = dict(family = "Gilroy", color  = 'black', size = 15))

fig.show()
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


##### 8.2.1 2维


下面是2维可视化的效果：


In [29]:



1
2
3
4
5
6
7
8
9
10
11

pca_2d_object, df_pca_2d = get_pca_2d(data_no_outliers, clusters_predict)


In [30]:



1
2
3
4
5

plot_pca_2d(df_pca_2d, title = “PCA Space”, opacity=1, width_line = 0.1)



现在能在网上找到很多很多的学习资源，有免费的也有收费的，当我拿到1套比较全的学习资源之前，我并没着急去看第1节，我而是去审视这套资源是否值得学习，有时候也会去问一些学长的意见，如果可以之后，我会对这套学习资源做1个学习计划，我的学习计划主要包括规划图和学习进度表。



分享给大家这份我薅到的免费视频资料，质量还不错，大家可以跟着学习

![](https://img-blog.csdnimg.cn/img_convert/21b2604bd33c4b6713f686ddd3fe5aff.png)



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/forums/4304bb5a486d4c3ab8389e65ecb71ac0)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】