numpy 用法大全

按功能分类的字典。每个函数列常用参数和一个能跑的例。 基础概念在入门那课。所有代码假定 import numpy as np。

一、创建数组

np.array

参数作用
object列表、元组、嵌套列表
dtype指定类型
copy是否复制(默认 True)
ndmin最少几维
np.array([1, 2, 3])
np.array([[1, 2], [3, 4]])
np.array([1, 2], dtype=float)
np.array([1, 2], ndmin=2)        # shape (1, 2)

np.asarray(x)      # 已经是数组就不复制
np.asanyarray(x)   # 同上,但保留 ndarray 子类

按规则生成

函数参数例
zeros(shape, dtype)形状、类型np.zeros((2,3))
ones(shape)同上np.ones(5)
full(shape, fill_value)填充值np.full((2,2), 7)
eye(N, M, k)k 是偏移(1=上移)np.eye(3, k=1)
identity(n)单位矩阵np.identity(3)
arange(start, stop, step, dtype)步长,不含终点np.arange(0,10,2)
linspace(start, stop, num, endpoint)endpoint=False 可排除终点np.linspace(0,1,5)
logspace(start, stop, num, base)base 默认 10np.logspace(0,3,4)
geomspace(start, stop, num)等比(直接给起止值)np.geomspace(1,1000,4)
zeros_like(a)同形状同类型也有 ones_like / full_like / empty_like
empty(shape)不初始化(快但值是随机的)np.empty((3,3))
np.arange(0, 10, 2)          # [0 2 4 6 8],不含 10
np.linspace(0, 1, 5)         # [0 .25 .5 .75 1],含终点
np.linspace(0, 1, 5, endpoint=False)  # 不含终点
np.logspace(0, 3, 4)         # [1 10 100 1000]
np.geomspace(1, 1000, 4)     # [1 10 100 1000]
arange 的坑

用浮点步长时 arange 可能因为精度问题多给或少给一个元素。

np.arange(0, 1, 0.1) 有时长度是 10,有时是 11。

需要确定个数就用 linspace。

网格

x = np.arange(3); y = np.arange(2)
X, Y = np.meshgrid(x, y)     # X 形状 (2,3)
# X = [[0,1,2],[0,1,2]]   Y = [[0,0,0],[1,1,1]]

# 三维
X, Y, Z = np.meshgrid(x, y, z, indexing="ij")

二、随机数

新写法统一用 rng = np.random.default_rng(seed),之后所有方法都挂在 rng 上。

方法参数例
random(size)[0,1) 均匀rng.random(5)
uniform(low, high, size)区间均匀rng.uniform(1, 10, 5)
normal(loc, scale, size)均值、标准差rng.normal(0, 1, 5)
integers(low, high, size)整数,不含 highrng.integers(0, 10, 5)
choice(a, size, replace, p)p 是概率权重rng.choice([1,2,3], 5, p=[.5,.3,.2])
permutation(x)打乱后返回新数组rng.permutation(10)
shuffle(x)原地打乱rng.shuffle(arr)
binomial(n, p, size)二项分布rng.binomial(10, .5, 100)
poisson(lam, size)泊松rng.poisson(3, 100)
multivariate_normal(mean, cov, size)多元正态rng.multivariate_normal([0,0], [[1,.5],[.5,1]], 100)
rng = np.random.default_rng(42)     # 固定种子,可复现

rng.random(5)
rng.normal(0, 1, (3, 4))          # 直接给多维形状
rng.integers(0, 10, 5)
rng.choice([1,2,3], 5, replace=False)   # 不重复抽

# 打乱数据(训练集洗牌常用)
idx = rng.permutation(len(X))
X, y = X[idx], y[idx]
别再用 np.random.seed()

旧的 np.random.* 是全局状态,多个函数互相干扰时会出问题。

新代码统一 default_rng。

三、属性与类型

属性含义例(3×4 数组)
shape各维长度(3, 4)
ndim维数2
size元素总数12
dtype元素类型int64
itemsize每元素字节数8
nbytes总字节96
T转置变成 4×3
base指向的原数组(是视图时)None 表示独立
flags内存布局标志C_CONTIGUOUS

dtype 一览

类型说明字节
int8/16/32/64有符号整数1/2/4/8
uint8..64无符号整数1/2/4/8
float16/32/64浮点(32 常用在深度学习)2/4/8
complex64/128复数8/16
bool布尔1
object任意 Python 对象(慢)8
str_ / <U10定长字符串——

astype 参数

a.astype(float)              # 基本转换(复制一份)
a.astype(np.int32)           # 指定具体类型
a.astype("category")         # pandas 才有
a.astype(int, copy=False)    # 类型相同就不复制
整数转换是截断,不是四舍五入

np.array([3.7]).astype(int) 得到 3,不是 4。

要四舍五入先 np.round()。

四、索引与选取

基本索引

a[0]          # 第 0 行(降一维)
a[0, 1]       # 第 0 行第 1 列
a[:, 0]       # 所有行第 0 列
a[1:3]        # 第 1、2 行
a[::2]        # 隔一个取一个
a[::-1]       # 反转
a[..., 0]     # 省略号代表"前面所有维"
a[None]       # 加一个新维

布尔索引

a[a > 5]                 # → 一维数组
a[(a > 2) & (a < 8)]       # 与:&,一定要加括号
a[~(a > 5)]                # 非:~
(a > 5).sum()              # 数有几个
np.count_nonzero(a > 5)    # 同上

花式索引

a[[0, 2]]                 # 取第 0、2 行
a[[0, 1], [1, 2]]          # 取 (0,1) 和 (1,2) 两个位置
a[np.ix_([0,2], [1,3])]    # 取子矩阵(行 0,2 × 列 1,3)

按条件取值

函数参数作用
where(cond, x, y)三参数 = 三元运算满足取 x,否则 y
where(cond)单参数返回满足的下标
clip(a, min, max)上下界截断
take(a, indices)索引数组按索引取
put(a, indices, v)索引、值按索引写(原地)
select(condlist, choicelist, default)条件列表多条件选择
np.where(a > 5, 1, 0)          # 三元
np.where(a > 5)                # (array([...]),) 下标
np.clip(a, 0, 10)              # 截断到 [0,10]
np.take(a, [0, 2])
np.select([a < 3, a > 7], [0, 9], default=5)

五、形状操作

函数参数是否复制
reshape(shape, order)-1 表示自动推否,视图
ravel(order)拉平否(可能)
flatten(order)拉平是
transpose(axes) / .T轴顺序否
swapaxes(i, j)交换两维否
moveaxis(a, src, dst)移动某一维否
expand_dims(a, axis)插入长度 1 的维否
squeeze(a, axis)去掉长度 1 的维否
broadcast_to(a, shape)广播成目标形状否,只读
a = np.arange(12)
a.reshape(3, 4)
a.reshape(2, -1)        # -1 自动算成 6
a.reshape(3, 4, order="F")   # 列优先

a[:, None]              # 一维 → 列向量,等价 expand_dims(a, 1)
a[np.newaxis, :]        # 一维 → 行向量

b = a.reshape(3,4)
b.T.shape               # (4,3)
np.moveaxis(b, 0, 1).shape   # 同转置
reshape 的 -1

只能有一个 -1,其他维必须能整除。

12 个元素可以 reshape 成 (3,4)、(2,6)、(2,2,3),不能 (5,-1)。

六、合并与拆分

concatenate

参数作用
arrays序列(元组或列表)
axis沿哪一维拼(默认 0)
out输出到已有数组
np.concatenate([a, b])            # 沿 axis=0
np.concatenate([a, b], axis=1)     # 沿 axis=1

np.vstack([a, b])      # 垂直堆(按行)
np.hstack([a, b])      # 水平堆(按列)
np.dstack([a, b])      # 沿第三维

stack vs concatenate

函数输入形状输出形状
concatenate两个 (3,)(6,) 维数不变
stack两个 (3,)(2, 3) 维数 +1
np.stack([a, b], axis=0)       # (2, 3)
np.stack([a, b], axis=1)       # (3, 2)

拆分

np.split(a, 3)               # 等分成 3 份
np.split(a, [2, 5])            # 在索引 2、5 处切
np.array_split(a, 3)           # 不能整除也能切
np.hsplit(a, 2) / np.vsplit(a, 2)

重复与补边

函数作用例
tile(a, reps)整块重复np.tile([1,2], 3) → [1,2,1,2,1,2]
repeat(a, n, axis)每个元素重复np.repeat([1,2], 3) → [1,1,1,2,2,2]
pad(a, width, mode)补边np.pad(a, 1, "constant", constant_values=0)
np.tile([1, 2], 3)      # [1 2 1 2 1 2]
np.repeat([1, 2], 3)     # [1 1 1 2 2 2]
np.pad([1,2,3], 1)       # [0 1 2 3 0]
np.pad(a, 1, mode="edge")     # 用边缘值补
np.pad(a, 1, mode="reflect")  # 镜像

七、数学运算

逐元素运算

a + b, a - b, a * b, a / b       # 都是逐元素
a ** 2, a % 3, a // 2                # 幂、取余、整除
-a, np.abs(a)                        # 取负、绝对值

a + 10                               # 标量广播
a + np.array([1,2,3,4])              # 一维广播

通用函数 ufunc

类别函数
幂与根sqrt cbrt power exp expm1
对数log(自然)log2 log10 log1p
三角sin cos tan arcsin arctan2
双曲sinh cosh tanh
取整round floor ceil trunc rint
符号sign absolute
极值maximum minimum fmax fmin
其他mod remainder hypot degrees radians
np.sqrt(a)
np.exp(a)
np.log(a)            # 有 0 会得到 -inf,有负数得到 nan
np.log1p(a)          # log(1+a),a 很小时更精确
np.round(a, 2)       # 保留 2 位
np.maximum(a, 0)     # 等价 ReLU
log1p 和 expm1 存在的原因

log(1+x) 在 x 很接近 0 时,1+x 会丢掉精度。

log1p(x) 内部直接算,精度高得多。同理 expm1(x) = exp(x) - 1。

矩阵乘法

写法行为
A * B逐元素相乘
A @ B矩阵乘法(推荐)
np.matmul(A, B)同上
np.dot(A, B)二维时同 matmul,一维是内积,高维行为不同
np.inner(A, B)沿最后一维内积
np.outer(a, b)外积
np.einsum(...)爱因斯坦求和,万能
A @ B                       # 矩阵乘
A * B                       # 逐元素(形状要相容)

np.dot([1,2], [3,4])        # 1*3 + 2*4 = 11(内积)
np.outer([1,2], [3,4])      # [[3,4],[6,8]]

# 批量矩阵乘
np.einsum("ij,jk->ik", A, B)
* 和 @ 是最常见的 bug

想算矩阵乘却写了 *,如果两个矩阵形状恰好一样,不会报错,结果全错。

看到奇怪的数值,先检查这里。

八、统计聚合

所有聚合函数都支持三个参数:

参数含义
axis沿哪一维压(None = 全部)
keepdims保留被压的那一维为长度 1
where只统计满足条件的
函数作用例
sum求和a.sum(axis=0)
mean / average平均 / 加权平均np.average(a, weights=w)
median中位数np.median(a)
std / var标准差 / 方差a.std(ddof=1) 样本标准差
min / max最值a.min()
argmin / argmax最值下标a.argmax()
prod连乘a.prod()
cumsum / cumprod累加 / 累乘a.cumsum()
percentile分位数np.percentile(a, 75)
quantile分位数(0~1)np.quantile(a, .75)
all / any全真 / 存在真(a > 0).all()
count_nonzero非零个数np.count_nonzero(a)
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]     每行
a.sum(axis=1, keepdims=True)   # 形状 (3,1),便于广播

np.average(a, axis=0, weights=[1,2,3])   # 加权平均

(a > 5).sum()        # 数个数
axis 的唯一记法

axis=k 表示“把第 k 维压掉”。

(3,4) 沿 axis=0 → (4,);沿 axis=1 → (3,)。

别记“行还是列”,三维就乱了。

九、比较与逻辑

函数作用例
> < >= <= == !=逐元素比较a > 5
& | ~与、或、非(a>2) & (a<8)
array_equal完全相等np.array_equal(a,b)
allclose浮点近似相等np.allclose(a, b, rtol=1e-5)
isclose逐元素近似np.isclose(a, b)
logical_and/or/not逻辑运算np.logical_and(a>1, a<5)
isfinite/isnan/isinf数值检查np.isnan(a)
a > 5                    # 布尔数组
(a > 2) & (a < 8)          # 一定要括号
~np.isnan(a)               # 非 NaN

np.allclose(0.1+0.2, 0.3)  # True(近似)
0.1 + 0.2 == 0.3           # False(精确)

十、排序与查找

函数参数作用
sort(a, axis, kind)kind 选算法返回排好序的新数组
a.sort()无原地排序
argsort(a, axis)—返回排序后的下标
partition(a, kth)kth 位置第 k 小的放到位,前面更小后面更大
argpartition(a, kth)—上面那个的下标版本
searchsorted(a, v)side="left"/"right"v 该插在哪(要求 a 已排序)
unique(a, return_counts, return_index)各种 return去重并排序
nonzero(a)—非零元素下标
argmax / argminaxis最值下标
b = np.array([3, 1, 2])
np.sort(b)            # [1 2 3],b 不变
b.sort()              # b 变成 [1 2 3]
b.argsort()           # [1 2 0]

# 间接排序(按某列排整个表)
order = data[:, 1].argsort()
data[order]

np.unique([3,1,2,1], return_counts=True)
# (array([1,2,3]), array([2,1,1]))

np.searchsorted([1,3,5], 4)   # 2(该插在索引 2)

十一、线性代数

函数作用例
A @ B矩阵乘A @ B
linalg.inv(A)求逆np.linalg.inv(A)
linalg.pinv(A)伪逆不可逆时用
linalg.det(A)行列式np.linalg.det(A)
linalg.solve(A, b)解 Ax=b比 inv 快且稳
linalg.lstsq(A, b)最小二乘超定方程
linalg.eig(A)特征值/向量一般矩阵
linalg.eigh(A)对称矩阵特征分解更快更稳
linalg.svd(A)奇异值分解U, S, Vt = np.linalg.svd(A)
linalg.qr(A)QR 分解—
linalg.cholesky(A)Cholesky 分解正定矩阵
linalg.norm(a, ord)范数ord=1/2/np.inf
trace(A)迹对角线和
linalg.matrix_rank(A)秩—
x = np.linalg.solve(A, b)         # 解方程,不要用 inv
np.linalg.norm(a)                  # L2 范数
np.linalg.norm(a, ord=1)           # L1
U, S, Vt = np.linalg.svd(A)        # 降维/PCA 的基础
np.trace(A)
解方程别用 inv

inv(A) @ b 数学上对,但数值不稳、还慢一倍。

用 solve(A, b)。

十二、文件读写

二进制(快,保留类型)

函数作用例
save(file, a)存单个 → .npynp.save("a.npy", a)
load(file)读 .npy/.npznp.load("a.npy")
savez(file, **kw)存多个(不压缩)np.savez("ab.npz", a=a, b=b)
savez_compressed存多个(压缩)同上
tofile / fromfile裸二进制,无表头要自己记形状和类型
np.save("a.npy", a)
np.load("a.npy")

np.savez("ab.npz", a=a, b=b)
d = np.load("ab.npz")
d["a"], d["b"]

文本(通用,慢)

函数关键参数
savetxtdelimiter、fmt、header、comments
loadtxtdelimiter、skiprows、usecols、dtype
genfromtxt同上 + missing_values、filling_values(能处理缺失)
np.savetxt("a.csv", a, delimiter=",", fmt="%.2f")
np.loadtxt("a.csv", delimiter=",")
np.genfromtxt("a.csv", delimiter=",", skip_header=1,
              missing_values="NA", filling_values=0)

十三、广播规则

两条数组形状不同时,numpy 按这套规则决定能不能算:

  1. 如果维数不同,在较小的形状前面补 1
  2. 从最后一维开始往前比,每一维必须满足:相等、或其中一个是 1
  3. 不满足就报错;满足的话,长度为 1 的那一维被“复制”到另一边的长度
(3, 4) + (4,)      # → (3,4),一维被当成 (1,4)
(3, 1) + (1, 4)     # → (3,4)
(5, 3, 1) + (3, 4)  # → (5,3,4)

(3,) + (4,)         # 报错:3 和 4 不相等,也没 1
常见用法:给每行减均值
X = np.random.default_rng(0).random((5, 3))
X - X.mean(axis=0)          # (5,3) - (3,) → 广播,每列减自己的均值
X - X.mean(axis=1)[:, None] # (5,3) - (5,1) → 每行减自己的均值

忘写 [:, None] 会变成 (5,3) - (5,),报错。

十四、性能与内存

视图 vs 拷贝

操作返回
切片 a[1:3]视图,改了影响原数组
reshape / .T / ravel视图
布尔索引 a[a>0]拷贝
花式索引 a[[0,2]]拷贝
astype() / flatten()拷贝
# 判断是否共享内存
np.shares_memory(a, b)     # True/False
a.base is None             # True 表示独立数据

加速手段

做法效果
向量化代替 for 循环快 10~100 倍
原地运算 a += 1不新建数组,省内存
先分配 np.empty 再填避免反复扩容
用 float32 代替 float64内存减半
np.dot / BLAS底层是多线程优化的
避免 np.append 在循环里它每次都重新分配

十五、常见坑

坑正确做法
and/or/not 作用在数组用 & | ~,并加括号
== 比较浮点np.allclose
改切片以为不影响原数组要独立数据用 .copy()
* 当矩阵乘用 @
整数相除以为得整数/ 得 float,整除用 //
axis 记成行/列记“哪一维被压掉”
循环里 np.append先收集到 list,最后 np.array
np.arange 浮点步长少一个用 linspace
整数数组转 float 精度丢失先 astype(float) 再算
数组很大时内存爆用 np.memmap 或分块
np.append 的陷阱

numpy 数组大小固定,np.append 每次都会新建数组并复制全部旧数据。

循环里用一万次就是 O(n²)。

正确做法:先放进 Python list,最后一次性 np.array(list)。

十六、一页速查

创建   array zeros ones full eye arange(step) linspace(num) logspace geomspace
       zeros_like empty meshgrid
随机   default_rng random uniform normal integers choice permutation shuffle
属性   shape ndim size dtype itemsize nbytes T base
类型   int8-64 uint8-64 float16/32/64 bool complex; astype(copy)
索引   a[i] a[:,j] a[a>5] a[[0,2]] where clip take put select ix_
形状   reshape(-1) ravel flatten transpose swapaxes expand_dims squeeze broadcast_to
合并   concatenate(axis) stack(axis,+1维) vstack hstack dstack split array_split
       tile repeat pad
运算   + - * / ** @  sqrt exp log log1p round floor ceil maximum
线代   linalg.solve inv det eig eigh svd qr norm(p) trace matrix_rank
统计   sum mean average median std(ddof) var min max argmin argmax prod
       cumsum cumprod percentile quantile all any count_nonzero
       → 通用参数 axis keepdims where
比较   & | ~ allclose isclose isnan isfinite logical_and
排序   sort argsort partition argpartition searchsorted unique nonzero nlargest
读写   save load savez savez_compressed savetxt loadtxt genfromtxt memmap
广播   末尾对齐,每维相等或为 1