numpy

参考速查更新于 2026-10-02编辑本文

轴：

axis=0，表示纵轴。

axis=1，表示横轴。

轴用来为超过一维的数组定义的属性，二维数据拥有两个轴：第 0 轴沿着行的垂直往下，第 1 轴沿着列的方向水平延伸。注意看，官方对于 0 和 1 的解释是轴，也就是坐标轴。而坐标轴是有方向的，所以千万不要用行和列的思维去想 axis，因为行和列是没有方向的，这样想会在遇到不同的例子时感到困惑。

根据官方的说法，1 表示横轴，方向从左到右；0 表示纵轴，方向从上到下。当 axis=1 时，数组的变化是横向的，而体现出来的是列的增加或者减少。

其实 axis 的重点在于方向，而不是行和列。具体到各种用法而言也是如此。当 axis=1 时，如果是求平均，那么是从左到右横向求平均；如果是拼接，那么也是左右横向拼接；如果是 drop，那么也是横向发生变化，体现为列的减少。

np.where(condition, x, y)  #满足条件(condition)，输出x，不满足输出y
np.where(condition)    #只有条件 (condition)，没有x和y，则输出满足条件 (即非0) 元素的坐标 。这里的坐标以tuple的形式给出，通常原数组有多少维，输出的tuple中就包含几个数组，分别对应符合条件元素的各维坐标。
size()    #函数主要是用来统计矩阵元素个数，或矩阵某一维上的元素个数的函数
numpy.size(a, axis=None)
#axis的值没有设定，返回矩阵的元素个数
#axis = 0，返回该二维矩阵的行数
#axis = 1，返回该二维矩阵的列数

random.randint(参数1，参数2)
#参数1、参数2必须是整数
#函数返回参数1和参数2之间的任意整数， 闭区间
#在需要生成随机数据的实验中，每次实验都需要生成数据。设置随机种子是为了确保每次生成固定的随机数，这就使得每次实验结果显示一致了，有利于实验的比较和改进。使得每次运行该 .py 文件时生成的随机数相同。


test = np.load('C:\Users\ABC\Desktop\test.npy')
np.save('F:/ObjectDatasetTools-master2/LINEMOD/thread33/transforms1.npy',t)

# 倒序排列
b = a[i:j]   表示复制a[i]到a[j-1]，以生成新的list对象
a = [0,1,2,3,4,5,6,7,8,9]
b = a[1:3]   # [1,2]
当i缺省时，默认为0，即 a[:3]相当于 a[0:3]
当j缺省时，默认为len(alist), 即a[1:]相当于a[1:10]
当i,j都缺省时，a[:]就相当于完整复制一份a

b = a[i:j:s]表示：i,j与上面的一样，但s表示步进，缺省为1.
所以a[i:j:1]相当于a[i:j]
当s<0时，i缺省时，默认为-1. j缺省时，默认为-len(a)-1
#s相当于step
所以a[::-1]相当于 a[-1:-len(a)-1:-1]，也就是从最后一个元素到第一个元素复制一遍，即倒序。


np.linalg.inv 是 numpy 中的一个函数，用于计算矩阵的逆矩阵。如果输入矩阵是奇异的，则该函数会引发 LinAlgError 异常。


np.savetxt('F:/ipy/datasets/thread33_0/sample_points_img.txt', sample_points_img, fmt='%d')


省略号（...）是 Python 中的一种语法，用于表示多维数组的高级索引。它可以代替一个或多个冒号（:），从而简化多维数组的索引语法。
a = np.zeros((2, 3, 4, 5))
b = a[..., 0]  # 取所有维度的所有索引，但只取最后一个维度中索引为 0 的元素
c = a[1, ..., 2]  # 等价于 a[1, :, :, 2]
print(b.shape)  # 输出 (2, 3, 4)
print(c.shape)  # 输出 (4, 5)

数据类型

# 数据类型字节大小
np.dtype().itemsize

创建数组

序号	函数名	描述	参数说明	示例代码及输出
1	array	创建一维或多维数组	-	`np.array([1,2,3,4,5])` `array([1, 2, 3, 4, 5])`
2	linspace	创建一个具有指定间隔的浮点数的数组	start:起始数字 end:结束 num:样本数，默认为50	`np.linspace(10,100,10)` `array([...])`
3	arange	在给定的间隔内返回具有一定步长的整数	start:起始数字 stop:结束 step:步长	`np.arange(5,10,2)` `array([5, 7, 9])`
4	random.uniform	在上下限之间的均匀分布中生成随机样本	low:下限 high:上限 size:输出数组的形状	`np.random.uniform(5,10,size=4)` `array([...])`
5	random.randint	在一个范围内生成 n 个随机整数样本	low:下限 high:上限 size:生成随机数的数量	`np.random.randint(5,10,10)` `array([...])`
6	random.random	生成 n 个随机浮点数样本	size:输出数组的形状	`np.random.random(3)` `array([...])`
7	logspace	在对数尺度上生成间隔均匀的数字	start:起始值 end:结束值 num:样本数 base:底数	`np.logspace(0,10,5,base=2)` `array([...])`
8	zeros	创建一个全部为 0 的数组	shape:数组形状 dtype:数据类型	`np.zeros((2,3),dtype='int')` `array([...])`
9	ones	创建一个全部为 1 的数组	shape:数组形状	`np.ones((3,4))` `array([...])`
10	full	创建一个单独值的 n 维数组	fill_value:填充值 shape:数组形状	`np.full((2,4),fill_value=2)` `array([...])`
11	identity	创建具有指定维度的单位矩阵	n:单位矩阵的维度	`np.identity(4)` `array([...])`

数组操作

序号	函数名	描述	参数说明	示例代码及输出
1	min	返回数组中的最小值。	axis:操作轴 out:存储输出的数组	`np.min(arr)` `1`
2	max	返回数组中的最大值。	-	`np.max(arr)` `6`
3	unique	返回一个所有唯一元素排序的数组。	return_index:返回索引 return_inverse:返回下标 return_counts:返回计数 axis:操作轴	`np.unique(arr, return_counts=True)` `(array([...]), array([...]))`
4	mean	返回数组的平均数。	-	`np.mean(arr, dtype='int')` `3`
5	median	返回数组的中位数。	-	`np.median(arr)` `3.5`
6	digitize	返回输入数组中每个值所属的容器的索引。	bins:容器数组 right:区间包含左右	`np.digitize(a, bins)` `array([...])`
7	reshape	返回一个数组，其中包含具有新形状的相同数据。	-	`a.reshape((3,4))` `array([...])`
8	expand_dims	用于扩展数组的维度。	axis:扩展的轴	`np.expand_dims(A, axis=0)` `array([...])`
9	squeeze	通过移除单一维度来降低数组的维度。	-	`np.squeeze(arr)` `array([...])`
10	count_nonzero	计算所有非零元素并返回它们的计数。	-	`np.count_nonzero(a)` `3`
11	argwhere	查找并返回非零元素的所有下标。	-	`np.argwhere(a)` `array([...])`
12	argmax & argmin	argmax:返回数组中最大元素的索引。 argmin:返回数组中最小元素的索引。	-	`np.argmax(arr)` `1` `np.argmin(min)` `3`
13	sort	对数组排序。	kind:排序算法	`np.sort(arr)` `array([...])`
14	abs	返回数组中元素的绝对值。	-	`np.abs(A)` `array([...])`
15	round	将浮点值四舍五入到指定数目的小数点。	decimals:保留的小数位数	`np.round(a, decimals=0)` `array([...])`
16	clip	将数组的值裁剪到一个范围内。	min:下限 max:上限	`arr.clip(0,5)` `array([...])`
17	`.transpose`	交换任意两个轴，也可以一次性重新排列所有轴。		transposed_arr = np.transpose(arr, (1, 0))
18	`.swapaxes`	交换数组的任意两个轴		swapped_arr = np.swapaxes(arr, 0, 1)

替换数组中的值

序号	函数名	功能描述	示例代码
1	`where`	返回满足条件的数组元素	`np.where(a>5)` 返回数组 `a` 中大于5的元素的索引
2	`put`	替换数组中指定的元素	`np.put(arr, [1,2], [6,7])` 将数组 `arr` 中索引为1和2的元素替换为6和7
3	`copyto`	将一个数组内容复制到另一个数组	`np.copyto(arr1, arr2)` 将 `arr2` 的内容复制到 `arr1`

集合操作

序号	函数名	功能描述	示例代码及输出
1	`intersect1d`	返回两个数组中所有唯一的公共元素	`np.intersect1d(ar1,ar2)` 输出：`array([1, 3, 4, 5])`
2	`setdiff1d`	返回数组1中数组2中不存在的所有唯一元素	`np.setdiff1d(a, b)` 输出：`array([1, 3, 4])`
3	`setxor1d`	返回两个数组中所有唯一的值	`np.setxor1d(a,b)` 输出：`array([ 2, 3, 6, 9, 36])`
4	`union1d`	将两个数组合并为一个	`np.union1d(a,b)` 输出：`array([ 1, 2, 3, 4, 5, 36])`

数组分割

序号	函数名	功能描述	示例代码及输出
1	`hsplit`	水平分割数组为n个相等的部分	`np.hsplit(A,2)` 输出：`[array([[3, 4],[6, 7]]), array([[5, 2],[2, 6]])]`
2	`hsplit`	水平分割数组为4个相等的部分	`np.hsplit(A,4)` 输出：`[array([[3],[6]]), array([[4],[7]]), array([[5],[2]]), array([[2],[6]])]`
3	`vsplit`	垂直分割数组为n个相等的部分	`np.vsplit(A,2)` 输出：`[array([[3, 4, 5, 2]]), array([[6, 7, 2, 6]])]`

数组叠加

序号	函数名	功能描述	示例代码及输出
1	`hstack`	水平叠加数组	`np.hstack((a,b))` 输出：`array([ 1, 2, 3, 4, 5, 1, 4, 9, 16, 25])`
2	`vstack`	垂直叠加数组	`np.vstack((a,b))` 输出：`array([[ 1, 2, 3, 4, 5], [ 1, 4, 9, 16, 25]])`

数组比较

序号	函数名	功能描述	示例代码及输出
1	`allclose`	检查两个数组是否近似相等	`np.allclose(a,b,tolerance)` 当 `tolerance=0.1` 时输出：`False`，当 `tolerance=0.5` 时输出：`True`
2	`equal`	比较两个数组的每个元素是否相等	`np.equal(arr1,arr2)` 输出：`array([ True, True, True, False, True, True])`

重复的数组元素

序号	函数名	功能描述	示例代码及输出
1	`repeat`	重复数组中的元素 n 次	`np.repeat('2017',3)` 输出：`array(['2017', '2017', '2017'], dtype='<U4')` # 使用 numpy.repeat 沿着新的第一个维度重复3次，形状变为 (3, 480, 480) expanded_arr = np.repeat(expanded_arr, 3, axis=0)
2	`repeat`	在 DataFrame 中添加重复的年份列	`fruits["year"] = np.repeat(2020, fruits.shape[0]);` 输出：DataFrame 包含新列 “year” 均为 2020
3	`tile`	构造数组，通过重复 A rep 次	`np.tile("Ram",5)` 输出：`array(['Ram', 'Ram', 'Ram', 'Ram', 'Ram'], dtype='<U3')`
4	`tile`	构造一个由重复元素 3 组成的 2x3 数组	`np.tile(3,(2,3))` 输出：`array([[3, 3, 3], [3, 3, 3]])`

爱因斯坦求和

序号	函数名	功能描述	示例代码及输出
1	`einsum`	计算对角线元素的和	`np.einsum('ii->i',a)` 输出：`array([1, 5, 9])`
2	`einsum`	按行索引排列元素	`np.einsum('ji',a)` 输出：`array([[1, 4, 7], [2, 5, 8], [3, 6, 9]])`
3	`einsum`	矩阵乘法（点积）	`np.einsum('ij,jk',a,b)` 输出：`array([[150, 156, 162], [366, 381, 396], [582, 606, 630]])`
4	`einsum`	计算所有元素的和	`np.einsum('ii',a)` 输出：`15`

统计分析

序号	函数名	功能描述	示例代码及输出
1	`histogram`	计算数据的直方图值	`np.histogram(A)` 输出：直方图数组和区间边界数组
2	`percentile`	计算数据的百分位数	`np.percentile(a, 50)` 输出：中位数 `5.0`
3	`percentile`	计算数据的10百分位数	`np.percentile(a, 10)` 输出：10百分位数 `3.0`
4	`percentile`	计算数据的5百分位数	`np.percentile(arr, 5)` 输出：5百分位数 `2.5`
5	`std`	计算标准偏差	`np.std(a, axis=1)` 输出：每一行的标准偏差
6	`std`	按列计算标准偏差	`np.std(a, axis=0)` 输出：每一列的标准偏差
7	`var`	计算方差	`np.var(a, axis=1)` 输出：每一行的方差
8	`var`	按列计算方差	`np.var(a, axis=0)` 输出：每一列的方差

数组打印

序号	功能描述	示例代码及输出
1	设置浮点数打印时的小数位数	`np.set_printoptions(precision=2)` 后 `print(a)` 输出：`array([12.23, 32.34])`
2	设置打印数组时的最大值	`np.set_printoptions(threshold=np.inf)`
3	设置打印时每行的元素数量	`np.set_printoptions(linewidth=100)` 默认是 75

保存和加载数据

序号	功能描述	示例代码及输出
1	保存数组到文本文件	`np.savetxt("array.txt", arr);` 将数组 `arr` 保存到 “array.txt” 文件中
2	从文本文件加载数组	`np.loadtxt("array.txt");` 从 “array.txt” 文件加载数组
3	从.npy文件加载数组	`np.load("data.npy", allow_pickle=True);` 加载 “data.npy” 文件中的数组，允许pickle序列化的对象

savedata = np.array(all_data, dtype=object)

常用

序号	功能描述	示例代码及输出
51	矩阵点乘	`arr1 @ arr2` 等价于 `np.dot(arr1, arr2)`
52	打乱数组元素顺序	`np.random.shuffle(a)` 将数组 `a` 中的元素顺序打乱
53	计算逻辑非	`np.logical_not(a)` 将布尔数组 `a` 中的每个元素取反
54	数据类型转换	`arr.astype(type)` 将数组 `arr` 转换为指定的数据类型 `type`
55	线性代数运算	`np.linalg.norm(vertex, axis=2, keepdims=True)` 计算向量的范数

拷贝

以下是将 NumPy 数组和列表创建副本的不同方式，以及它们是否改变内存中的位置和是否是深拷贝的表格形式：

方法	改变内存位置	是否深拷贝	备注
`arr[:]`	否	否	浅拷贝，共享数据缓冲区
`np.copy(arr)`	是	是	深拷贝，独立数据缓冲区
`arr.astype(arr.dtype)`	是	是	深拷贝，改变数据类型
`arr.view()`	否	否	浅拷贝，共享数据缓冲区
`np.array(arr)`	否（默认）	否（默认）	浅拷贝，可指定 `copy=True` 进行深拷贝
`[item for item in arr.tolist()]`	是	是	深拷贝，通过列表推导式
`np.copyto(dst, arr)`	是	是	深拷贝，使用内存复制函数
`arr + 0`	否	否	浅拷贝，数值操作

请注意，“改变内存位置” 指的是副本是否拥有一个独立的内存位置，与原始数据不共享。“是否深拷贝” 指的是副本的数据是否完全独立于原始数据，对副本的修改不会影响到原始数据。在某些情况下，例如使用 np.array() 而没有指定 copy=True，虽然创建了一个新的数组对象，但数据可能仍然是共享的，因此是浅拷贝。

方法

函数/方法	描述	代码示例
`np.array()`	创建一个`numpy`数组。	`arr = np.array([1, 2, 3])`
`np.zeros()`	创建一个给定形状和类型的全零数组。	`arr = np.zeros((3, 4))`
`np.ones()`	创建一个给定形状和类型的全一数组。	`arr = np.ones((2, 2))`
`np.arange()`	创建一个与Python的`range`类似的数组。	`arr = np.arange(10)`
`np.linspace()`	在指定的区间内创建一个均匀间隔的数组。	`arr = np.linspace(0, 1, 5)`
`np.random.rand()`	创建一个给定形状的随机数组，值在[0, 1)之间。	`arr = np.random.rand(2, 2)`
`np.random.randn()`	创建一个标准正态分布的随机数组。	`arr = np.random.randn(3, 3)`
`np.eye()`	创建一个给定大小的恒等矩阵或单位矩阵。	`arr = np.eye(4)`
`np.reshape()`	改变数组的形状而不改变其数据。	`arr = np.array([1, 2, 3, 4]).reshape(2, 2)`
`np.transpose()`	转置数组。	`arr = np.array([[1, 2], [3, 4]]).transpose()`
`np.dot()`	矩阵乘法。	`arr1 = np.array([1, 2]); arr2 = np.array([3, 4]); result = np.dot(arr1, arr2)`
`np.sum()`	计算数组元素的总和。	`arr = np.array([1, 2, 3]); result = np.sum(arr)`
`np.mean()`	计算数组元素的平均值。	`arr = np.array([1, 2, 3]); result = np.mean(arr)`
`np.std()`	计算数组元素的标准差。	`arr = np.array([1, 2, 3]); result = np.std(arr)`
`np.var()`	计算数组元素的方差。	`arr = np.array([1, 2, 3]); result = np.var(arr)`
`np.min()`	找出数组中的最小值。	`arr = np.array([1, 2, 3]); result = np.min(arr)`
`np.max()`	找出数组中的最大值。	`arr = np.array([1, 2, 3]); result = np.max(arr)`
`np.argmin()`	返回数组中最小元素的索引。	`arr = np.array([3, 1, 2]); result = np.argmin(arr)`
`np.argmax()`	返回数组中最大元素的索引。	`arr = np.array([3, 1, 2]); result = np.argmax(arr)`
`np.where()`	Return elements chosen from `x` or `y` depending on `condition`.	`arr = np.array([1, 2, 3]); result = np.where(arr > 1, 0, 1)`
`np.all()`	如果数组中的所有元素都为真，则返回`True`。	`arr = np.array([True, True, True]); result = np.all(arr)`
`np.any()`	如果数组中至少有一个元素为真，则返回`True`。	`arr = np.array([False, True, False]); result = np.any(arr)`
`np.isnan()`	返回一个布尔数组，表示原数组中的元素是否为`NaN`。	`arr = np.array([np.nan, 1, 2]); result = np.isnan(arr)`
np.count_nozero(arr)	判断数组非零元素个数
np.nonzero()	返回一个元组，其中包含输入数组中非零元素的索引。
np.flatten()	数组展平成一维数组。

（1）判断元素

import numpy as np

# 创建一个数组
arr = np.array([1, 2, np.nan, 4])

# 使用numpy的isnan函数来检查数组中的元素是否为NaN
if np.isnan(arr).all():
    print("数组中的所有元素都是NaN")
else:
    print("数组中不是所有元素都是NaN")

import numpy as np

# 创建一个包含多个np.array的元组
tuple_of_arrays = (
    np.array([1, 2, 3]),
    np.array([4, 5, 6]),
    np.array([7, 8, 9])
)

# 检查每个数组是否都不含有NaN
none_contain_nan = all(np.isnan(arr).all() == False for arr in tuple_of_arrays)

print(none_contain_nan)  # 如果所有数组都不含有NaN，将输出True，否则输出False

错题

import numpy as np
a = np.repeat(np.arange(5).reshape([1,-1]),10,axis = 0)+10.0
b = np.random.randint(5, size= a.shape)
c = np.argmin(a*b, axis=1)
b = np.zeros(a.shape)
b[np.arange(b.shape[0]), c] = 1
print(b)