🔍

数据分析技术训练营

从零基础到实战 · 6大模块 · 视频+教程+代码+练习

课程章节

代码示例

练习题

15周

建议周期

Python 运行环境加载中，首次加载约需 10MB ...

🧹

Chapter 01

数据清洗与预处理

入门2周

🎥视频解说▼

▶

Python数据清洗入门教程

B站视频嵌入占位 · 后续替换为实际视频

📖图文教程▼

1. 认识脏数据

在真实世界中，数据几乎从来不是完美的。打开一个 CSV 文件，你可能会发现缺失值（某些格子是空的）、重复行、异常值（比如年龄=200）、格式错误。使用 Pandas 的 df.info() 和 df.describe() 可以快速了解数据全貌。

Python

import pandas as pd
data = {'姓名': ['张三', '李四', '王五', '张三', '赵六'],
    '年龄': [25, 30, None, 25, 200],
    '工资': [5000, 8000, 6000, 5000, 7000]}
df = pd.DataFrame(data)
print("数据形状:", df.shape)
print(df.isnull().sum())
print(df.describe())

2. 处理缺失值

缺失值处理有三种策略：删除、填充（均值/中位数/众数）、插值。

Python

# 删除缺失行
df_clean = df.dropna()
# 中位数填充（对异常值更鲁棒）
df_filled = df.fillna({'年龄': df['年龄'].median()})
print("填充后:", df_filled)

3. 重复值与异常值

使用 df.duplicated() 检测重复行。使用 IQR 方法检测异常值。

Python

import numpy as np
print("重复行:", df.duplicated().sum())
Q1, Q3 = df['年龄'].quantile([0.25, 0.75])
IQR = Q3 - Q1
outliers = df[(df['年龄'] < Q1-1.5*IQR) | (df['年龄'] > Q3+1.5*IQR)]
print("异常值:\n", outliers)

💡详细解释▼

❓ 为什么数据清洗如此重要？

数据科学界名言："Garbage In, Garbage Out"。数据科学家约花费 60-80% 的时间在数据清洗上。

🛠 怎么选择缺失值处理方法？

删除：缺失 < 5% 时最简单。均值：适合正态分布。中位数：有异常值时更鲁棒。众数：适合分类数据。

💻动手练习▼

import pandas as pd
import numpy as np

np.random.seed(42)
data = {
    'PassengerId': range(1, 21),
    'Name': [f'乘客{i}' for i in range(1, 21)],
    'Age': [22, 38, 26, 35, None, 28, 54, 2, 27, 14,
            4, 58, 20, 39, 14, 55, 2, None, 31, None],
    'Fare': [7.25, 71.28, 7.92, 53.10, 8.05, 8.46, 51.86,
            21.08, 11.13, 30.07, 16.70, 26.55, 7.85, 31.28,
            7.85, 16.00, 29.12, 18.00, 7.75, 7.75],
    'Sex': ['male','female','female','female','male','male',
            'male','male','female','female','female','male',
            'female','female','female','male','male','female',
            'male','female']
}
df = pd.DataFrame(data)

print("=== 缺失值统计 ===")
print(df.isnull().sum())

age_median = df['Age'].median()
df['Age'] = df['Age'].fillna(age_median)
print(f"\n用中位数 {age_median} 填充后: {df['Age'].isnull().sum()} 个缺失")

Q1 = df['Fare'].quantile(0.25)
Q3 = df['Fare'].quantile(0.75)
upper = Q3 + 1.5 * (Q3 - Q1)
outliers = df[df['Fare'] > upper]
print(f"\nFare 异常值阈值: {upper:.2f}, 数量: {len(outliers)}")

df['Sex_encoded'] = df['Sex'].map({'male': 1, 'female': 0})
print("\n编码后:")
print(df[['Name', 'Sex', 'Sex_encoded']].head(10))

✅练习题▼

Q1. 以下哪个方法最适合处理少量缺失值（< 5%）？

A. 用 0 填充B. 直接删除含缺失值的行C. 忽略不做处理D. 用最大值填充

答案：B。缺失比例很小时直接删除最简单有效。

Q2. IQR 方法中异常值判定范围是？

A. 均值 +/- 2个标准差B. Q1 - IQR ~ Q3 + IQRC. Q1 - 1.5*IQR ~ Q3 + 1.5*IQRD. 最小值 ~ 最大值

答案：C。IQR 方法用 Q1-1.5*IQR 和 Q3+1.5*IQR 作为异常值边界。

Q3. 有异常值时填充缺失值应优先选择？

A. 均值B. 中位数C. 最大值D. 最小值

答案：B。中位数不受极端值影响，更能代表数据中心趋势。

⚙️

Chapter 02

特征工程实战

进阶2周

🎥视频解说▼

▶

特征工程 Python 实战教程

B站视频嵌入占位 · 后续替换为实际视频

📖图文教程▼

1. 标准化与归一化

标准化将数据转为均值0、标准差1。归一化缩放到 [0, 1]。特征量纲差异大时必须先做标准化。

Python

import numpy as np
data = np.array([[25,5000],[30,8000],[35,12000],[40,15000]])
# 标准化
data_std = (data - data.mean(axis=0)) / data.std(axis=0)
print("标准化后均值:", data_std.mean(axis=0).round(4))
# 归一化
data_norm = (data - data.min(axis=0)) / (data.max(axis=0) - data.min(axis=0))
print("归一化范围:", data_norm.min(axis=0), "~", data_norm.max(axis=0))

2. 编码技术

标签编码将分类值映射为整数。独热编码为每个类别创建二进制列。

Python

import pandas as pd
colors = pd.Series(['红','绿','蓝','红','绿'])
print("标签编码:", colors.map({v:i for i,v in enumerate(colors.unique())}).tolist())
print("独热编码:\n", pd.get_dummies(colors, prefix='颜色'))

3. 特征创建

从现有特征创造新特征：数学组合、日期拆分、文本提取。

Python

import pandas as pd
df = pd.DataFrame({'建造年份':[2000,1995,2010],'总面积':[120,85,150],'价格':[300,220,450]})
df['房屋年龄'] = 2024 - df['建造年份']
df['每平米价格'] = (df['价格'] / df['总面积']).round(2)
print(df)

💡详细解释▼

❓ 为什么特征工程比模型选择更重要？

"特征决定上限，模型只是逼近上限"。好的特征能让简单模型超越复杂模型。

🛠 标准化 vs 归一化？

标准化适合 SVM、逻辑回归。归一化适合 KNN、图像处理。有异常值时优先用标准化。

💻动手练习▼

import pandas as pd
import numpy as np

np.random.seed(42)
n = 50
df = pd.DataFrame({
    '建造年份': np.random.randint(1980, 2024, n),
    '总面积': np.random.randint(50, 300, n),
    '卧室数': np.random.randint(1, 6, n),
    '地段等级': np.random.choice(['A','B','C','D'], n),
    '价格': np.random.randint(100, 1000, n) * 1000
})
print("=== 原始数据 ===")
print(df.head())
print(f"形状: {df.shape}")

df['房屋年龄'] = 2024 - df['建造年份']
df['每平米价格'] = (df['价格'] / df['总面积']).round(0)
df_encoded = pd.get_dummies(df, columns=['地段等级'], prefix='地段')
print(f"\n编码后形状: {df_encoded.shape}")

for col in ['房屋年龄', '总面积', '每平米价格']:
    m, s = df_encoded[col].mean(), df_encoded[col].std()
    df_encoded[col+'_std'] = ((df_encoded[col]-m)/s).round(3)
print("\n标准化后:")
print(df_encoded[['房屋年龄','房屋年龄_std']].head())

print("\n与价格的相关系数:")
print(df[['房屋年龄','总面积','卧室数','价格']].corr()['价格'].sort_values(ascending=False))

✅练习题▼

Q1. 独热编码的主要缺点是？

A. 编码速度慢B. 会显著增加数据维度C. 无法处理字符串D. 只能处理二分类

答案：B。100个取值的特征独热编码会新增100列，导致维度灾难。

Q2. 标准化后均值和标准差分别是？

A. 均值=0, 标准差=0B. 均值=1, 标准差=0C. 均值=0, 标准差=1D. 均值=1, 标准差=1

答案：C。标准化公式 (x-mean)/std 变换后均值为0，标准差为1。

Q3. 哪种方法不适合有序分类变量（"低"、"中"、"高"）？

A. 标签编码B. 独热编码C. 有序编码D. 目标编码

答案：B。独热编码会丢失有序变量间的顺序关系。

📊

Chapter 03

数据建模与分析

进阶3周

🎥视频解说▼

▶

机器学习入门 Python 教程

B站视频嵌入占位 · 后续替换为实际视频

📖图文教程▼

1. 线性回归

用 y = wx + b 拟合数据，最小化均方误差（MSE）。

Python

import numpy as np
X = np.array([1,2,3,4,5], dtype=float)
y = np.array([2.1,3.9,6.2,7.8,10.1])
w = ((X-X.mean())*(y-y.mean())).sum() / ((X-X.mean())**2).sum()
b = y.mean() - w*X.mean()
y_pred = w*X + b
r2 = 1 - ((y-y_pred)**2).sum()/((y-y.mean())**2).sum()
print(f"y = {w:.2f}x + {b:.2f}, R² = {r2:.4f}")

2. 逻辑回归（分类）

通过 Sigmoid 函数映射到 [0,1] 概率值，用于二分类。

Python

import numpy as np
def sigmoid(z): return 1/(1+np.exp(-z))
hours = np.array([1,2,3,4,5,6,7,8], dtype=float)
passed = np.array([0,0,0,1,0,1,1,1])
prob = sigmoid(0.8*hours - 3.0)
pred = (prob >= 0.5).astype(int)
print(f"准确率: {(pred==passed).mean():.2%}")

3. 模型评估

回归看 R²/MAE/RMSE，分类看精确率/召回率/F1。

Python

import numpy as np
yt = np.array([1,0,1,1,0,1,0,0,1,1])
yp = np.array([1,0,1,0,0,1,1,0,1,1])
tp=((yp==1)&(yt==1)).sum(); fp=((yp==1)&(yt==0)).sum()
fn=((yp==0)&(yt==1)).sum(); tn=((yp==0)&(yt==0)).sum()
prec=tp/(tp+fp) if tp+fp else 0; rec=tp/(tp+fn) if tp+fn else 0
f1=2*prec*rec/(prec+rec) if prec+rec else 0
print(f"准确率:{(tp+tn)/len(yt):.2%} 精确率:{prec:.2%} 召回率:{rec:.2%} F1:{f1:.2%}")

💡详细解释▼

❓ 为什么需要交叉验证？

K 折交叉验证将数据分成 K 份轮流测试，取平均值，结果更稳定可靠。

🛠 过拟合 vs 欠拟合？

过拟合：训练好但测试差（死记硬背）。欠拟合：训练和测试都差（太简单）。

💻动手练习▼

import numpy as np

np.random.seed(42)
X = np.random.uniform(0, 10, 100)
y = 2.5 * X + 3 + np.random.normal(0, 2, 100)

X_mean, y_mean = X.mean(), y.mean()
w = ((X - X_mean) * (y - y_mean)).sum() / ((X - X_mean)**2).sum()
b = y_mean - w * X_mean
y_pred = w * X + b

mse = ((y - y_pred)**2).mean()
r2 = 1 - ((y - y_pred)**2).sum() / ((y - y_mean)**2).sum()
print("=== 线性回归 ===")
print(f"方程: y = {w:.4f}x + {b:.4f}")
print(f"MSE: {mse:.4f}, RMSE: {np.sqrt(mse):.4f}, R²: {r2:.4f}")

print("\n=== 分类评估 ===")
yt = np.array([1,0,1,1,0,1,0,0,1,1,0,1,1,0,1,0,1,0,1,1])
yp = np.array([1,0,1,0,0,1,1,0,1,1,0,1,0,0,1,0,1,1,1,0])
tp=((yp==1)&(yt==1)).sum(); fp=((yp==1)&(yt==0)).sum()
fn=((yp==0)&(yt==1)).sum(); tn=((yp==0)&(yt==0)).sum()
prec=tp/(tp+fp) if tp+fp else 0; rec=tp/(tp+fn) if tp+fn else 0
f1=2*prec*rec/(prec+rec) if prec+rec else 0
print(f"准确率:{(tp+tn)/len(yt):.2%} 精确率:{prec:.2%} 召回率:{rec:.2%} F1:{f1:.2%}")

✅练习题▼

Q1. R² 分数的取值范围是？

A. [0, 1]B. (-inf, 1]C. [0, 100]D. [-1, 1]

答案：B。R² 可以为负值（模型比均值还差时），越接近1越好。

Q2. 医疗诊断场景中哪个指标最重要？

A. 准确率B. 精确率C. 召回率D. F1

答案：C。漏诊代价远高于误诊，召回率（不漏掉病人）最重要。

Q3. 哪种方法能有效防止过拟合？

A. 更复杂的模型B. 增加训练数据量C. 减少交叉验证折数D. 使用全部特征

答案：B。增加数据量是最直接有效的防过拟合方法。

🗃️

Chapter 04

SQL 高级查询技巧

入门2周

🎥视频解说▼

▶

SQL 入门教程

B站视频嵌入占位 · 后续替换为实际视频

📖图文教程▼

1. SQL 基础查询

SELECT 选择列，FROM 指定表，WHERE 过滤条件。

SQL

SELECT name, salary FROM employees
WHERE salary > 5000 AND department = '技术部'
ORDER BY salary DESC LIMIT 10;

2. 聚合与分组

GROUP BY 分组，HAVING 过滤组。

SQL

SELECT department, COUNT(*) AS 人数, AVG(salary) AS 平均工资
FROM employees GROUP BY department
HAVING AVG(salary) > 5000;

3. 窗口函数

不折叠行，为每行计算额外值。

SQL

SELECT name, salary,
  ROW_NUMBER() OVER(PARTITION BY department ORDER BY salary DESC) AS 排名
FROM employees;

SELECT month, revenue,
  LAG(revenue, 1) OVER(ORDER BY month) AS 上月
FROM sales;

💡详细解释▼

❓ WHERE vs HAVING？

WHERE 分组前过滤行。HAVING 分组后过滤组。执行顺序：FROM->WHERE->GROUP BY->HAVING->SELECT。

🛠 ROW_NUMBER vs RANK？

ROW_NUMBER：连续 1,2,3,4。RANK：并列跳号 1,2,2,4。DENSE_RANK：并列不跳 1,2,2,3。

💻动手练习▼

import pandas as pd
import numpy as np

np.random.seed(42)
emp = pd.DataFrame({
    'id': range(1, 21),
    'name': [f'员工{i}' for i in range(1, 21)],
    'department': np.random.choice(['技术部','市场部','财务部','人事部'], 20),
    'salary': np.random.randint(3000, 15000, 20)
})
print("=== 员工表 ===")
print(emp.to_string(index=False))

print("\n=== GROUP BY + HAVING ===")
r = emp.groupby('department').agg(人数=('id','count'),平均工资=('salary','mean')).round(0)
print(r[r['平均工资'] > 5000].sort_values('平均工资', ascending=False))

print("\n=== ROW_NUMBER ===")
emp['排名'] = emp.groupby('department')['salary'].rank(method='first', ascending=False).astype(int)
print(emp.sort_values(['department','排名']).to_string(index=False))

print("\n=== LAG 环比 ===")
sales = pd.DataFrame({'month':['1月','2月','3月','4月','5月','6月'],'revenue':[100,120,115,140,135,160]})
sales['上月'] = sales['revenue'].shift(1)
sales['增长'] = sales['revenue'] - sales['上月']
print(sales.to_string(index=False))

✅练习题▼

Q1. SQL 正确执行顺序是？

A. SELECT->FROM->WHEREB. FROM->WHERE->GROUP BY->HAVING->SELECTC. FROM->SELECT->WHERED. WHERE->FROM->GROUP BY

答案：B。逻辑执行顺序：FROM->WHERE->GROUP BY->HAVING->SELECT->ORDER BY->LIMIT。

Q2. RANK() 并列第2名后下一个排名是？

A. 2B. 3C. 4D. 5

答案：C。RANK() 遇到并列会跳号，两个第2名后是第4名。

Q3. 窗口函数和 GROUP BY 的主要区别？

A. 窗口函数更快B. 窗口函数不折叠行C. GROUP BY 更强大D. 没区别

答案：B。GROUP BY 折叠行，窗口函数保留每行并附加统计信息。

🐍

Chapter 05

Python 数据分析库

入门3周

🎥视频解说▼

▶

Pandas 数据分析教程

B站视频嵌入占位 · 后续替换为实际视频

📖图文教程▼

1. NumPy 基础

ndarray 数组，向量化运算比循环快 10-100 倍。

Python

import numpy as np
arr = np.array([1,2,3,4,5])
print("向量化:", arr * 2 + 10)
print("均值:", arr.mean(), "标准差:", arr.std())
a = np.array([[1,2,3]]); b = np.array([[10],[20]])
print("广播:\n", a + b)

2. Pandas 数据操作

核心操作：筛选、分组、聚合、合并。

Python

import pandas as pd
df = pd.DataFrame({'部门':['技术','市场','技术'],'工资':[8000,6000,12000]})
print(df[df['工资'] > 7000])
print(df.groupby('部门').agg(平均工资=('工资','mean')))

3. 文本可视化

Python

months = ['1月','2月','3月','4月','5月','6月']
sales = [100,120,115,140,135,160]
for m, s in zip(months, sales):
    print(f"  {m} | {'█' * int(s/max(sales)*30)} {s}万")

💡详细解释▼

❓ 为什么 NumPy 比 Python 循环快？

NumPy 底层用 C 语言实现，利用连续内存和 SIMD 指令集，向量化运算避免了 Python 循环开销。

🛠 loc vs iloc？

df.loc[] 基于标签索引。df.iloc[] 基于位置索引。记忆：loc=label，iloc=integer location。

💻动手练习▼

import pandas as pd
import numpy as np

np.random.seed(42)
n = 100
df = pd.DataFrame({
    '员工ID': range(1001, 1001+n),
    '部门': np.random.choice(['技术部','市场部','财务部','人事部','运营部'], n),
    '年龄': np.random.randint(22, 55, n),
    '工资': np.random.randint(4000, 25000, n),
    '绩效': np.random.uniform(60, 100, n).round(1)
})

print("=== 概览 ===")
print(f"形状: {df.shape}")
print(df.describe().round(1))

print("\n=== 高薪精英 ===")
elite = df[(df['工资']>15000) & (df['绩效']>80)]
print(f"共 {len(elite)} 人")

print("\n=== 部门统计 ===")
dept = df.groupby('部门').agg(人数=('员工ID','count'),平均工资=('工资','mean'),平均绩效=('绩效','mean')).round(1).sort_values('平均工资', ascending=False)
print(dept.to_string())

print("\n=== 相关性 ===")
print(df[['年龄','工资','绩效']].corr().round(3))

print("\n=== 部门工资柱状图 ===")
ds = df.groupby('部门')['工资'].mean().sort_values(ascending=True)
mx = ds.max()
for d, s in ds.items():
    print(f"  {d:4s} | {'█' * int(s/mx*25)} {s:.0f}")

✅练习题▼

Q1. Series 和 DataFrame 的区别？

A. 没区别B. Series 一维，DataFrame 二维C. DataFrame 一维，Series 二维D. Series 只能存数字

答案：B。Series 是一维数组，DataFrame 是二维表格。

Q2. 基于标签的索引方法是？

A. df.iloc[]B. df.loc[]C. df.ix[]D. df.get[]

答案：B。loc 基于标签，iloc 基于位置。

Q3. NumPy 广播机制规则是？

A. 形状必须完全相同B. 从尾部维度比较，兼容维度相等或其中一个是1C. 只能一维数组D. 会修改原数组

答案：B。广播从最右维度比较，兼容条件是相等或其中一个是1。

⚒️

Chapter 06

数据挖掘算法应用

高级3周

🎥视频解说▼

▶

数据挖掘 Python 实战教程

B站视频嵌入占位 · 后续替换为实际视频

📖图文教程▼

1. K-Means 聚类

把数据分成 K 组，使组内相似、组间不同。步骤：选中心->分配->更新->重复。

Python

import numpy as np
def kmeans(X, k, max_iters=100):
    np.random.seed(42)
    centers = X[np.random.choice(len(X), k, replace=False)].copy()
    for _ in range(max_iters):
        dists = np.array([[np.sqrt(((x-c)**2).sum()) for c in centers] for x in X])
        labels = dists.argmin(axis=1)
        new_c = np.array([X[labels==i].mean(axis=0) for i in range(k)])
        if np.allclose(centers, new_c): break
        centers = new_c
    return labels, centers

np.random.seed(42)
X = np.vstack([np.random.normal([2,2],0.5,(30,2)),
               np.random.normal([8,8],0.5,(30,2)),
               np.random.normal([2,8],0.5,(30,2))])
labels, centers = kmeans(X, 3)
for i in range(3):
    print(f"簇{i}: {(labels==i).sum()}个点, 中心=({centers[i][0]:.1f}, {centers[i][1]:.1f})")

2. PCA 降维

把高维数据压缩到低维，保留主要信息。

Python

import numpy as np
np.random.seed(42)
X = np.random.randn(100, 5)
# 手动 PCA
X_centered = X - X.mean(axis=0)
cov = np.cov(X_centered, rowvar=False)
eigenvalues, eigenvectors = np.linalg.eigh(cov)
idx = np.argsort(eigenvalues)[::-1]
eigenvalues = eigenvalues[idx]
eigenvectors = eigenvectors[:, idx]
variance_ratio = eigenvalues / eigenvalues.sum()
print("各主成分方差解释率:", variance_ratio.round(4))
print("前2个累计:", variance_ratio[:2].sum().round(4))

3. 时间序列分析

移动平均、指数平滑，用于趋势预测。

Python

import numpy as np
np.random.seed(42)
sales = np.cumsum(np.random.randn(12) * 10) + 100
months = [f'{i+1}月' for i in range(12)]
# 3个月移动平均
ma3 = np.convolve(sales, np.ones(3)/3, mode='valid')
print("月份 | 实际 | MA3")
for i in range(len(ma3)):
    print(f"  {months[i+1]} | {sales[i+1]:.1f} | {ma3[i]:.1f}")

💡详细解释▼

❓ K-Means 的 K 值怎么选？

常用肘部法则：计算不同 K 值的簇内误差平方和（SSE），画图找"拐点"。拐点对应的 K 就是最优值。

🛠 PCA 降维会丢失信息吗？

会。方差解释率告诉我们保留了多少信息。通常保留累计解释率 > 85% 的主成分即可。

💻动手练习▼

import numpy as np

# === K-Means 聚类 ===
def kmeans(X, k, max_iters=100):
    np.random.seed(42)
    centers = X[np.random.choice(len(X), k, replace=False)].copy()
    for _ in range(max_iters):
        dists = np.array([[np.sqrt(((x-c)**2).sum()) for c in centers] for x in X])
        labels = dists.argmin(axis=1)
        new_c = np.array([X[labels==i].mean(axis=0) for i in range(k)])
        if np.allclose(centers, new_c): break
        centers = new_c
    return labels, centers

np.random.seed(42)
X = np.vstack([
    np.random.normal([2,2], 0.5, (30,2)),
    np.random.normal([8,8], 0.5, (30,2)),
    np.random.normal([2,8], 0.5, (30,2))
])

labels, centers = kmeans(X, 3)
print("=== K-Means 聚类结果 ===")
for i in range(3):
    pts = X[labels==i]
    print(f"簇{i}: {len(pts)}个点, 中心=({centers[i][0]:.2f}, {centers[i][1]:.2f})")
    print(f"  X范围: [{pts[:,0].min():.1f}, {pts[:,0].max():.1f}]")
    print(f"  Y范围: [{pts[:,1].min():.1f}, {pts[:,1].max():.1f}]")

# === PCA 降维 ===
print("\n=== PCA 降维 ===")
np.random.seed(42)
data = np.random.randn(100, 5)
data_centered = data - data.mean(axis=0)
cov = np.cov(data_centered, rowvar=False)
eigenvalues, eigenvectors = np.linalg.eigh(cov)
idx = np.argsort(eigenvalues)[::-1]
eigenvalues = eigenvalues[idx]
var_ratio = eigenvalues / eigenvalues.sum()
print("方差解释率:", var_ratio.round(4))
print(f"前2个累计: {var_ratio[:2].sum():.2%}")
print(f"前3个累计: {var_ratio[:3].sum():.2%}")

# === 时间序列 ===
print("\n=== 时间序列移动平均 ===")
np.random.seed(42)
sales = np.cumsum(np.random.randn(12) * 10) + 100
months = [f'{i+1}月' for i in range(12)]
ma3 = np.convolve(sales, np.ones(3)/3, mode='valid')
print("月份 | 实际    | MA3")
for i in range(len(ma3)):
    print(f"  {months[i+1]}  | {sales[i+1]:7.1f} | {ma3[i]:.1f}")

✅练习题▼

Q1. K-Means 算法需要预先指定什么？

A. 学习率B. 聚类数 KC. 迭代次数上限D. 收敛阈值

答案：B。K-Means 必须预先指定 K 值（聚类数），可用肘部法则选择最优 K。

Q2. PCA 降维后保留的信息量用什么衡量？

A. 均方误差B. 方差解释率C. 准确率D. F1 分数

答案：B。方差解释率表示每个主成分保留的原始信息比例，累计值越高保留越多。

Q3. 移动平均的主要作用是？

A. 增加数据量B. 平滑噪声，揭示趋势C. 检测异常值D. 特征选择

答案：B。移动平均通过取窗口内的均值来平滑短期波动，揭示数据的长期趋势。

返回技能矩阵