第3-4周：数据处理基础

核心工具：

• NumPy: 科学计算、矩阵运算（AI基础）
• Pandas: 数据分析、表格处理

关键技能：

• 向量化运算（替代for循环）
• DataFrame筛选和分组
• 数据清洗（空值处理）
• CSV读写

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
NumPy和Pandas基础 - AI数据处理必备
目标：掌握科学计算和数据分析核心工具
"""

import numpy as np
import pandas as pd

# =============================================================================
# 第一部分：NumPy - Python的科学计算库
# 对标：C语言的数组运算，但功能强大100倍
# =============================================================================

print("="*60)
print("NumPy基础")
print("="*60)

# 1. 创建数组 - 比C的malloc+初始化简洁太多
# C: int *arr = (int*)malloc(5 * sizeof(int));
arr1 = np.array([1, 2, 3, 4, 5])
arr2 = np.zeros(5)           # [0., 0., 0., 0., 0.]
arr3 = np.ones((3, 3))       # 3x3的全1矩阵
arr4 = np.arange(0, 10, 2)   # [0, 2, 4, 6, 8]
arr5 = np.linspace(0, 1, 5)  # [0., 0.25, 0.5, 0.75, 1.]

print(f"arr1: {arr1}")
print(f"3x3矩阵:\n{arr3}")

# 2. 数组属性 - C语言需要手动计算
print(f"\n数组维度: {arr3.ndim}")      # 2
print(f"数组形状: {arr3.shape}")       # (3, 3)
print(f"元素总数: {arr3.size}")        # 9
print(f"数据类型: {arr3.dtype}")       # float64

# 3. 向量化运算 - 无需写for循环（C语言需要循环）
# C: for(i=0; i<n; i++) c[i] = a[i] + b[i];
a = np.array([1, 2, 3, 4, 5])
b = np.array([10, 20, 30, 40, 50])

print(f"\n向量加法: {a + b}")          # [11, 22, 33, 44, 55]
print(f"向量乘法: {a * b}")          # [10, 40, 90, 160, 250]
print(f"标量乘法: {a * 2}")          # [2, 4, 6, 8, 10]
print(f"平方: {a ** 2}")              # [1, 4, 9, 16, 25]
print(f"开方: {np.sqrt(a)}")          # [1., 1.414, ...]

# 4. 矩阵运算 - AI核心（神经网络就是矩阵运算）
matrix_a = np.array([[1, 2], [3, 4]])
matrix_b = np.array([[5, 6], [7, 8]])

print(f"\n矩阵A:\n{matrix_a}")
print(f"\n矩阵B:\n{matrix_b}")
print(f"\n矩阵乘法:\n{np.dot(matrix_a, matrix_b)}")
print(f"转置:\n{matrix_a.T}")
print(f"逆矩阵:\n{np.linalg.inv(matrix_a)}")
print(f"行列式: {np.linalg.det(matrix_a)}")

# 5. 切片和索引 - 比C灵活太多
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(f"\n原矩阵:\n{matrix}")
print(f"第一行: {matrix[0]}")         # [1, 2, 3]
print(f"第二列: {matrix[:, 1]}")     # [2, 5, 8]
print(f"子矩阵:\n{matrix[0:2, 1:3]}")  # [[2,3],[5,6]]

# 6. 广播机制 - 不同形状数组自动对齐
# C语言需要手动处理，NumPy自动完成
arr2d = np.array([[1, 2, 3], [4, 5, 6]])
row_vec = np.array([10, 20, 30])
print(f"\n广播相加:\n{arr2d + row_vec}")

# 7. 统计运算 - AI数据分析必备
print(f"\n求和: {a.sum()}")
print(f"均值: {a.mean()}")
print(f"标准差: {a.std()}")
print(f"最大值: {a.max()}")
print(f"最小值: {a.min()}")
print(f"最大索引: {a.argmax()}")

# =============================================================================
# 第二部分：Pandas - 数据处理和分析神器
# 对标：Excel + SQL + 编程的完美结合
# =============================================================================

print("\n" + "="*60)
print("Pandas基础")
print("="*60)

# 1. Series - 一维带标签数组（类似C的结构体数组）
s = pd.Series([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])
print(f"\nSeries:\n{s}")
print(f"索引'a'的值: {s['a']}")

# 2. DataFrame - 二维表格数据（AI数据集的标准格式）
# 类似于C的结构体数组，但功能强大得多
data = {
    '姓名': ['张三', '李四', '王五', '赵六'],
    '年龄': [25, 30, 35, 28],
    '城市': ['北京', '上海', '深圳', '杭州'],
    '薪资': [15000, 20000, 25000, 18000],
    '是否工程师': [True, True, False, True]
}

df = pd.DataFrame(data)
print(f"\nDataFrame:\n{df}")

# 3. 数据查看 - 比C的printf强大太多
print(f"\n前3行:\n{df.head(3)}")
print(f"\n数据形状: {df.shape}")  # (4, 5) - 4行5列
print(f"\n列名: {df.columns.tolist()}")
print(f"\n数据类型:\n{df.dtypes}")
print(f"\n统计摘要:\n{df.describe()}")

# 4. 数据选择 - 比C的数组索引灵活
print(f"\n选择'姓名'列:\n{df['姓名']}")
print(f"\n选择多列:\n{df[['姓名', '薪资']]}")
print(f"\n选择第2行:\n{df.iloc[1]}")  # 按位置
print(f"\n选择年龄>30的行:\n{df[df['年龄'] > 30]}")  # 条件筛选

# 5. 条件筛选 - SQL的WHERE语句等价物
engineers = df[(df['是否工程师'] == True) & (df['薪资'] > 15000)]
print(f"\n高薪工程师:\n{engineers}")

# 6. 数据清洗 - AI数据预处理必备
df_with_nan = pd.DataFrame({
    'A': [1, 2, np.nan, 4],
    'B': [5, np.nan, np.nan, 8],
    'C': [9, 10, 11, 12]
})

print(f"\n含空值数据:\n{df_with_nan}")
print(f"\n检查空值:\n{df_with_nan.isnull()}")
print(f"\n删除含空值的行:\n{df_with_nan.dropna()}")
print(f"\n填充空值:\n{df_with_nan.fillna(0)}")
print(f"\n填充为列均值:\n{df_with_nan.fillna(df_with_nan.mean())}")

# 7. 数据转换 - AI特征工程核心
print(f"\n薪资增加10%:\n{df['薪资'] * 1.1}")
df['薪资等级'] = df['薪资'].apply(lambda x: '高' if x > 20000 else '中' if x > 15000 else '低')
print(f"\n添加薪资等级列:\n{df}")

# 8. 分组聚合 - SQL的GROUP BY等价物
print(f"\n按城市分组统计:\n{df.groupby('是否工程师')['薪资'].agg(['mean', 'count', 'max'])}")

# 9. 数据合并 - SQL的JOIN等价物
df1 = pd.DataFrame({'员工ID': [1, 2, 3], '姓名': ['张三', '李四', '王五']})
df2 = pd.DataFrame({'员工ID': [1, 2, 3], '部门': ['技术', '产品', '销售']})

merged = pd.merge(df1, df2, on='员工ID')
print(f"\n合并后的数据:\n{merged}")

# 10. 时间序列 - AI时序预测基础
dates = pd.date_range('2024-01-01', periods=7, freq='D')
time_series = pd.Series([100, 102, 105, 103, 108, 110, 112], index=dates)
print(f"\n时间序列:\n{time_series}")
print(f"\n移动平均:\n{time_series.rolling(window=3).mean()}")

# =============================================================================
# 第三部分：实践项目 - C语言日志分析器重写
# =============================================================================

print("\n" + "="*60)
print("实践项目：CSV日志分析器")
print("="*60)

# 创建示例日志数据
log_data = {
    'timestamp': pd.date_range('2024-01-01', periods=1000, freq='h'),
    'level': np.random.choice(['INFO', 'WARNING', 'ERROR', 'DEBUG'], 1000),
    'module': np.random.choice(['network', 'database', 'auth', 'api'], 1000),
    'message': ['Log message ' + str(i) for i in range(1000)],
    'response_time': np.random.exponential(100, 1000)  # 指数分布模拟响应时间
}

logs_df = pd.DataFrame(log_data)

# 保存为CSV（模拟日志文件）
logs_df.to_csv('sample_logs.csv', index=False, encoding='utf-8-sig')
print(f"\n生成日志文件: sample_logs.csv (1000条记录)")

# 读取并分析
logs = pd.read_csv('sample_logs.csv')
print(f"\n日志统计:")
print(f"总记录数: {len(logs)}")
print(f"\n日志级别分布:\n{logs['level'].value_counts()}")
print(f"\n模块分布:\n{logs['module'].value_counts()}")
print(f"\n响应时间统计:\n{logs['response_time'].describe()}")

# 筛选慢查询（响应时间>200ms）
slow_queries = logs[logs['response_time'] > 200]
print(f"\n慢查询数量: {len(slow_queries)}")

# 按模块分析平均响应时间
print(f"\n模块平均响应时间:\n{logs.groupby('module')['response_time'].mean().sort_values(ascending=False)}")

# =============================================================================
# 第四部分：AI数据处理常用模式
# =============================================================================

print("\n" + "="*60)
print("AI数据处理常用模式")
print("="*60)

# 1. 特征归一化（机器学习预处理）
features = np.array([[1, 200], [2, 300], [3, 400], [4, 500]])
# Min-Max归一化
normalized = (features - features.min(axis=0)) / (features.max(axis=0) - features.min(axis=0))
print(f"\n原始特征:\n{features}")
print(f"\n归一化后:\n{normalized}")

# 2. 数据分批（训练神经网络时）
data = np.arange(1000)
batch_size = 32
num_batches = len(data) // batch_size

for i in range(3):  # 只显示前3个batch
    batch = data[i*batch_size : (i+1)*batch_size]
    print(f"Batch {i}: {batch[:5]}... (共{len(batch)}个)")

# 3. 数据洗牌（随机打乱训练数据）
np.random.seed(42)
shuffled_indices = np.random.permutation(len(data))
print(f"\n洗牌后的索引前10个: {shuffled_indices[:10]}")

# =============================================================================
# 学习检查点
# =============================================================================

print("\n" + "="*60)
print("第3-4周学习检查清单：")
print("="*60)
checklist = [
    "创建NumPy数组并理解其属性",
    "掌握NumPy的向量化运算（无需for循环）",
    "理解矩阵运算（dot, transpose, inverse）",
    "创建Pandas DataFrame和Series",
    "掌握数据选择（索引、切片、条件筛选）",
    "会进行数据清洗（处理空值、重复值）",
    "掌握分组聚合（groupby）",
    "会读取和保存CSV文件",
    "理解数据合并（merge, join）"
]
for i, item in enumerate(checklist, 1):
    print(f"{i}. [ ] {item}")

print("\n实践项目建议：")
print("1. 分析你自己的工作日志或项目数据")
print("2. 处理一个Kaggle入门数据集（如Titanic）")
print("3. 用Pandas重写你之前的C语言数据分析工具")
在这里插入代码片

1. 转置 (Transpose)

转置就是把矩阵的行变成列，列变成行。

原矩阵 (2行3列):        转置后 (3行2列):
┌           ┐          ┌     ┐
│ 1  2  3  │          │ 1  4│
│ 4  5  6  │   →      │ 2  5│
└           ┘          │ 3  6│
                       └     ┘

import numpy as np

matrix = np.array([[1, 2, 3], 
                   [4, 5, 6]])
print(matrix.T)  
# [[1 4]
#  [2 5]
#  [3 6]]

实际用途：

• 神经网络中调整数据形状（比如把 (1000, 784) 的图片转置成 (784, 1000)）
• 矩阵乘法要求维度匹配时的维度调整

2. 点乘 (Dot Product / 矩阵乘法)

点乘不是对应元素相乘，而是"行×列"的规则运算。

矩阵A (2×3)   ×   矩阵B (3×2)   =   结果 (2×2)

┌         ┐     ┌       ┐     ┌              ┐
│1  2  3 │     │1  4│     │1×1+2×2+3×3  1×4+2×5+3×6│
│4  5  6 │  ×  │2  5│  =  │4×1+5×2+6×3  4×4+5×5+6×6│
└         ┘     │3  6│     └              ┘
                └       ┘
              =  ┌        ┐
                 │14   32│
                 │32   77│
                 └        ┘

A = np.array([[1, 2, 3], 
              [4, 5, 6]])      # 形状 (2, 3)
B = np.array([[1, 4], 
              [2, 5], 
              [3, 6]])         # 形状 (3, 2)

result = np.dot(A, B)  # 或 A @ B
# [[14 32]
#  [32 77]]

关键规则：

• A 的形状 (m, n) × B 的形状 (n, p) = 结果 (m, p)
• 中间维度必须相同：A 的列数 = B 的行数

实际用途：

• 神经网络的前向传播（每层都是矩阵点乘）
• 图像变换（旋转、缩放）
• 求解线性方程组

对比：* 和 np.dot 的区别

A = np.array([[1, 2], 
              [3, 4]])

# * 是逐元素相乘 (Hadamard积)
A * A     # [[1 4]     1×1, 2×2
          #  [9 16]]   3×3, 4×4

# np.dot 是矩阵乘法
np.dot(A, A)  # [[ 7 10]    行×列
              #  [15 22]]

简单记忆：

• * → 对应位置相乘（形状不变）
• np.dot / @ → 行列相乘再相加（形状会变）
  实践项目：
  分析CSV日志文件，生成统计报告