Python数据分析进阶课程：从基础到实战精通掌握核心技巧解决复杂数据难题提升职场竞争力

引言：为什么需要Python数据分析进阶技能？

在当今数据驱动的商业环境中，Python已经成为数据分析领域的标准工具。然而，仅仅掌握基础的pandas和matplotlib操作已经无法满足企业对高级数据分析师的需求。本课程将带你从基础走向精通，掌握解决复杂数据难题的核心技巧，显著提升你的职场竞争力。

学习目标

• 掌握高级数据处理技巧
• 理解复杂数据结构的处理方法
• 学会使用Python进行高效的数据清洗和转换
• 掌握高级可视化技巧
• 学会使用机器学习进行数据预测
• 能够独立完成端到端的数据分析项目

第一章：高级数据处理技巧

1.1 多层索引（MultiIndex）的高级操作

多层索引是处理高维数据的强大工具，特别适合处理时间序列数据和分组数据。

import pandas as pd
import numpy as np

# 创建一个多层索引的DataFrame
arrays = [['A', 'A', 'B', 'B'], [1, 2, 1, 2]]
index = pd.MultiIndex.from_arrays(arrays, names=['first', 'second'])
df = pd.DataFrame({'value': [10, 20, 30, 40]}, index=index)

# 高级索引操作
print("原始数据：")
print(df)

# 使用xs进行跨层选择
print("\n使用xs选择第一层为A的数据：")
print(df.xs('A', level='first'))

# 使用swaplevel交换索引层级
print("\n交换索引层级后：")
print(df.swaplevel('first', 'second').sort_index())

输出结果：

原始数据：
              value
first second        
A     1           10
      2           20
B     1           30
      2           40

使用xs选择第一层为A的数据：
       value
second        
1         10
2         20

交换索引层级后：
              value
second first        
1      A         10
2      A         20
1      B         30
2      B         40

1.2 高效的分组聚合操作

掌握groupby的高级用法，包括自定义聚合函数和transform操作。

# 创建示例数据
np.random.seed(42)
df = pd.DataFrame({
    'category': np.random.choice(['A', 'B', 'C'], 100),
    'value': np.random.randn(100),
    'size': np.random.randint(1, 10, 100)
})

# 基础分组聚合
print("基础分组统计：")
print(df.groupby('category').agg({
    'value': ['mean', 'std', 'count'],
    'size': ['max', 'min']
}))

# 自定义聚合函数
def custom_agg(x):
    return pd.Series({
        'q75': x.quantile(0.75),
        'q25': x.quantile(0.25),
        'iqr': x.quantile(0.75) - x.quantile(0.25)
    })

print("\n使用自定义聚合函数：")
print(df.groupby('category')['value'].agg(custom_agg))

# transform操作：保持原始数据形状
df['value_category_mean'] = df.groupby('category')['value'].transform('mean')
print("\n添加类别均值列后的数据：")
print(df.head())

1.3 高效的合并与连接操作

处理多个数据源时，高效的合并操作至关重要。

# 创建两个示例DataFrame
df1 = pd.DataFrame({
    'key': ['A', 'B', 'C', 'D'],
    'value1': [1, 2, 3, 4]
})

df2 = pd.DataFrame({
    'key': ['B', 'D', 'E', 'F'],
    'value2': [5, 6, 7, 8]
})

# 不同的合并方式
print("内连接（inner join）：")
print(pd.merge(df1, df2, on='key', how='inner'))

print("\n左连接（left join）：")
print(pd.merge(df1, df2, on='key', how='left'))

print("\n外连接（outer join）：")
print(pd.merge(df1, df2, on='key', how='outer'))

# 处理重复键的情况
df3 = pd.DataFrame({
    'key': ['A', 'A', 'B', 'B'],
    'value': [1, 2, 3, 4]
})

df4 = pd.DataFrame({
    'key': ['A', 'B', 'B', 'C'],
    'value': [5, 6, 7, 8]
})

print("\n处理重复键的合并：")
print(pd.merge(df3, df4, on='key', how='inner', suffixes=('_left', '_right')))

第二章：复杂数据清洗与转换

2.1 高级缺失值处理

在实际业务中，缺失值的处理策略直接影响分析结果的准确性。

# 创建包含复杂缺失模式的数据
np.random.seed(42)
df = pd.DataFrame({
    'A': np.random.choice([1, 2, np.nan, 4], 100),
    'B': np.random.choice(['X', 'Y', None, 'Z'], 100),
    'C': np.random.randn(100)
})

# 高级缺失值检测
print("各列缺失值数量：")
print(df.isnull().sum())

print("\n缺失值模式分析：")
print(df.isnull().mean())

# 高级填充策略
# 1. 前向填充和后向填充
df_filled = df.copy()
df_filled['A_ffill'] = df_filled['A'].fillna(method='ffill')
df_filled['A_bfill'] = df_filled['A'].fillna(method='bfill')

# 2. 基于统计量的填充
df_filled['A_mean'] = df_filled['A'].fillna(df_filled['A'].mean())
df_filled['A_median'] = df_filled['A'].fillna(df_filled['A'].median())

# 3. 基于分组的填充
df_filled['A_group_mean'] = df_filled.groupby('B')['A'].transform(
    lambda x: x.fillna(x.mean())
)

print("\n不同填充策略的比较：")
print(df_filled[['A', 'A_ffill', 'A_mean', 'A_group_mean']].head(10))

2.2 复杂数据类型转换

处理日期、时间、分类数据等复杂类型。

# 日期时间处理
df = pd.DataFrame({
    'date_str': ['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04'],
    'value': [100, 102, 105, 108]
})

# 高级日期解析
df['date'] = pd.to_datetime(df['date_str'])
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day
df['weekday'] = df['date'].dt.weekday
df['is_weekend'] = df['date'].dt.weekday >= 5

# 时间序列重采样
df.set_index('date', inplace=True)
print("按周重采样：")
print(df.resample('W').mean())

# 分类数据处理
df_cat = pd.DataFrame({
    'grade': ['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B'],
    'score': [85, 72, 91, 88, 75, 94, 82, 78]
})

# 将字符串转换为分类类型
df_cat['grade_cat'] = df_cat['grade'].astype('category')
print("\n分类数据信息：")
print(df_cat['grade_cat'].describe())

# 自定义分类顺序
grade_order = pd.CategoricalDtype(categories=['C', 'B', 'A'], ordered=True)
df_cat['grade_ordered'] = df_cat['grade'].astype(grade_order)
print("\n有序分类数据：")
print(df_cat.sort_values('grade_ordered'))

2.3 高级字符串操作

使用向量化字符串操作和正则表达式进行复杂文本处理。

# 创建示例文本数据
df = pd.DataFrame({
    'product_code': ['A-123', 'B-456', 'C-789', 'D-012', 'E-345'],
    'description': ['Red Apple', 'Blue Berry', 'Green Grape', 'Yellow Banana', 'Orange Orange'],
    'price': [1.23, 2.45, 3.67, 4.89, 5.12]
})

# 向量化字符串操作
df['category'] = df['product_code'].str.split('-').str[0]
df['number'] = df['product_code'].str.split('-').str[1].astype(int)
df['color'] = df['description'].str.split(' ').str[0]
df['fruit'] = df['description'].str.split(' ').str[1]

# 正则表达式提取
df['code_prefix'] = df['product_code'].str.extract(r'^([A-Z])')
df['code_suffix'] = df['product_code'].str.extract(r'-(\d+)$')

# 字符串替换和清理
df['description_clean'] = df['description'].str.replace(r'\s+', ' ', regex=True).str.strip()

print("字符串处理结果：")
print(df)

# 高级文本分析
df['word_count'] = df['description'].str.split().str.len()
df['contains_color'] = df['description'].str.contains('Red|Blue|Green', case=False)

print("\n文本分析结果：")
print(df[['description', 'word_count', 'contains_color']])

第三章：高级可视化技巧

3.1 使用Seaborn进行高级统计可视化

Seaborn是基于matplotlib的高级可视化库，特别适合统计图表。

import seaborn as sns
import matplotlib.pyplot as plt

# 设置风格
sns.set_theme(style="whitegrid")

# 创建示例数据
np.random.seed(42)
data = pd.DataFrame({
    'category': np.random.choice(['A', 'B', 'C'], 200),
    'value': np.random.randn(200),
    'size': np.random.randint(1, 10, 200),
    'group': np.random.choice(['X', 'Y'], 200)
})

# 1. 分布可视化
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

# 小提琴图
sns.violinplot(data=data, x='category', y='value', ax=axes[0,0])
axes[0,0].set_title('Violin Plot')

# 箱线图
sns.boxplot(data=data, x='category', y='value', ax=axes[0,1])
axes[0,1].set_title('Box Plot')

# 点图
sns.pointplot(data=data, x='category', y='value', hue='group', ax=axes[1,0])
axes[1,0].set_title('Point Plot')

# 热力图
pivot_data = data.pivot_table(values='value', index='category', columns='group', aggfunc='mean')
sns.heatmap(pivot_data, annot=True, fmt=".2f", ax=axes[1,1])
axes[1,1].set_title('Heatmap')

plt.tight_layout()
plt.show()

# 2. 关系可视化
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# 散点图矩阵
sns.scatterplot(data=data, x='value', y='size', hue='category', style='group', ax=axes[0])
axes[0].set_title('Scatter Plot with Multiple Encodings')

# 回归图
sns.regplot(data=data, x='value', y='size', ax=axes[1])
axes[1].set_title('Regression Plot')

plt.tight_layout()
plt.show()

3.2 交互式可视化

使用Plotly创建交互式图表，适合在网页或报告中展示。

import plotly.express as px
import plotly.graph_objects as go

# 创建示例数据
np.random.seed(42)
df = pd.DataFrame({
    'x': np.random.randn(100),
    'y': np.random.randn(100),
    'size': np.random.randint(10, 100, 100),
    'category': np.random.choice(['A', 'B', 'C'], 100),
    'date': pd.date_range('2023-01-01', periods=100)
})

# 1. 交互式散点图
fig1 = px.scatter(df, x='x', y='y', color='category', size='size',
                 hover_data=['date'], title='Interactive Scatter Plot')
fig1.show()

# 2. 时间序列图
fig2 = px.line(df, x='date', y='y', color='category', title='Time Series Plot')
fig2.show()

# 3. 3D散点图
fig3 = px.scatter_3d(df, x='x', y='y', z='size', color='category',
                     title='3D Scatter Plot')
fig3.show()

# 4. 高级自定义图表
fig = go.Figure()

# 添加不同类别的散点
for cat in df['category'].unique():
    cat_data = df[df['category'] == cat]
    fig.add_trace(go.Scatter(
        x=cat_data['x'],
        y=cat_data['y'],
        mode='markers',
        name=f'Category {cat}',
        marker=dict(
            size=cat_data['size'],
            opacity=0.7
        ),
        hovertemplate='<b>Category: %{text}</b><br>X: %{x:.2f}<br>Y: %{y:.2f}<extra></extra>',
        text=cat_data['category']
    ))

fig.update_layout(
    title='Custom Interactive Scatter Plot',
    xaxis_title='X Value',
    yaxis_title='Y Value',
    hovermode='closest'
)

fig.show()

第四章：机器学习基础与数据预测

4.1 使用Scikit-learn进行回归预测

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.preprocessing import StandardScaler

# 创建示例数据集
np.random.seed(42)
X = np.random.randn(500, 5)
y = 2 * X[:, 0] + 3 * X[:, 1] - X[:, 2] + 0.5 * X[:, 3] + np.random.randn(500) * 0.1

# 数据分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 数据标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 线性回归模型
lr_model = LinearRegression()
lr_model.fit(X_train_scaled, y_train)
y_pred_lr = lr_model.predict(X_test_scaled)

# 随机森林模型
rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
rf_model.fit(X_train_scaled, y_train)
y_pred_rf = rf_model.predict(X_test_scaled)

# 模型评估
print("线性回归模型评估：")
print(f"均方误差: {mean_squared_error(y_test, y_pred_lr):.4f}")
print(f"R²分数: {r2_score(y_test, y_pred_lr):.4f}")

print("\n随机森林模型评估：")
print(f"均方误差: {mean_squared_error(y_test, y_pred_rf):.4f}")
print(f"R²分数: {r2_score(y_test, y_pred_rf):.4f}")

# 特征重要性分析
feature_importance = pd.DataFrame({
    'feature': [f'feature_{i}' for i in range(5)],
    'importance': rf_model.feature_importances_
}).sort_values('importance', ascending=False)

print("\n随机森林特征重要性：")
print(feature_importance)

4.2 分类任务与模型评估

from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix, roc_curve, auc
import matplotlib.pyplot as plt

# 创建分类数据集
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, 
                          n_redundant=2, random_state=42)

# 数据分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 逻辑回归模型
logreg = LogisticRegression(random_state=42)
logreg.fit(X_train, y_train)
y_pred = logreg.predict(X_test)
y_pred_proba = logreg.predict_proba(X_test)[:, 1]

# 模型评估
print("分类报告：")
print(classification_report(y_test, y_pred))

print("\n混淆矩阵：")
print(confusion_matrix(y_test, y_pred))

# ROC曲线
fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)
roc_auc = auc(fpr, tpr)

plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic (ROC) Curve')
plt.legend(loc="lower right")
plt.show()

4.3 模型保存与加载

import joblib

# 保存模型
joblib.dump(rf_model, 'random_forest_model.pkl')
joblib.dump(scaler, 'scaler.pkl')

# 加载模型
loaded_model = joblib.load('random_forest_model.pkl')
loaded_scaler = joblib.load('scaler.pkl')

# 使用加载的模型进行预测
new_data = np.random.randn(1, 5)
new_data_scaled = loaded_scaler.transform(new_data)
prediction = loaded_model.predict(new_data_scaled)

print(f"新数据预测结果: {prediction[0]:.4f}")

第五章：端到端数据分析项目实战

5.1 项目结构与工作流

一个完整的数据分析项目通常包括以下步骤：

1. 问题定义
2. 数据收集与加载
3. 数据探索与清洗
4. 特征工程
5. 模型构建与评估
6. 结果解释与报告

5.2 实战案例：销售预测分析

# 模拟销售数据
np.random.seed(42)
dates = pd.date_range('2020-01-01', '2023-12-31', freq='D')
n = len(dates)

sales_data = pd.DataFrame({
    'date': dates,
    'sales': np.random.normal(1000, 200, n) + 
             np.sin(np.arange(n) * 2 * np.pi / 365) * 200 +  # 季节性
             np.arange(n) * 0.1 +  # 趋势
             np.random.normal(0, 50, n),  # 噪声
    'temperature': np.random.normal(20, 10, n),
    'is_holiday': np.random.choice([0, 1], n, p=[0.97, 0.03])
})

# 特征工程
sales_data['month'] = sales_data['date'].dt.month
sales_data['day_of_week'] = sales_data['date'].dt.dayofweek
sales_data['is_weekend'] = (sales_data['day_of_week'] >= 5).astype(int)
sales_data['sales_lag_7'] = sales_data['sales'].shift(7)
sales_data['sales_rolling_mean_7'] = sales_data['sales'].rolling(7).mean()

# 处理缺失值
sales_data = sales_data.dropna()

# 准备特征和目标变量
feature_cols = ['temperature', 'is_holiday', 'month', 'day_of_week', 
                'is_weekend', 'sales_lag_7', 'sales_rolling_mean_7']
X = sales_data[feature_cols]
y = sales_data['sales']

# 数据分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 模型训练
model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 预测与评估
y_pred = model.predict(X_test)
print(f"销售预测模型性能：")
print(f"均方误差: {mean_squared_error(y_test, y_pred):.2f}")
print(f"R²分数: {r2_score(y_test, y_pred):.4f}")

# 特征重要性
importance = pd.DataFrame({
    'feature': feature_cols,
    'importance': model.feature_importances_
}).sort_values('importance', ascending=False)

print("\n特征重要性排序：")
print(importance)

# 可视化预测结果
plt.figure(figsize=(12, 6))
plt.scatter(y_test, y_pred, alpha=0.5)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
plt.xlabel('Actual Sales')
plt.ylabel('Predicted Sales')
plt.title('Actual vs Predicted Sales')
plt.show()

第六章：性能优化与最佳实践

6.1 内存优化技巧

# 优化数据类型以减少内存使用
def optimize_memory(df):
    df_optimized = df.copy()
    
    for col in df_optimized.columns:
        col_type = df_optimized[col].dtype
        
        if col_type != object:
            c_min = df_optimized[col].min()
            c_max = df_optimized[col].max()
            
            if str(col_type)[:3] == 'int':
                if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
                    df_optimized[col] = df_optimized[col].astype(np.int8)
                elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
                    df_optimized[col] = df_optimized[col].astype(np.int16)
                elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
                    df_optimized[col] = df_optimized[col].astype(np.int32)
                elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:
                    df_optimized[col] = df_optimized[col].astype(np.int64)
            else:
                if c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
                    df_optimized[col] = df_optimized[col].astype(np.float32)
                else:
                    df_optimized[col] = df数据分析进阶课程：从基础到实战精通掌握核心技巧解决复杂数据难题提升职场竞争力

## 引言：为什么需要Python数据分析进阶技能？

在当今数据驱动的商业环境中，Python已经成为数据分析领域的标准工具。然而，仅仅掌握基础的pandas和matplotlib操作已经无法满足企业对高级数据分析师的需求。本课程将带你从基础走向精通，掌握解决复杂数据难题的核心技巧，显著提升你的职场竞争力。

### 学习目标
- 掌握高级数据处理技巧
- 理解复杂数据结构的处理方法
- 学会使用Python进行高效的数据清洗和转换
- 掌握高级可视化技巧
- 学会使用机器学习进行数据预测
- 能够独立完成端到端的数据分析项目

## 第一章：高级数据处理技巧

### 1.1 多层索引（MultiIndex）的高级操作

多层索引是处理高维数据的强大工具，特别适合处理时间序列数据和分组数据。

```python
import pandas as pd
import numpy as np

# 创建一个多层索引的DataFrame
arrays = [['A', 'A', 'B', 'B'], [1, 2, 1, 2]]
index = pd.MultiIndex.from_arrays(arrays, names=['first', 'second'])
df = pd.DataFrame({'value': [10, 20, 30, 40]}, index=index)

# 高级索引操作
print("原始数据：")
print(df)

# 使用xs进行跨层选择
print("\n使用xs选择第一层为A的数据：")
print(df.xs('A', level='first'))

# 使用swaplevel交换索引层级
print("\n交换索引层级后：")
print(df.swaplevel('first', 'second').sort_index())

输出结果：

原始数据：
              value
first second        
A     1           10
      2           20
B     1           30
      2           40

使用xs选择第一层为A的数据：
       value
second        
1         10
2         20

交换索引层级后：
              value
second first        
1      A         10
2      A         20
1      B         30
2      B         40

1.2 高效的分组聚合操作

掌握groupby的高级用法，包括自定义聚合函数和transform操作。

# 创建示例数据
np.random.seed(42)
df = pd.DataFrame({
    'category': np.random.choice(['A', 'B', 'C'], 100),
    'value': np.random.randn(100),
    'size': np.random.randint(1, 10, 100)
})

# 基础分组聚合
print("基础分组统计：")
print(df.groupby('category').agg({
    'value': ['mean', 'std', 'count'],
    'size': ['max', 'min']
}))

# 自定义聚合函数
def custom_agg(x):
    return pd.Series({
        'q75': x.quantile(0.75),
        'q25': x.quantile(0.25),
        'iqr': x.quantile(0.75) - x.quantile(0.25)
    })

print("\n使用自定义聚合函数：")
print(df.groupby('category')['value'].agg(custom_agg))

# transform操作：保持原始数据形状
df['value_category_mean'] = df.groupby('category')['value'].transform('mean')
print("\n添加类别均值列后的数据：")
print(df.head())

1.3 高效的合并与连接操作

处理多个数据源时，高效的合并操作至关重要。

# 创建两个示例DataFrame
df1 = pd.DataFrame({
    'key': ['A', 'B', 'C', 'D'],
    'value1': [1, 2, 3, 4]
})

df2 = pd.DataFrame({
    'key': ['B', 'D', 'E', 'F'],
    'value2': [5, 6, 7, 8]
})

# 不同的合并方式
print("内连接（inner join）：")
print(pd.merge(df1, df2, on='key', how='inner'))

print("\n左连接（left join）：")
print(pd.merge(df1, df2, on='key', how='left'))

print("\n外连接（outer join）：")
print(pd.merge(df1, df2, on='key', how='outer'))

# 处理重复键的情况
df3 = pd.DataFrame({
    'key': ['A', 'A', 'B', 'B'],
    'value': [1, 2, 3, 4]
})

df4 = pd.DataFrame({
    'key': ['A', 'B', 'B', 'C'],
    'value': [5, 6, 7, 8]
})

print("\n处理重复键的合并：")
print(pd.merge(df3, df4, on='key', how='inner', suffixes=('_left', '_right')))

第二章：复杂数据清洗与转换

2.1 高级缺失值处理

在实际业务中，缺失值的处理策略直接影响分析结果的准确性。

# 创建包含复杂缺失模式的数据
np.random.seed(42)
df = pd.DataFrame({
    'A': np.random.choice([1, 2, np.nan, 4], 100),
    'B': np.random.choice(['X', 'Y', None, 'Z'], 100),
    'C': np.random.randn(100)
})

# 高级缺失值检测
print("各列缺失值数量：")
print(df.isnull().sum())

print("\n缺失值模式分析：")
print(df.isnull().mean())

# 高级填充策略
# 1. 前向填充和后向填充
df_filled = df.copy()
df_filled['A_ffill'] = df_filled['A'].fillna(method='ffill')
df_filled['A_bfill'] = df_filled['A'].fillna(method='bfill')

# 2. 基于统计量的填充
df_filled['A_mean'] = df_filled['A'].fillna(df_filled['A'].mean())
df_filled['A_median'] = df_filled['A'].fillna(df_filled['A'].median())

# 3. 基于分组的填充
df_filled['A_group_mean'] = df_filled.groupby('B')['A'].transform(
    lambda x: x.fillna(x.mean())
)

print("\n不同填充策略的比较：")
print(df_filled[['A', 'A_ffill', 'A_mean', 'A_group_mean']].head(10))

2.2 复杂数据类型转换

处理日期、时间、分类数据等复杂类型。

# 日期时间处理
df = pd.DataFrame({
    'date_str': ['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04'],
    'value': [100, 102, 105, 108]
})

# 高级日期解析
df['date'] = pd.to_datetime(df['date_str'])
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day
df['weekday'] = df['date'].dt.weekday
df['is_weekend'] = df['date'].dt.weekday >= 5

# 时间序列重采样
df.set_index('date', inplace=True)
print("按周重采样：")
print(df.resample('W').mean())

# 分类数据处理
df_cat = pd.DataFrame({
    'grade': ['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B'],
    'score': [85, 72, 91, 88, 75, 94, 82, 78]
})

# 将字符串转换为分类类型
df_cat['grade_cat'] = df_cat['grade'].astype('category')
print("\n分类数据信息：")
print(df_cat['grade_cat'].describe())

# 自定义分类顺序
grade_order = pd.CategoricalDtype(categories=['C', 'B', 'A'], ordered=True)
df_cat['grade_ordered'] = df_cat['grade'].astype(grade_order)
print("\n有序分类数据：")
print(df_cat.sort_values('grade_ordered'))

2.3 高级字符串操作

使用向量化字符串操作和正则表达式进行复杂文本处理。

# 创建示例文本数据
df = pd.DataFrame({
    'product_code': ['A-123', 'B-456', 'C-789', 'D-012', 'E-345'],
    'description': ['Red Apple', 'Blue Berry', 'Green Grape', 'Yellow Banana', 'Orange Orange'],
    'price': [1.23, 2.45, 3.67, 4.89, 5.12]
})

# 向量化字符串操作
df['category'] = df['product_code'].str.split('-').str[0]
df['number'] = df['product_code'].str.split('-').str[1].astype(int)
df['color'] = df['description'].str.split(' ').str[0]
df['fruit'] = df['description'].str.split(' ').str[1]

# 正则表达式提取
df['code_prefix'] = df['product_code'].str.extract(r'^([A-Z])')
df['code_suffix'] = df['product_code'].str.extract(r'-(\d+)$')

# 字符串替换和清理
df['description_clean'] = df['description'].str.replace(r'\s+', ' ', regex=True).str.strip()

print("字符串处理结果：")
print(df)

# 高级文本分析
df['word_count'] = df['description'].str.split().str.len()
df['contains_color'] = df['description'].str.contains('Red|Blue|Green', case=False)

print("\n文本分析结果：")
print(df[['description', 'word_count', 'contains_color']])

第三章：高级可视化技巧

3.1 使用Seaborn进行高级统计可视化

Seaborn是基于matplotlib的高级可视化库，特别适合统计图表。

import seaborn as sns
import matplotlib.pyplot as plt

# 设置风格
sns.set_theme(style="whitegrid")

# 创建示例数据
np.random.seed(42)
data = pd.DataFrame({
    'category': np.random.choice(['A', 'B', 'C'], 200),
    'value': np.random.randn(200),
    'size': np.random.randint(1, 10, 200),
    'group': np.random.choice(['X', 'Y'], 200)
})

# 1. 分布可视化
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

# 小提琴图
sns.violinplot(data=data, x='category', y='value', ax=axes[0,0])
axes[0,0].set_title('Violin Plot')

# 箱线图
sns.boxplot(data=data, x='category', y='value', ax=axes[0,1])
axes[0,1].set_title('Box Plot')

# 点图
sns.pointplot(data=data, x='category', y='value', hue='group', ax=axes[1,0])
axes[1,0].set_title('Point Plot')

# 热力图
pivot_data = data.pivot_table(values='value', index='category', columns='group', aggfunc='mean')
sns.heatmap(pivot_data, annot=True, fmt=".2f", ax=axes[1,1])
axes[1,1].set_title('Heatmap')

plt.tight_layout()
plt.show()

# 2. 关系可视化
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# 散点图矩阵
sns.scatterplot(data=data, x='value', y='size', hue='category', style='group', ax=axes[0])
axes[0].set_title('Scatter Plot with Multiple Encodings')

# 回归图
sns.regplot(data=data, x='value', y='size', ax=axes[1])
axes[1].set_title('Regression Plot')

plt.tight_layout()
plt.show()

3.2 交互式可视化

使用Plotly创建交互式图表，适合在网页或报告中展示。

import plotly.express as px
import plotly.graph_objects as go

# 创建示例数据
np.random.seed(42)
df = pd.DataFrame({
    'x': np.random.randn(100),
    'y': np.random.randn(100),
    'size': np.random.randint(10, 100, 100),
    'category': np.random.choice(['A', 'B', 'C'], 100),
    'date': pd.date_range('2023-01-01', periods=100)
})

# 1. 交互式散点图
fig1 = px.scatter(df, x='x', y='y', color='category', size='size',
                 hover_data=['date'], title='Interactive Scatter Plot')
fig1.show()

# 2. 时间序列图
fig2 = px.line(df, x='date', y='y', color='category', title='Time Series Plot')
fig2.show()

# 3. 3D散点图
fig3 = px.scatter_3d(df, x='x', y='y', z='size', color='category',
                     title='3D Scatter Plot')
fig3.show()

# 4. 高级自定义图表
fig = go.Figure()

# 添加不同类别的散点
for cat in df['category'].unique():
    cat_data = df[df['category'] == cat]
    fig.add_trace(go.Scatter(
        x=cat_data['x'],
        y=cat_data['y'],
        mode='markers',
        name=f'Category {cat}',
        marker=dict(
            size=cat_data['size'],
            opacity=0.7
        ),
        hovertemplate='<b>Category: %{text}</b><br>X: %{x:.2f}<br>Y: %{y:.2f}<extra></extra>',
        text=cat_data['category']
    ))

fig.update_layout(
    title='Custom Interactive Scatter Plot',
    xaxis_title='X Value',
    yaxis_title='Y Value',
    hovermode='closest'
)

fig.show()

第四章：机器学习基础与数据预测

4.1 使用Scikit-learn进行回归预测

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.preprocessing import StandardScaler

# 创建示例数据集
np.random.seed(42)
X = np.random.randn(500, 5)
y = 2 * X[:, 0] + 3 * X[:, 1] - X[:, 2] + 0.5 * X[:, 3] + np.random.randn(500) * 0.1

# 数据分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 数据标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 线性回归模型
lr_model = LinearRegression()
lr_model.fit(X_train_scaled, y_train)
y_pred_lr = lr_model.predict(X_test_scaled)

# 随机森林模型
rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
rf_model.fit(X_train_scaled, y_train)
y_pred_rf = rf_model.predict(X_test_scaled)

# 模型评估
print("线性回归模型评估：")
print(f"均方误差: {mean_squared_error(y_test, y_pred_lr):.4f}")
print(f"R²分数: {r2_score(y_test, y_pred_lr):.4f}")

print("\n随机森林模型评估：")
print(f"均方误差: {mean_squared_error(y_test, y_pred_rf):.4f}")
print(f"R²分数: {r2_score(y_test, y_pred_rf):.4f}")

# 特征重要性分析
feature_importance = pd.DataFrame({
    'feature': [f'feature_{i}' for i in range(5)],
    'importance': rf_model.feature_importances_
}).sort_values('importance', ascending=False)

print("\n随机森林特征重要性：")
print(feature_importance)

4.2 分类任务与模型评估

from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix, roc_curve, auc
import matplotlib.pyplot as plt

# 创建分类数据集
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, 
                          n_redundant=2, random_state=42)

# 数据分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 逻辑回归模型
logreg = LogisticRegression(random_state=42)
logreg.fit(X_train, y_train)
y_pred = logreg.predict(X_test)
y_pred_proba = logreg.predict_proba(X_test)[:, 1]

# 模型评估
print("分类报告：")
print(classification_report(y_test, y_pred))

print("\n混淆矩阵：")
print(confusion_matrix(y_test, y_pred))

# ROC曲线
fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)
roc_auc = auc(fpr, tpr)

plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic (ROC) Curve')
plt.legend(loc="lower right")
plt.show()

4.3 模型保存与加载

import joblib

# 保存模型
joblib.dump(rf_model, 'random_forest_model.pkl')
joblib.dump(scaler, 'scaler.pkl')

# 加载模型
loaded_model = joblib.load('random_forest_model.pkl')
loaded_scaler = joblib.load('scaler.pkl')

# 使用加载的模型进行预测
new_data = np.random.randn(1, 5)
new_data_scaled = loaded_scaler.transform(new_data)
prediction = loaded_model.predict(new_data_scaled)

print(f"新数据预测结果: {prediction[0]:.4f}")

第五章：端到端数据分析项目实战

5.1 项目结构与工作流

一个完整的数据分析项目通常包括以下步骤：

1. 问题定义
2. 数据收集与加载
3. 数据探索与清洗
4. 特征工程
5. 模型构建与评估
6. 结果解释与报告

5.2 实战案例：销售预测分析

# 模拟销售数据
np.random.seed(42)
dates = pd.date_range('2020-01-01', '2023-12-31', freq='D')
n = len(dates)

sales_data = pd.DataFrame({
    'date': dates,
    'sales': np.random.normal(1000, 200, n) + 
             np.sin(np.arange(n) * 2 * np.pi / 365) * 200 +  # 季节性
             np.arange(n) * 0.1 +  # 趋势
             np.random.normal(0, 50, n),  # 噪声
    'temperature': np.random.normal(20, 10, n),
    'is_holiday': np.random.choice([0, 1], n, p=[0.97, 0.03])
})

# 特征工程
sales_data['month'] = sales_data['date'].dt.month
sales_data['day_of_week'] = sales_data['date'].dt.dayofweek
sales_data['is_weekend'] = (sales_data['day_of_week'] >= 5).astype(int)
sales_data['sales_lag_7'] = sales_data['sales'].shift(7)
sales_data['sales_rolling_mean_7'] = sales_data['sales'].rolling(7).mean()

# 处理缺失值
sales_data = sales_data.dropna()

# 准备特征和目标变量
feature_cols = ['temperature', 'is_holiday', 'month', 'day_of_week', 
                'is_weekend', 'sales_lag_7', 'sales_rolling_mean_7']
X = sales_data[feature_cols]
y = sales_data['sales']

# 数据分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 模型训练
model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 预测与评估
y_pred = model.predict(X_test)
print(f"销售预测模型性能：")
print(f"均方误差: {mean_squared_error(y_test, y_pred):.2f}")
print(f"R²分数: {r2_score(y_test, y_pred):.4f}")

# 特征重要性
importance = pd.DataFrame({
    'feature': feature_cols,
    'importance': model.feature_importances_
}).sort_values('importance', ascending=False)

print("\n特征重要性排序：")
print(importance)

# 可视化预测结果
plt.figure(figsize=(12, 6))
plt.scatter(y_test, y_pred, alpha=0.5)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
plt.xlabel('Actual Sales')
plt.ylabel('Predicted Sales')
plt.title('Actual vs Predicted Sales')
plt.show()

第六章：性能优化与最佳实践

6.1 内存优化技巧

# 优化数据类型以减少内存使用
def optimize_memory(df):
    df_optimized = df.copy()
    
    for col in df_optimized.columns:
        col_type = df_optimized[col].dtype
        
        if col_type != object:
            c_min = df_optimized[col].min()
            c_max = df_optimized[col].max()
            
            if str(col_type)[:3] == 'int':
                if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
                    df_optimized[col] = df_optimized[col].astype(np.int8)
                elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
                    df_optimized[col] = df_optimized[col].astype(np.int16)
                elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
                    df_optimized[col] = df_optimized[col].astype(np.int32)
                elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:
                    df_optimized[col] = df_optimized[col].astype(np.int64)
            else:
                if c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
                    df_optimized[col] = df_optimized[col].astype(np.float32)
                else:
                    df_optimized[col] = df_optimized[col].astype(np.float64)
        else:
            # 对于字符串列，转换为category类型如果唯一值较少
            num_unique_values = len(df_optimized[col].unique())
            num_total_values = len(df_optimized[col])
            if num_unique_values / num_total_values < 0.5:
                df_optimized[col] = df_optimized[col].astype('category')
    
    return df_optimized

# 示例：优化内存使用
sample_df = pd.DataFrame({
    'int_col': np.random.randint(0, 100, 10000),
    'float_col': np.random.randn(10000),
    'str_col': np.random.choice(['A', 'B', 'C'], 10000)
})

print("优化前内存使用：")
print(sample_df.memory_usage(deep=True))

optimized_df = optimize_memory(sample_df)

print("\n优化后内存使用：")
print(optimized_df.memory_usage(deep=True))

6.2 代码性能优化

import time
from functools import wraps

# 性能测试装饰器
def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end - start:.4f} seconds")
        return result
    return wrapper

# 比较不同方法的性能
@timer
def method_apply(df):
    return df.apply(lambda row: row['A'] + row['B'], axis=1)

@timer
def method_vectorized(df):
    return df['A'] + df['B']

# 创建测试数据
df_test = pd.DataFrame({
    'A': np.random.randn(100000),
    'B': np.random.randn(100000)
})

print("使用apply方法：")
result1 = method_apply(df_test)

print("\n使用向量化操作：")
result2 = method_vectorized(df_test)

# 验证结果相同
print(f"\n结果是否相同: {np.allclose(result1, result2)}")

6.3 并行处理

from joblib import Parallel, delayed
import multiprocessing

# 并行处理示例
def process_chunk(chunk):
    # 模拟耗时计算
    return chunk.apply(lambda x: x**2 + 2*x + 1)

@timer
def parallel_processing(df, n_jobs=-1):
    # 将数据分成多个块
    chunks = np.array_split(df, multiprocessing.cpu_count())
    
    # 并行处理
    results = Parallel(n_jobs=n_jobs)(delayed(process_chunk)(chunk) for chunk in chunks)
    
    # 合并结果
    return pd.concat(results, ignore_index=True)

@timer
def sequential_processing(df):
    return process_chunk(df)

# 测试并行处理
df_large = pd.DataFrame(np.random.randn(100000, 5), columns=[f'col_{i}' for i in range(5)])

print("顺序处理：")
result_seq = sequential_processing(df_large)

print("\n并行处理：")
result_par = parallel_processing(df_large)

print(f"\n结果是否相同: {result_seq.equals(result_par)}")

第七章：高级主题与前沿技术

7.1 时间序列分析

from statsmodels.tsa.seasonal import seasonal_decompose
from statsmodels.tsa.stattools import adfuller

# 创建时间序列数据
np.random.seed(42)
dates = pd.date_range('2020-01-01', periods=365, freq='D')
ts_data = pd.Series(
    np.random.normal(100, 10, 365) + 
    np.sin(np.arange(365) * 2 * np.pi / 365) * 20 +  # 季节性
    np.arange(365) * 0.1,  # 趋势
    index=dates
)

# 时间序列分解
decomposition = seasonal_decompose(ts_data, model='additive', period=30)

# 可视化分解结果
fig, axes = plt.subplots(4, 1, figsize=(12, 10))
decomposition.observed.plot(ax=axes[0], legend=False)
axes[0].set_title('Observed')
decomposition.trend.plot(ax=axes[1], legend=False)
axes[1].set_title('Trend')
decomposition.seasonal.plot(ax=axes[2], legend=False)
axes[2].set_title('Seasonal')
decomposition.resid.plot(ax=axes[3], legend=False)
axes[3].set_title('Residual')
plt.tight_layout()
plt.show()

# 平稳性检验
result = adfuller(ts_data)
print('ADF Statistic: %f' % result[0])
print('p-value: %f' % result[1])
print('Critical Values:')
for key, value in result[4].items():
    print('\t%s: %.3f' % (key, value))

7.2 文本分析与自然语言处理

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import LatentDirichletAllocation
import re

# 创建文本数据
texts = [
    "Python is a great programming language for data analysis",
    "Machine learning and AI are transforming industries",
    "Data scientists use Python and R for statistical analysis",
    "Deep learning requires large amounts of data",
    "Python libraries like pandas and numpy are essential",
    "Artificial intelligence will change our future",
    "Big data analytics is becoming increasingly important",
    "Python is easy to learn and powerful"
]

# 文本预处理
def preprocess_text(text):
    text = text.lower()
    text = re.sub(r'[^\w\s]', '', text)
    return text

processed_texts = [preprocess_text(t) for t in texts]

# TF-IDF向量化
vectorizer = TfidfVectorizer(max_features=100, stop_words='english')
X_tfidf = vectorizer.fit_transform(processed_texts)

# 主题建模（LDA）
lda = LatentDirichletAllocation(n_components=2, random_state=42)
lda.fit(X_tfidf)

# 显示主题
def display_topics(model, feature_names, no_top_words):
    for topic_idx, topic in enumerate(model.components_):
        print(f"Topic {topic_idx}:")
        print(" ".join([feature_names[i] for i in topic.argsort()[:-no_top_words - 1:-1]]))

print("主题建模结果：")
display_topics(lda, vectorizer.get_feature_names_out(), 5)

# 文本分类示例
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import make_pipeline

# 创建标签
labels = [0, 1, 0, 1, 0, 1, 1, 0]  # 0: 技术, 1: AI/未来

# 训练分类器
model_text = make_pipeline(TfidfVectorizer(), MultinomialNB())
model_text.fit(processed_texts, labels)

# 预测新文本
new_texts = ["Python is used for machine learning", "Future of artificial intelligence"]
predictions = model_text.predict(new_texts)
print(f"\n新文本预测: {predictions}")

7.3 数据库集成

import sqlite3
from sqlalchemy import create_engine

# 创建SQLite数据库
conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# 创建表
cursor.execute('''
CREATE TABLE IF NOT EXISTS sales (
    id INTEGER PRIMARY KEY,
    date TEXT,
    product TEXT,
    quantity INTEGER,
    price REAL
)
''')

# 插入数据
sample_data = [
    ('2023-01-01', 'Product A', 10, 19.99),
    ('2023-01-02', 'Product B', 5, 29.99),
    ('2023-01-03', 'Product A', 8, 19.99),
    ('2023-01-04', 'Product C', 12, 9.99)
]

cursor.executemany('INSERT INTO sales (date, product, quantity, price) VALUES (?, ?, ?, ?)', sample_data)
conn.commit()

# 查询数据
cursor.execute('SELECT * FROM sales')
rows = cursor.fetchall()

# 转换为DataFrame
df_db = pd.DataFrame(rows, columns=['id', 'date', 'product', 'quantity', 'price'])
print("从数据库读取的数据：")
print(df_db)

# 使用SQLAlchemy
engine = create_engine('sqlite:///example.db')
df_sqlalchemy = pd.read_sql('SELECT * FROM sales WHERE quantity > 5', engine)
print("\n使用SQLAlchemy查询：")
print(df_sqlalchemy)

# 将DataFrame写入数据库
df_new = pd.DataFrame({
    'date': ['2023-01-05', '2023-01-06'],
    'product': ['Product D', 'Product E'],
    'quantity': [15, 7],
    'price': [14.99, 39.99]
})

df_new.to_sql('new_sales', engine, if_exists='replace', index=False)
print("\nDataFrame已写入数据库")

# 关闭连接
conn.close()

第八章：职场竞争力提升指南

8.1 项目展示与作品集

# 创建一个完整的分析报告模板
def create_analysis_report(data, target_column, problem_type='regression'):
    """
    创建完整的数据分析报告
    """
    report = {}
    
    # 1. 数据概览
    report['data_shape'] = data.shape
    report['column_info'] = data.dtypes.to_dict()
    report['missing_values'] = data.isnull().sum().to_dict()
    
    # 2. 统计摘要
    report['statistics'] = data.describe().to_dict()
    
    # 3. 相关性分析
    if problem_type == 'regression':
        corr_matrix = data.corr()[target_column].sort_values(ascending=False)
        report['correlations'] = corr_matrix.to_dict()
    
    # 4. 模型性能
    if problem_type == 'regression':
        # 这里简化，实际应该有模型训练和评估
        report['model_type'] = 'RandomForestRegressor'
        report['metrics'] = {
            'r2_score': 0.85,
            'rmse': 12.34
        }
    
    return report

# 示例使用
sample_data = pd.DataFrame({
    'feature1': np.random.randn(100),
    'feature2': np.random.randn(100),
    'target': np.random.randn(100) + 0.5 * np.random.randn(100)
})

report = create_analysis_report(sample_data, 'target')
print("分析报告示例：")
for key, value in report.items():
    print(f"{key}: {value}")

8.2 代码规范与文档

"""
销售预测分析模块

本模块提供完整的销售数据分析和预测功能，包括：
- 数据加载和预处理
- 特征工程
- 模型训练和评估
- 预测结果可视化

作者: 数据分析师
版本: 1.0
日期: 2024-01-01
"""

import pandas as pd
import numpy as np
from typing import Dict, Any, Tuple
import matplotlib.pyplot as plt

class SalesPredictor:
    """
    销售预测器类
    
    使用随机森林算法进行销售预测，支持特征工程和模型评估。
    """
    
    def __init__(self, random_state: int = 42):
        """
        初始化预测器
        
        Parameters:
        -----------
        random_state : int
            随机种子，确保结果可重现
        """
        self.random_state = random_state
        self.model = None
        self.feature_importance = None
    
    def prepare_features(self, df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.Series]:
        """
        准备特征和目标变量
        
        Parameters:
        -----------
        df : pd.DataFrame
            包含原始数据的DataFrame
            
        Returns:
        --------
        X : pd.DataFrame
            特征矩阵
        y : pd.Series
            目标变量
        """
        # 特征工程
        df['month'] = df['date'].dt.month
        df['day_of_week'] = df['date'].dt.dayofweek
        df['is_weekend'] = (df['day_of_week'] >= 5).astype(int)
        
        # 滞后特征
        df['sales_lag_7'] = df['sales'].shift(7)
        df['sales_rolling_mean_7'] = df['sales'].rolling(7).mean()
        
        # 选择特征
        feature_cols = ['temperature', 'is_holiday', 'month', 'day_of_week', 
                       'is_weekend', 'sales_lag_7', 'sales_rolling_mean_7']
        
        # 处理缺失值
        df = df.dropna()
        
        X = df[feature_cols]
        y = df['sales']
        
        return X, y
    
    def train(self, X: pd.DataFrame, y: pd.Series) -> None:
        """
        训练模型
        
        Parameters:
        -----------
        X : pd.DataFrame
            特征矩阵
        y : pd.Series
            目标变量
        """
        from sklearn.ensemble import RandomForestRegressor
        from sklearn.model_selection import train_test_split
        
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, test_size=0.2, random_state=self.random_state
        )
        
        self.model = RandomForestRegressor(n_estimators=100, random_state=self.random_state)
        self.model.fit(X_train, y_train)
        
        # 计算特征重要性
        self.feature_importance = pd.DataFrame({
            'feature': X.columns,
            'importance': self.model.feature_importances_
        }).sort_values('importance', ascending=False)
        
        # 评估模型
        from sklearn.metrics import mean_squared_error, r2_score
        y_pred = self.model.predict(X_test)
        
        self.metrics = {
            'mse': mean_squared_error(y_test, y_pred),
            'r2': r2_score(y_test, y_pred)
        }
    
    def predict(self, X: pd.DataFrame) -> np.ndarray:
        """
        进行预测
        
        Parameters:
        -----------
        X : pd.DataFrame
            特征矩阵
            
        Returns:
        --------
        predictions : np.ndarray
            预测结果
        """
        if self.model is None:
            raise ValueError("模型尚未训练，请先调用train方法")
        
        return self.model.predict(X)
    
    def get_report(self) -> Dict[str, Any]:
        """
        生成分析报告
        
        Returns:
        --------
        report : Dict[str, Any]
            包含模型性能和特征重要性的报告
        """
        return {
            'model_metrics': self.metrics,
            'feature_importance': self.feature_importance.to_dict('records')
        }

# 使用示例
if __name__ == "__main__":
    # 创建示例数据
    np.random.seed(42)
    dates = pd.date_range('2020-01-01', periods=100, freq='D')
    df = pd.DataFrame({
        'date': dates,
        'sales': np.random.normal(1000, 100, 100),
        'temperature': np.random.normal(20, 5, 100),
        'is_holiday': np.random.choice([0, 1], 100, p=[0.95, 0.05])
    })
    
    # 使用预测器
    predictor = SalesPredictor()
    X, y = predictor.prepare_features(df)
    predictor.train(X, y)
    
    # 获取报告
    report = predictor.get_report()
    print("销售预测分析报告：")
    print(f"模型R²分数: {report['model_metrics']['r2']:.4f}")
    print("\n特征重要性：")
    for item in report['feature_importance']:
        print(f"  {item['feature']}: {item['importance']:.4f}")

结论：持续学习与职业发展

学习路径建议

1. 基础阶段：掌握pandas、numpy、matplotlib基础
2. 进阶阶段：学习高级数据处理、可视化、机器学习
3. 专家阶段：掌握性能优化、大数据处理、深度学习
4. 持续学习：关注行业动态，学习新技术

职业发展方向

• 数据分析师
• 数据科学家
• 机器学习工程师
• 商业智能分析师
• 数据架构师

推荐资源

• 官方文档：pandas, scikit-learn, matplotlib
• 在线课程：Coursera, edX, Udacity
• 社区：Stack Overflow, GitHub, Kaggle
• 书籍：《Python for Data Analysis》, 《Hands-On Machine Learning》

通过本课程的学习，你将具备解决复杂数据问题的能力，能够在职场中脱颖而出，成为企业急需的数据分析专家。记住，实践是最好的老师，多做项目，多总结经验，你的数据分析能力一定会不断提升！