AI基石 | Python工具链(二)：NumPy与Pandas —— 拒绝循环，像数学家一样操作矩阵

NumPy向量化运算加速计算，Pandas处理真实数据，共同构建AI数据流水线。

ipython_harley

720人浏览 · 2026-01-07 08:00:00

ipython_harley · 2026-01-07 08:00:00 发布

AI基石 | Python工具链(二)：NumPy与Pandas —— 拒绝循环，像数学家一样操作矩阵

前言

上一篇我们用 Python 原生的 List 模拟了矩阵。虽然逻辑通顺，但它有两个致命缺点：

慢：Python 的 List 存储的是对象的引用，每次计算都要解包、类型检查，效率极低。
繁：两个矩阵相乘，你需要写 3 层嵌套 for 循环。

NumPy (Numerical Python) 的出现，就是为了解决这个问题。它底层由 C 语言编写，内存连续，计算并行。 Pandas 则是建立在 NumPy 之上的“Excel”，专门用来处理那些脏乱差的真实世界数据。

这一篇，我们要完成从a“程序员”到“数据科学家”的身份切换。

一、 NumPy：矩阵运算的“引擎”

NumPy 是所有深度学习框架（PyTorch/TensorFlow）的鼻祖。学好 NumPy，你对“维度（Dimension）”和“轴（Axis）”的理解将瞬间通透。

1. 核心对象：ndarray (N-dimensional Array)

List 什么都能装，ndarray 只能装数字，但它极其纯粹、整齐。

import numpy as np

# 普通列表 vs NumPy 数组
py_list = [1, 2, 3]
np_arr = np.array([1, 2, 3])

# 差异 1：内存布局
# List: 散落在内存各处
# NumPy: 紧凑的连续内存块 (C-contiguous)

2. 向量化运算 (Vectorization) —— 告别 For 循环

这是 AI 代码最显著的特征。能用矩阵操作的，绝不写循环。

场景：给 100 万个数字都加上 1。

普通写法 (慢)：

data = [i for i in range(1000000)]
# 就要跑 100 万次 CPU 指令
new_data = [x + 1 for x in data]

NumPy 写法 (快)：

data = np.arange(1000000)
# 只有 1 条指令，底层 C 语言并行处理
new_data = data + 1

效率对比：NumPy 通常快 50~100 倍。

3. 广播机制 (Broadcasting) —— NumPy 的魔法

这是新手最容易晕、但也最强大的功能。当两个形状不同的矩阵进行计算时，NumPy 会自动把“小”的那个“拉伸”成和“大”的一样，然后再计算。

场景：给所有学生的英语、数学、语文成绩（3列）分别加上 5分、10分、0分。

# 成绩表 (3个学生，3门课) -> Shape: (3, 3)
scores = np.array([
    [80, 90, 85],
    [70, 75, 80],
    [60, 60, 60]
])

# 加分项 (1行，3门课) -> Shape: (1, 3)
bonus = np.array([5, 10, 0])

# 魔法发生：(3,3) + (1,3)
# NumPy 会自动把 bonus 向下复制 3 次，变成 (3,3) 再相加
final_scores = scores + bonus

print(final_scores)
# 结果：
# [[ 85 100  85]
#  [ 75  85  80]
#  [ 65  70  60]]

4. 矩阵乘法：点积 (Dot Product)

还记得第一篇《线性代数》里的矩阵乘法吗？这是神经网络最核心的计算。

import numpy as np

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

# 对应位置相乘 (Element-wise product)
print(A * B)
print('***********')

# 真正的矩阵乘法 (Dot product) -> 也就是神经网络的全连接层运算
print(np.dot(A, B))
print('***********')
# 或者用现代写法 @ 符号
print(A @ B)
print('***********')

# [[ 5 12]
#  [21 32]]
# ***********
# [[19 22]
#  [43 50]]
# ***********
# [[19 22]
#  [43 50]]
# ***********

二、 Pandas：代码版的“Excel”

现实世界的数据不是干净的矩阵，而是充满了缺失值、字符串和乱码的 CSV 文件。Pandas 就是用来干这个脏活的。

1. 核心对象：DataFrame

你可以把 DataFrame 想象成一张永远不会卡顿的 Excel 表。它有行索引（Index）和列名（Columns）。

2. 数据的“查、改、增、删”

AI 工程师的数据处理流程通常是：读取 -> 筛选 -> 填补 -> 转换。

import pandas as pd
import numpy as np

# 1. 读取数据 (支持 csv, excel, sql, json...)
# 假设我们有一个房价数据
data = {
    '面积': [100, 150, np.nan, 80],  # np.nan 代表缺失值
    '价格': [500, 750, 600, 400],
    '城市': ['北京', '上海', '北京', '深圳']
}
df = pd.DataFrame(data)

# 2. 查：筛选数据
# 只要“北京”的房子
beijing_df = df[df['城市'] == '北京']

# 3. 改：处理缺失值
# 发现“面积”有空值，我们用平均值填充
mean_area = df['面积'].mean()
df['面积'] = df['面积'].fillna(mean_area)

# 4. 增：特征工程
# 计算“单价”
df['单价'] = df['价格'] / df['面积']

print(df)

#     面积   价格  城市     单价
# 0  100.0  500  北京  5.000000
# 1  150.0  750  上海  5.000000
# 2  110.0  600  北京  5.454545
# 3   80.0  400  深圳  5.000000

3. 神奇的 iloc 与 loc

这是 Pandas 面试必考题，也是取数据的核心。

loc：根据**标签（名字）**取数据。df.loc[0, '价格']
iloc：根据**位置（坐标）**取数据。df.iloc[0, 1]

三、实战：从 Pandas 到 NumPy 的流水线

在实际的 AI 项目（比如 Kaggle 比赛）中，这两个库是这样配合的：

用 Pandas 读取和清洗数据（因为 Pandas 能处理字符串、空值）。
将清洗好的数据转换为 NumPy 矩阵（因为模型只认数字矩阵）。
喂给模型训练。

实战案例：准备一份喂给神经网络的数据

import numpy as np
import pandas as pd

# --- 第一阶段：Pandas 清洗 ---
# 模拟一份原始数据
raw_data = pd.DataFrame({
    'Feat1': [1.0, 2.0, np.nan, 4.0],
    'Feat2': [10, 20, 30, 40],
    'Label': [0, 1, 0, 1]
})

print("原始数据:\n", raw_data)

# 原始数据:
#     Feat1  Feat2  Label
# 0    1.0     10      0
# 1    2.0     20      1
# 2    NaN     30      0
# 3    4.0     40      1

# 1. 填补缺失值
raw_data = raw_data.fillna(raw_data.mean())

# 2. 分离特征(X)和标签(y)
# drop用于删除列，values属性将DataFrame转换为NumPy数组
X_df = raw_data.drop('Label', axis=1)
y_df = raw_data['Label']

# --- 第二阶段：NumPy 转换与归一化 ---
# 转换为矩阵
X = X_df.values  # 变成了 np.array
y = y_df.values

# 归一化 (Normalization)：把数据压缩到 0~1 之间
# 公式：(x - min) / (max - min)
# 这一步利用了 NumPy 的广播机制！
X_norm = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

print("\n清洗并归一化后的矩阵 (喂给AI的):")
print(X_norm)
print("\nShape:", X_norm.shape)

# 清洗并归一化后的矩阵 (喂给AI的):
# [[0.         0.        ]
#  [0.33333333 0.33333333]
#  [0.44444444 0.66666667]
#  [1.         1.        ]]
# 
# Shape: (4, 2)