numpy 入门

它是干什么的

Python 自带的列表能装东西,但算起来慢。

它装的是“指向对象的指针”,不是数字本身。每次算两个元素,都要先顺着指针找到对象、判断类型、再运算。

numpy 换了个存法:一块连续的内存,装同一类型的数据。类型固定,所以能直接对内存做运算, 还能一次算一整片(向量化)。

实测,100 万个整数乘 2 再求和:

做法耗时
Python 列表推导0.137 秒
numpy 数组0.0054 秒

快 25 倍。而且代码还更短。

一句话概括

numpy 把“循环”从 Python 层搬到了 C 层。

你写 a * 2,看起来没有循环,其实底下有一个——只不过那个循环是编译好的 C 代码在跑, 比 Python 解释器快一两个数量级。

导入约定

import numpy as np

全世界的 numpy 代码都用 np 这个别名。跟着用就行,别自创。

核心对象:ndarray

numpy 里只有一个数据结构值得学,叫 ndarray(N 维数组)。

它由两部分组成:

  • 数据本身:一块连续内存,全是同一种类型
  • 元信息:形状(shape)、类型(dtype)、步长(strides)

关键理解:形状不是数据的属性,是“怎么看这块内存”的方式。 同一个数组可以看成 3 行 4 列,也可以看成 2 行 6 列——数据没动,只是读法变了。

创建

最常用的四种:

np.array([1, 2, 3])          # 从 Python 列表
np.zeros((2, 3))           # 全 0,指定形状
np.arange(0, 10, 2)        # 等差:0 2 4 6 8
np.linspace(0, 1, 5)       # 等分:0 0.25 0.5 0.75 1
arange 和 linspace 的区别

arange 你给的是步长(差多少),终点可能取不到。

linspace 你给的是个数(切几份),终点一定包含在内。

画函数图像时用 linspace,因为你要的是“在这段区间均匀取 N 个点”。

看形状

a = np.arange(12).reshape(3, 4)
a.shape    # (3, 4)
a.ndim     # 2
a.size     # 12
a.dtype    # dtype('int64')

reshape 不复制数据,只是换一种读法——12 个数还是那 12 个数。

索引

和 Python 列表几乎一样,但多了几个能力:

a[0]        # 第一行
a[0, 1]     # 第一行第二列(也可以写 a[0][1])
a[:, 0]     # 所有行的第一列
a[1:, :2]   # 第二行起,前两列

更有用的是布尔索引:

a[a > 5]    # 取出所有大于 5 的元素,返回一维数组

这一行等价于循环 + if,但快得多。数据清洗里到处都是它。

切片是视图,不是拷贝

这是 numpy 最容易踩的坑:

v = np.arange(5)     # [0 1 2 3 4]
s = v[1:4]
s[0] = 99
print(v)             # [ 0 99  2  3  4]  ← 原数组也变了
为什么这样设计

因为快。切 100 万行数据,如果每次都复制,内存和时间都受不了。

想真正复制一份,用 .copy()。

判断标准:切片、reshape、转置都返回视图;花式索引、布尔索引返回拷贝。

运算:逐元素

这是 numpy 和列表最大的区别:

a = np.array([1, 2, 3])
a + 10      # [11 12 13]
a * 2       # [2 4 6]
a ** 2      # [1 4 9]
a + a       # [2 4 6]

列表的 + 是拼接,numpy 的 + 是逐个相加。这是两套语义。

没有循环,但等价于循环

a * 2 不是“把数组看成一个整体乘 2”,是“每个元素都乘 2”。

这个叫向量化。写代码时脑子里要想着“对每个元素做什么”,手上写的是整体操作。

广播:形状不同也能算

如果形状不一样呢?

a = np.ones((3, 4))
b = np.array([1, 2, 3, 4])
a + b        # b 被"复制"成 3 行,逐行相加

numpy 会把 b(形状 4)自动扩展成 (3, 4) 参与运算。这叫广播。

但不是什么形状都能广播:

np.ones(3) + np.ones(4)
# ValueError: operands could not be broadcast together with shapes (3,) (4,)
广播规则(只记这一条)

从最后一维开始往前比,每一维要么相等,要么其中一个是 1,要么其中一个不存在。

(3, 1) 和 (1, 4):最后一维 1 vs 4 → 可广播成 4;倒数第二维 3 vs 1 → 可广播成 3。结果 (3, 4)。

(3,) 和 (4,):最后一维 3 vs 4,既不相等也没有 1 → 报错。

沿轴聚合

最常见的困惑是 axis 参数:

a = np.arange(12).reshape(3, 4)
a.sum()          # 66          全部加起来
a.sum(axis=0)    # [12 15 18 21]  每列的和
a.sum(axis=1)    # [ 6 22 38]     每行的和
记住这句话就不会错

axis=0 是把第 0 维“压掉”。

a 的形状是 (3, 4)。axis=0 压掉第 0 维的 3,剩下 (4,)—— 所以结果是 4 个数,也就是每列的和。

别记“行还是列”,记“哪一维消失了”。这样三维、四维也不会搞错。

常用的几个

函数做什么
np.mean(a)平均
np.std(a)标准差
np.min / np.max最小 / 最大
np.argmax(a)最大值在第几个位置
np.sort(a)排序
np.unique(a)去重
np.dot(A, B) 或 A @ B矩阵乘法(不是逐元素!)
np.linalg.inv(A)求逆

一个完整的小例子

用 numpy 算一组数据的标准化(也就是第 3 章的 StandardScaler):

x = np.array([2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0])

z = (x - x.mean()) / x.std()
# [-1.5 -0.5 -0.5 -0.5  0.   0.   1.   1.5]

三行代码,没有循环。这就是 numpy 的写法:把公式直接翻译成代码。

学 numpy 的正确姿势

第一课只讲“它是什么、怎么用”。真正的函数细节在第二课的用法大全里,当字典查。

不要试图背下来。知道有这么个东西、知道去哪查就够了。