NumPy

一.认识NumPy

NumPy是Python数据科学领域最基础的第三方库，其核心是多维数组对象(ndarray)。它不仅运算极其高效，还具备强大的“广播(Broadcasting)”机制，能够让不同形状的数组直接进行数学运算。

导入 NumPy 时，通常给其一个别名“np”，即 import numpy as np。

NumPy库中的函数，要在函数名前加上导入的库名 np. 才能使用。

二.ndarray

1. ndarray定义

Numpy的核心是对象类型是ndarray，也就是我们常说的多维数组。

  • 数组也是有序可变序列，可以对其进行索引。

  • 数组要求所有其内所有元素都是同一类型。当输入是不同类型时，数组就会对其进行转化。

  • 常将numpy.ndarray类型简称为Array类型

2. ndarray属性

ndarray的四个最基本属性(调用时不加括号)：

(1).ndim

ndim：返回数组的维度数(如一维、二维)(int)。

示例：

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
a.ndim   # 结果为 2
(2).shape

shape：返回数组的形状，如 (2, 3) 表示 2行3列(tuple)。

示例：

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
a.shape  # 结果为 (2, 3)
(3).size

size：返回数组中包含的元素总个数(int)。

示例：

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
a.size   # 结果为 6
(4).dtype

dtype：返回数组内部元素的数据类型(dtype)。

示例：

import numpy as np
a = np.array([1, 2, 3])
a.dtype  # 结果为 int64(具体取决于平台)

三.ndarray的类型及转化方法

1. ndarray的类型

数据类型 描述
bool_ 布尔(True或False)，存储为一个字节
int_ 默认整数类型(通常为int64或int32)
intc 与C int(通常为int32或int64)相同
intp 用于索引的整数(与C ssize_t相同；通常为int32或int64)
int8 字节(-128到127)
int16 整数(-32768到32767)
int32 整数(-2147483648至2147483647)
int64 整数(-9223372036854775808至9223372036854775807)
uint8 无符号整数(0到255)
uint16 无符号整数(0到65535)
uint32 无符号整数(0至4294967295)
uint64 无符号整数(0至18446744073709551615)
float_ float64的简写。
float16 半精度浮点：符号位，5位指数，10位尾数
float32 单精度浮点：符号位，8位指数，23位尾数
float64 双精度浮点：符号位，11位指数，52位尾数
complex_ complex128的简写。
complex64 复数，由两个32位浮点(实数和虚数分量)
complex128 复数，由两个64位浮点(实数和虚数分量)

当然，在实际使用过程中，我们用到的还是数值类型较多。这里不要求记住全部类型，但需要知道的是NumPy中自动执行的转化规则，以及如何手动设置array类型。

2. 类型转化规则

当array进行不同元素类型转化的时候，一般遵循"尽可能保留更多有效信息"的原则进行转化。常见的转化过程如下：

# 整型转浮点型
np.array([1, 1.1])
# 结果：array([1. , 1.1])

# 数值型转字符串
np.array([1, 1.1, '1'])
# 结果：array(['1', '1.1', '1'], dtype='<U32')

注：虽然array能够在创建的过程中自动转化对象类型，但使用需谨慎，避免经常出现输入对象和输出对象不一致的情况。

3. 强制类型转换(dtype参数)

在array方法中使用dtype参数，强制Array输出某一类型对象。

a = np.array([1, 1.1], dtype='int')   # dtype参数
# 结果：array([1, 1])

b = np.array([1, 2, 0], dtype='bool')   # 0输出False，其他输出True
# 结果：array([ True,  True, False])

c = np.array([1, '2'], dtype='uint8')
# 结果：array([1, 2], dtype=uint8)

# 并非所有转换都能执行
np.array(['g', 'q'], dtype='int')
# 报错：ValueError: invalid literal for int()

4. 已有数组类型转换(astype()方法)

针对已经创建好的Array进行类型转化，返回转换好的Array，但不改变原对象，使用astype()方法转换数组类型。

a = np.array([1, 1]) 
newa = a.astype(np.float64)
# a：array([1, 1])
# newa：array([1., 1.])

b = array([True, True, False])
newb = b.astype(np.int)
# newb：array([1, 1, 0]) 相比原始的b，损失了部分信息

5. 转换为list(tolist()方法)

由于Array和list是比较相似的对象，常使用tolist()方法将array转化为list。

a.tolist()
# 结果：[1, 1]

四.数组的索引、切片与视图

除了基础的下标索引，NumPy可以用类似矩阵的行列标索引

对于二维array，可以用逗号来区分是对行还是对列进行索引，并且行、列的索引都遵循python一般索引规则。

多维数组的索引和二维数组类似，只是需要增加一个维度，即增加一个“逗号”。

a = np.array([[1, 2], [3, 4]])
a[1, 1] # 类似矩阵的行列标索引
# 4
a[1, :]
# array([3, 4])

NumPy的索引机制有两大重要特性：

  • 花式索引： 可以通过布尔条件判断(如 x[x > 3])或传入索引数组来批量提取特定的元素，这在数据过滤中极其常用。
  • 视图与深拷贝： NumPy 数组的切片返回的是原数组的视图(View)，即两者共享同一块内存，对切片的任何赋值修改都会直接改变原数组。如果需要生成完全独立的副本，必须显式调用 .copy() 方法。

补充：

  • 多维Array的每一行也是一个Array类型

    arr = np.array([(1,2,3),[4,5,6]])
print(type(arr[0])) #<class 'numpy.ndarray'>

五.数组创建,修改方法

1. array - 创建数组

作用：将列表、元组等可迭代对象转换为 NumPy 数组 (ndarray)。注：NumPy 数组要求内部所有元素的数据类型必须完全一致，如果输入不同类型，NumPy 会自动向更兼容的类型(如浮点、字符串)转化！

np.array(object, dtype=None)

参数：

  • 对象 (object)： 需要转换为数组的列表、元组等可迭代对象(Iterable)。

    注：

    1. 创建多维数组时，每一行长度必须一样，否则报错。

      arr1 = np.array([[1,2,3],[5,6,0]]) #正确
arr2 = np.array([[1,2,3],[5,6]]) #错误

    2. 二维数组的创建不受输入序列类型的影响。

      arr = np.array([(5,6,7,8,9),[4,3,2,1,0]])
# arr1:array([[5, 6, 7, 8, 9],[4, 3, 2, 1, 0]])

    3. 创建n维数组，用n-1维数组创建

      l1 = [[1, 2], [3, 4]]
l2 = [[5, 6], [7, 8]]
a3 = np.array([l1, l2])
# array([[[1, 2],
#         [3, 4]],
#        [[5, 6],
#         [7, 8]]])

  • 数据类型 (dtype)： 可选参数，强制指定数组元素的数据类型(如 np.int32, np.float64, ‘bool’ 等)(dtype或str或None)。

返回值：

  • 成功： 返回一个全新的多维数组对象(ndarray)。

示例：

# 传入嵌套列表，创建2行2列的二维数组
arr = np.array([[1, 2], [3, 4]])

2. zeros & ones & full - 创建特定值数组

作用：创建指定形状的数组，元素全为0(zeros)、全为1(ones)，或全部填充为指定的值(full)。dtype默认是float。

np.zeros(shape, dtype=float)
np.ones(shape, dtype=float)
np.full(shape, fill_value, dtype=None)

参数：

  • 形状 (shape)： 数组的维度大小，如 (2, 3) 表示 2行3列(int 或 tuple[int])。
  • 填充值 (fill_value)： 用于填充full数组的目标数值(Any)。
  • 数据类型 (dtype)： 可选，默认是’float64’，指定生成的数据类型(dtype)。

返回值：

  • 成功： 返回指定形状的特定值数组(ndarray)。

示例：

zeros_arr = np.zeros((2, 3))       # 2行3列的全0矩阵
ones_arr = np.ones(3, dtype='int') # 1行3列的全1数组
full_arr = np.full((2, 2), 7)      # 2行2列的全7矩阵

3. zeros_like & ones_like & full_like - 创建同维特定值数组

作用：根据传入数组的形状和数据类型，生成一个全0(zeros_like)、全1(ones_like)或指定值(full_like)的全新数组。免去手动获取 .shape 的步骤。

np.zeros_like(a, dtype=None)
np.ones_like(a, dtype=None)
np.full_like(a, fill_value, dtype=None)

参数：

  • 数组 (a)： 形状和数据类型将被用来作为参考的输入数组(array_like)。

    array_like(类数组对象)并不是 Python 中某一个具体的数据类型，而是一个“概念”或“泛称”。指的是：任何能够被NumPy成功解析，并转化为NumPy多维数组(ndarray)的Python对象。

  • 填充值 (fill_value)： full_like 中需要的填充数值(Any)。

  • 数据类型 (dtype)： 可选，覆盖参考数组的数据类型(dtype或None)。

返回值：

  • 成功： 返回与输入数组a形状相同的新数组(ndarray)。

示例：

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

z = np.zeros_like(e)     # 生成与e同形状的全0数组
o = np.ones_like(e)      # 生成与e同形状的全1数组
f = np.full_like(e, 5)   # 生成与e同形状的全5数组

4. eye & diag - 创建单位/对角矩阵

作用：

  1. eye 用于生成对角线上为1，其余为0的二维单位矩阵；
  2. diag 用于将一维数组转换为对角矩阵，或提取已有二维矩阵的对角线元素。
np.eye(N, M=None, k=0, dtype=float)
np.diag(v, k=0)

参数：

  • 行/列数 (N, M)：eye中生成的行数N(int) 和列数M(可选 int)。M默认与N相同，即方阵。
  • 数组 (v)：对于diag，如果是一维数组，返回以它为对角线的方阵；如果是二维数组，返回其对角线元素的一维数组(array_like)。
  • 对角线偏移 (k)：默认0为主对角线，正数为上对角线偏移，负数为下对角线偏移(int)。

返回值：

  • 成功： 返回新生成的单位/对角矩阵或提取的一维对角线数组(ndarray)。

示例：

eye_arr = np.eye(5)            # 生成5行5列的单位矩阵
# array([[1., 0., 0., 0., 0.],
#        [0., 1., 0., 0., 0.],
#        [0., 0., 1., 0., 0.],
#        [0., 0., 0., 1., 0.],
#        [0., 0., 0., 0., 1.]])
diag_arr = np.diag([1, 2, 3])  # 生成主对角线为1,2,3的3x3矩阵
# array([[1, 0, 0],
#        [0, 2, 0],
#        [0, 0, 3]])

5. arange & linspace - 创建序列数组

作用：

  1. arange 根据设定的步长创建等差数列(左闭右开)；
  2. linspace 则根据指定的元素个数，在区间内创建等间隔的数组。
np.arange([start,] stop, [step,] dtype=None)
np.linspace(start, stop, num=50)

参数：

  • 起始与结束 (start, stop)： 区间起点和终点(int 或 float)。arange不包含终点，arange的start默认值是0，linspace 默认包含终点。
  • 步长 (step)： 两个相邻元素之间的差值，默认值就是1(int 或 float)。
  • 数量 (num)： linspace 中要求生成的样本总数(int)。

返回值：

  • 成功： 返回一维序列数组(ndarray)。

示例：

arr1 = np.arange(0, 10, 2)    # [0, 2, 4, 6, 8]
arr2 = np.linspace(0, 1, 5)   # [0. , 0.25, 0.5, 0.75, 1. ]

6. random 模块 - 创建随机数组

作用：生成随机数数组。

  1. random 生成 0~1 的均匀分布(有的时候也用rand)；
  2. rand 生成 0~1 的均匀分布(与random等价，仅参数形式不同)；
  3. randn 生成标准正态分布；
  4. normal 生成指定均值和标准差的正态分布；
  5. randint 生成指定范围内的随机整数。
np.random.random(size)
np.random.rand(d0, d1, ..., dn)
np.random.randn(d0, d1, ..., dn)
np.random.normal(loc=0.0, scale=1.0, size=None)
np.random.randint(low, high=None, size=None)

参数：

  • 尺寸/形状 (size)： 用于 random、normal 和 randint，表示生成数组的形状 (int 或 tuple[int])。
  • 维度参数 (d0, d1, …, dn)：用于 rand 和 randn，表示每一维的大小(int)，多个参数共同确定数组形状。
  • 区间 (low, high)：randint 中指定的整数范围(左闭右开)(int)。
  • 均值 (loc)： normal 分布的均值 (float)。
  • 标准差 (scale)： normal 分布的标准差 (float)。

返回值：

  • 成功：返回填满随机样本值的数组(ndarray)。

示例：

random_arr = np.random.random((2, 5))   # 2行5列的0~1均匀分布数组
rand_arr = np.random.rand(2, 5)         # 2行5列的0~1均匀分布数组
randn_arr = np.random.randn(5)          # 1行5列的标准正态分布数组
normal_arr = np.random.normal(10, 2, 5) # 1行5列的正态分布数组(均值10，标准差2)
randint_arr = np.random.randint(0, 10, 3) # 1行3列的随机整数数组(0~9)

7. astype - 数据类型转换

作用：对已有的 NumPy 数组进行数据类型转换。注：此操作不会修改原数组，而是返回一个指定类型的新数组！

ndarray.astype(dtype)

参数：

  • 数据类型 (dtype)： 想要转换成的新目标类型(如 np.float64, np.int32)(dtype)。

返回值：

  • 成功： 返回转换数据类型后的新数组(ndarray)。

示例：

a = np.array([1.1, 2.8])
b = a.astype(np.int32)    # 强制转为整型，结果b为 [1, 2]

8. copy - 数组深拷贝

作用：创建一个数组的完全独立副本。注：因为数组切片仅返回视图，若不使用 copy，对切片的赋值将直接改变原数组！

ndarray.copy()

参数：

  • 无参数。

返回值：

  • 成功： 返回一个与原数组数据相同但内存地址完全独立的新数组(ndarray)。

示例：

a = np.array([1, 2, 3])
b = a[:2].copy()  # 对切片进行深拷贝
b[0] = 99         # 修改 b 不会影响原数组 a

9. reshape - 改变数组形状

作用：在不改变数组内部元素数据的情况下，修改数组的维度和形状。注：修改前后，数组的元素总数(size)必须完全保持一致！可以使用-1作为占位符；reshape方法不会改变数组维度。

ndarray.reshape(shape)

参数：

  • 形状 (shape)： 期望重塑的新维度大小(int 或 tuple[int])。

返回值：

  • 成功： 返回重塑形状后的新数组视图(ndarray)。

示例：

a1 = np.random.random((2, 3))  
a2 = a1.reshape(3, 2)       # 重塑为3行2列
a3 = a1.reshape(-1, 1)      # 重塑为未知行数，但固定1列的数组

10. flatten & T & flip - 展平、转置与翻转

作用：

  1. flatten() 将多维降维成一维；
  2. .T 将数组转置；
  3. flip() 则可以沿指定轴将数组内的元素顺序反转。
ndarray.flatten()
ndarray.T
np.flip(m, axis=None)

参数：

  • 数组 (m)： 需要被翻转的数组(ndarray)。

  • 轴 (axis)： 沿哪个轴进行翻转(int或None)。

    axis=None 是把数组“压扁成一维”，然后整体反转

返回值：

  • 成功： 返回结构发生改变后的新数组或视图(ndarray)。

示例：

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

a_flat = a.flatten()  # [1, 2, 3, 4]
a_t = a.T             # [[1, 3], [2, 4]]
a_flip = np.flip(a)   # [[4, 3], [2, 1]]
# axis=None时flip过程
# 第一步：先“按行展开”
# [1, 2, 3, 4]
# 第二步：整体反转
# [4, 3, 2, 1]
# 第三步：再“塞回原形状”
# [[4, 3],
#  [2, 1]]

11. append & delete - 元素的增删

作用：向数组末尾追加元素，或删除特定索引位置的元素。注：如果不指定 axis，操作的数组会被强制展平为一维！且二者都不会修改原数组，而是返回新对象。

np.append(arr, values, axis=None)
np.delete(arr, obj, axis=None)

参数：

  • 原数组 (arr)： 需要操作的源数组(ndarray)。
  • 目标对象 (values / obj)： 追加的新元素，或需要删除的索引位置(Any / int / slice)。
  • 轴 (axis)： 沿其操作的轴方向(int 或 None)。

返回值：

  • 成功： 返回增删元素后的新数组(ndarray)。

示例：

arr = np.array([10, 20, 30])
arr_app = np.append(arr, [40])    # [10, 20, 30, 40]
arr_del = np.delete(arr, 1)       # [10, 30]

12. concatenate & vstack & hstack - 数组拼接

作用：将多个形状匹配的数组合并在一起。

  1. concatenate 是最通用的拼接方法；
  2. vstack 是沿垂直(上下)拼接；
  3. hstack 是沿水平(左右)拼接。
np.concatenate(tup, axis=0)
np.vstack(tup)
np.hstack(tup)

参数：

  • 数组序列 (tup)： 包含要拼接的多个数组的元组或列表(tuple[ndarray] 或 list[ndarray])。
  • 轴 (axis)： concatenate 中指定拼接所沿着的轴方向(int，默认为0)。

返回值：

  • 成功： 返回合并拼接后的新数组(ndarray)。

示例：

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

# 以下两种上下拼接的结果完全一致：[[1, 2], [3, 4]]
res1 = np.concatenate((a1, a2), axis=0)
# [[1 2]
#  [3 4]]
res2 = np.vstack((a1, a2))
# [[1 2]
#  [3 4]]
res3 = np.hstack((a1, a2))
# [[1 2 3 4]]

13. split & array_split & vsplit & hsplit - 数组切分

作用：将数组分割成多个较小的子数组。

  1. split 是通用切分；
  2. array_split 是 split 的增强版(允许不等分)。
  3. vsplit 沿垂直方向(上下)切分；
  4. hsplit 沿水平方向(左右)切分。
np.split(ary, indices_or_sections, axis=0)
np.array_split(ary, indices_or_sections, axis=0)
np.vsplit(ary, indices_or_sections)
np.hsplit(ary, indices_or_sections)

参数：

  • 数组 (ary)： 需要被切分的目标数组(ndarray)。
  • 切分方式 (indices_or_sections)： 如果是整数 N，表示进行 N 等分；如果是序列 (x, y)，表示根据坐标位置进行定点切分(int 或 tuple[int])。

返回值：

  • 成功： 返回一个包含了切分后各个子数组的列表(list[ndarray])。

注：split和array_split区别

a = np.arange(10)
np.split(a, 3) #报错
np.array_split(a, 3) #不报错，不整除自动“尽量均匀切”
# [
#  [0,1,2,3],
#  [4,5,6],
#  [7,8,9]
# ]

示例：

a = np.arange(16).reshape(4, 4)
# 将 4行4列 的矩阵纵向(上下)等分成2份
res = np.vsplit(a, 2)  

a = np.arange(16).reshape(4, 4)
# 1.vsplit
# 将4行4列的矩阵纵向(上下)等分成2份
res1 = np.vsplit(a, 2)
# 等价写法
res2 = np.split(a, 2, axis=0)
# 结果：
# res1 =
# [
#   [[ 0  1  2  3],
#    [ 4  5  6  7]],
#
#   [[ 8  9 10 11],
#    [12 13 14 15]]
# ]

# 2.hsplit
# 将4x4矩阵横向(左右)等分成2份
res3 = np.hsplit(a, 2)
# 等价写法：
res4 = np.split(a, 2, axis=1)
# 结果：
# res3 =
# [
#   [[ 0  1],
#    [ 4  5],
#    [ 8  9],
#    [12 13]],
#
#   [[ 2  3],
#    [ 6  7],
#    [10 11],
#    [14 15]]
# ]

# 3.split(indices_or_sections为序列的情况)
# 按指定“切分位置”进行不等分切割
res5 = np.split(a, [1, 3], axis=0) #把第1和3列单独切出来，别的一起切出来
# 结果：
# res5 =
# [
#   [[ 0  1  2  3]],
#
#   [[ 4  5  6  7],
#    [ 8  9 10 11]],
#
#   [[12 13 14 15]]
# ]

# 4. 多变量接收切分结果(常用写法)
a1, a2 = np.hsplit(a, 2)
# 等价理解：把返回的 list[ndarray] 拆包赋值给多个变量
b1, b2 = np.vsplit(a, 2)
c1, c2, c3 = np.split(a, [1, 3], axis=0)

六.NumPy广播计算规则

1. 广播示意图

在这里插入图片描述

2. 广播要求

如果两个数组的形状在任何一个维度上都不匹配并且没有任何一个维度为1，则会引发异常无法广播。

如：

a = np.ones((3,2))
# array([[1., 1.],
#        [1., 1.],
#        [1., 1.]])
b = np.arange(3)
# array([0, 1, 2])
a + b #报错，因为a有两列如果复杂就变成4列了，所以无法广播相加

七.数组的算数运算

数学运算函数 描述
np.add(x1，x2 ) 按元素添加参数，等效于 x1 + x2
np.subtract(x1，x2) 按元素方式减去参数，等效于x1 - x2
np.multiply(x1，x2) 逐元素乘法参数，等效于x1 * x2
np.divide(x1，x2) 逐元素除以参数，等效于x1 / x2
np.exp(x) 计算e的x次方。
np.exp2(x) 计算2的x次方。
np.power(x1,x2) 计算x1的x2次幂。
np.mod(x) 返回输入数组中相应元素的除法余数.
np.log(x) 自然对数，逐元素。
np.log2(x) x的基础2对数。
np.log10(x) 以元素为单位返回输入数组的基数10的对数。
np.expm1(x) 对数组中的所有元素计算exp(x) - 1
np.log1p(x) 返回一个加自然对数的输入数组。
np.sqrt(x) 按元素方式返回数组的正平方根。
np.square(x) 返回输入的元素平方。
np.sin(x) 三角正弦。
np.cos(x) 元素余弦。
np.tan(x) 逐元素计算切线。
np.round(x) 四舍五入
np.floor(x) 向下取整
np.ceil(x) 向上取整

1. add & subtract & multiply & divide & mod - 基础四则与取余运算

作用：对数组执行按元素的加、减、乘、除以及取余数运算。等效于 +, -, *, /, % 运算符。

np.add(x1, x2)
np.subtract(x1, x2)
np.multiply(x1, x2)
np.divide(x1, x2)
np.mod(x1, x2)

参数：

  • 数组1、数组2 (x1, x2)： 参与运算的两个对象(array_like)。可以是形状相同的数组，或者是能够触发广播机制的数组与标量。

返回值：

  • 成功： 返回执行基础四则/取余运算后的结果(ndarray 或 数值标量)。

示例：

a = np.array([10, 20, 30])
b = np.array([1, 2, 3])

np.add(a, b)      # 结果：[11, 22, 33] (等效于a + b)
np.mod(a, b)      # 结果：[0, 0, 0] (取余，等效于a % b)

2. exp & log 系 - 指数与对数运算

作用：对数组执行指数运算(如 exe^xex, 2x2^x2x)以及对数运算(如自然对数 ln⁡\lnln, 底数为2的对数 log⁡2\log_2log2​ 等)。

np.exp(x)      # 计算e的x次方
np.exp2(x)     # 计算2的x次方
np.expm1(x)    # 计算e^(x-1) (在x极小时能保持高精度)

np.log(x)      # 计算自然对数 (底数为e)
np.log2(x)     # 计算底数为2的对数
np.log10(x)    # 计算底数为10的对数
np.log1p(x)    # 计算ln(1 + x) (在 x 极小时能保持高精度)

参数：

  • 数组 (x)： 参与运算的目标数组或数值(array_like)。

返回值：

  • 成功： 返回逐元素计算指数/对数后的结果(ndarray 或 数值标量)。

示例：

a = np.array([1, 2, np.e])
np.log(a)  # 结果：[0., 0.69314718, 1.]

3. power & sqrt & square - 幂与开方运算

作用：执行求幂(power)、求正平方根(sqrt)、求平方运算(square)。

np.power(x1, x2) # 计算 x1 的 x2 次幂
np.sqrt(x)       # 返回正平方根
np.square(x)     # 返回平方

参数：

  • 底数/数组 (x / x1)： 被进行幂/开方运算的目标底数或数组(array_like)。
  • 指数 (x2)： power 函数中指定的幂次(array_like)。

返回值：

  • 成功： 返回计算结果的新数组(ndarray 或 数值标量)。

示例：

a = np.array([1, 2, 3])
np.power(a, 2)     # [1, 4, 9] (等效于 a ** 2 或 np.square(a))
np.sqrt([1, 4, 9]) # [1., 2., 3.]

4. sin & cos & tan - 三角函数运算

作用：逐元素计算数组的正弦、余弦和正切值。注：传入的数值代表弧度(Radians)而非角度(Degrees)！

np.sin(x)
np.cos(x)
np.tan(x)

参数：

  • 弧度数组 (x)： 输入的以弧度为单位的数值或数组(array_like)。

返回值：

  • 成功： 返回计算后的三角函数值(ndarray 或 数值标量)。

示例：

a = np.array([0, np.pi/2, np.pi])
np.sin(a)  # 结果接近：[0., 1., 0.]

5. round & floor & ceil - 舍入与取整运算

作用：对浮点数进行四舍五入(round)、向下取整(floor)或向上取整(ceil)。

np.round(a, decimals=0) # 四舍五入
np.floor(x)             # 向下取整 (如 1.9 -> 1.0)
np.ceil(x)              # 向上取整 (如 1.1 -> 2.0)

参数：

  • 数组 (a / x)： 需要被取整或舍入的目标数组(array_like)。
  • 保留位数 (decimals)： round 函数独有，指定保留的小数位数(int，默认为0)。

返回值：

  • 成功： 返回舍入或取整后的结果(ndarray)。注：floor 和 ceil 仍返回浮点数形式。

示例：

a = np.array([-1.7, -1.2, 1.2, 1.7])
np.floor(a)  # [-2., -2.,  1.,  1.]
np.ceil(a)   # [-1., -1.,  2.,  2.]

八.数组的统计函数(重要)

常用统计函数：

函数名称 NaN安全版本 描述
np.sum() np.nansum() 计算元素的和
np.min() np.nanmin() 找出最小值
np.max() np.nanmax() 找出最大值
np.prod() np.nanprod() 计算元素的积
np.ptp() N/A 计算元素的极差(最大值 - 最小值)
np.mean() np.nanmean() 计算元素的算术平均值
np.std() np.nanstd() 计算标准差
np.var() np.nanvar() 计算方差
np.percentile() np.nanpercentile() 计算百分位数
np.median() np.nanmedian() 计算中位数
np.average() N/A 返回数组的加权平均值
np.any() N/A 验证任何一个元素是否为真
np.all() N/A 验证所有元素是否为真

关于NaN安全(缺失值安全)版本的说明：数组出现NaN空值将影响最终结果输出，如果跳过空值带入计算，则可使用NaN安全版本。

a = np.array([4,3,5,np.nan,6,3,5,2,7])
# array([ 4.,  3.,  5., nan,  6.,  3.,  5.,  2.,  7.])
np.sum(a) # 结果：nan
np.nansum(a) # 结果：35.0

所有函数的axis如果不填，就是默认对所有元素的计算。

1. sum & mean & max & min - 常见聚合函数

作用：对 NumPy数组中的元素进行求和(sum)、求均值(mean)、求最大值(max)或最小值(min)。

np.sum(a, axis=None)
np.mean(a, axis=None)
np.max(a, axis=None)
np.min(a, axis=None)

参数：

  • 数组 (a)： 需要计算的输入数组(ndarray)。
  • 轴 (axis)： 沿哪个轴计算(int 或 None)。如果不指定，默认针对全数组计算。

返回值：

  • 成功： 返回聚合计算的结果(数值标量 或 ndarray)。

示例：

arr = np.array([[1, 2], [3, 4]])
col_sum = np.sum(arr, axis=0)    # 沿纵向求和: [4, 6]
max_val = np.max(arr)            # 全局最大值: 4

# 沿轴计算的例子(替他函数同理)
a = np.array([
    [3,7,5],
    [8,4,3],
    [2,4,9]])
np.min(a)               # 所有元素中最小的元素
np.min(a, axis = 0) 	# 每一列中最小的元素：array([2, 4, 3])
np.max(a, axis = 1)		# 每一行中最大的元素：array([7, 8, 9])

2. argmax & argmin - 最值索引

作用：找出数组中最大值或最小值所在的索引位置。

np.argmax(a, axis=None)
np.argmin(a, axis=None)

参数：

  • 数组 (a)： 需要计算的输入数组(ndarray)。
  • 轴 (axis)： 沿哪个轴计算索引(int 或 None)。

返回值：

  • 成功： 返回最大/最小值的整数索引(int 或 ndarray)。

示例：

a = np.array([10, 50, 20])
max_idx = np.argmax(a)   # 结果为 1 (对应数值 50)

3. ptp & std & var - 极差与离散度分析

作用：ptp 计算极差(最大减最小)；std 计算标准差；var 计算方差。用于统计数据的离散程度。

np.ptp(a, axis=None)
np.std(a, axis=None)
np.var(a, axis=None)

参数：

  • 数组 (a)： 需要计算的输入数组(ndarray)。
  • 轴 (axis)： 沿哪个轴计算(int 或 None)。

返回值：

  • 成功： 返回极差、标准差或方差的数值结果(数值标量 或 ndarray)。

示例：

a = np.array([1, 2, 3, 4])
p_val = np.ptp(a)    # 极差: 4 - 1 = 3
s_val = np.std(a)    # 标准差: 1.118...
v_val = np.var(a)    # 方差: 1.25

4. prod - 数组元素求积

作用：计算给定轴上数组所有元素的乘积。

np.prod(a, axis=None)

参数：

  • 数组 (a)： 需要计算乘积的输入数组(array_like)。
  • 轴 (axis)： 沿哪个轴计算(int 或 None)。

返回值：

  • 成功： 返回计算所有元素相乘后的结果(数值标量 或 ndarray)。

示例：

a = np.array([1, 2, 3, 4])
res = np.prod(a)  # 结果为 24 (1*2*3*4)

5. percentile & median & average - 百分位数、中位数与加权平均

作用：percentile 计算指定百分位上的数值；median 计算中位数(即 50% 百分位数)；average 可用于计算数组的加权算术平均值。

np.percentile(a, q, axis=None)
np.median(a, axis=None)
np.average(a, axis=None, weights=None, returned=False)

参数：

  • 数组 (a)： 需要计算的输入数组(array_like)。
  • 百分位数 (q)： percentile 需要计算的具体百分位，取值范围 0~100(float 或 array_like)。
  • 权重 (weights)： average 中与 a 维度对应的权重数组(array_like 或 None)。不设置时等价于 np.mean()。
  • 返回权重总和 (returned)： 若设为 True，则返回 (平均值, 权重之和) 的元组(bool)。
  • 轴 (axis)： 沿哪个轴计算(int 或 None)。

返回值：

  • 成功： 返回计算的百分位数/中位数/平均值结果(数值标量 或 ndarray)。

示例：

a = np.array([1, 2, 3, 4])
np.median(a)                         # 结果：2.5
np.average(a, weights=[4, 3, 2, 1])  # 结果：2.0 ((1*4 + 2*3 + 3*2 + 4*1) / 10)
np.average(a,weights=[4,3,2,1], returned=True) # 结果：(2.0, 10.0)

6. any & all - 布尔逻辑检验

作用：用于验证数组内元素的布尔状态(真/假)。any 判断是否至少存在一个元素为真；all 判断是否所有元素均为真。

np.any(a, axis=None)
np.all(a, axis=None)

参数：

  • 数组 (a)： 需要被检验的逻辑判断数组(array_like)。
  • 轴 (axis)： 沿哪个轴检验(int 或 None)。

返回值：

  • 成功： 返回检验判定结果(bool 或 ndarray)。

示例：

a = np.array([True, False, True])
np.any(a)   # True (因为里面有 True)
np.all(a)   # False (因为里面有 False)

九.数组的线性代数函数

NumPy拥有numpy.linalg 模块，提供线性代数所需的所有功能。

函数 作用
np.dot() 返回两个数组的点积
np.vdot() 返回两个向量的点积
np.inner() 返回一维数组的向量内积
np.matmul() 返回两个数组的矩阵乘积
np.linalg.det() 计算输入矩阵的行列式
np.linalg.solve() 求解矩阵形式的线性方程的解
np.linalg.inv() 计算矩阵的逆
@ 运算符 在较新版本中用于表示矩阵乘法(等价 np.matmul)

1. dot & vdot & inner & matmul - 点积、内积与矩阵乘法

作用：执行向量和矩阵层面的各种乘法运算。

  1. dot：通用点积(一维为内积，二维为矩阵乘法)。
  2. vdot：专门计算两个向量的点积(多维会自动展平；若含复数，自动取共轭)。
  3. inner：一维时等效于内积，多维时等效于拿最后一个轴求内积。
  4. matmul：专门针对多维矩阵相乘。注：现代 Python 中经常直接使用 @ 符号代替！
np.dot(a, b)
np.vdot(a, b)
np.inner(a, b)
np.matmul(a, b)
# 等效语法: a @ b

参数：

  • 数组1、数组2 (a, b)： 参与运算的左侧与右侧输入数组(array_like)。

返回值：

  • 成功： 返回矩阵或向量乘法的计算结果(数值标量 或 ndarray)。
(1).点积(Dot Product)
①.一维点积(向量点积)

作用：计算两个一维向量对应元素相乘再求和。

通用流程：

  1. 保持两个向量为一维
  2. 对应位置元素相乘
  3. 所有结果求和
  4. 得到一个标量

公式：
v1⋅v2=∑v1[i]×v2[i] v1 \cdot v2 = \sum v1[i] \times v2[i] v1⋅v2=∑v1[i]×v2[i]

②.多维点积(矩阵乘法dot/matmul)

作用：通过“行 × 列”的方式进行矩阵乘法，本质是多次点积组合。

通用流程：

  1. 确定左矩阵 A 的“行”
  2. 确定右矩阵 B 的“列”
  3. 对应行向量与列向量做逐元素相乘
  4. 每一对结果求和
  5. 形成新矩阵

公式：
C[i,j]=∑A[i,k]×B[k,j] C[i, j] = \sum A[i, k] \times B[k, j] C[i,j]=∑A[i,k]×B[k,j]

(2).内积(Inner Product)
①.一维内积(向量内积 = vdot)

作用：将向量展平后一维化，再计算点积。

通用流程：

  1. 将两个数组展平成一维
  2. 对应位置元素相乘
  3. 所有结果求和
  4. 得到标量

公式：
v1⋅v2=∑v1[i]×v2[i] v1 \cdot v2 = \sum v1[i] \times v2[i] v1⋅v2=∑v1[i]×v2[i]

②.多维内积(inner：最后一维内积)

作用：对两个多维数组的“最后一维”做内积运算。

通用流程：

  1. 取 A 的最后一维向量
  2. 取 B 的最后一维向量
  3. 两两组合做向量内积
  4. 输出矩阵

公式：
C[i,j]=∑A[i,k]×B[j,k] C[i, j] = \sum A[i, k] \times B[j, k] C[i,j]=∑A[i,k]×B[j,k]
总结：

  • 点积 = 计算规则(逐元素乘 + 求和)
  • 内积 = 点积的“应用形式”(一维/多维最后一维)
  • 矩阵乘法 = 多次点积组合(行 × 列)

示例：

A = np.array([[1, 2], [3, 4]])
B = np.array([[1, 0], [0, 1]])
C = np.dot(A, B)      
D = A @ B #等价写法
# 矩阵乘法：Cij = A的i行 × B的j列
# [[1,2], · [[1,0],
#  [3,4]]    [0,1]]
# = [[1*1+2*0, 1*0+2*1],
#    [3*1+4*0, 3*0+4*1]]
# = [[1,2],
#    [3,4]]

v1 = np.array([1, 2])
v2 = np.array([3, 4])
v_res = np.vdot(v1, v2)
# 展平向量点积：平成一维，对应位置相乘求和
# = 1*3 + 2*4
# = 3 + 8
# = 11

I = np.array([[1, 2],
              [3, 4]])
J = np.array([[5, 6],
              [7, 8]])
inner_res = np.inner(I, J)
# 按最后一维做点积：
# 第一行：
# [1,2]·[5,6] = 1*5 + 2*6 = 17
# [1,2]·[7,8] = 1*7 + 2*8 = 23
# 第二行：
# [3,4]·[5,6] = 3*5 + 4*6 = 39
# [3,4]·[7,8] = 3*7 + 4*8 = 53
# 结果 = [[17, 23],
#         [39, 53]]

matmul_res = np.matmul(A, B)
# 矩阵乘法(等价 @)：
# = A 行 × B 列
# = [[1,2], × [[1,0],
#    [3,4]]    [0,1]]
# = [[1*1+2*0, 1*0+2*1],
#    [3*1+4*0, 3*0+4*1]]
# = [[1,2],
#    [3,4]]

2. linalg.det - 计算矩阵行列式

作用：计算给定方阵(二维正方形数组)的行列式(Determinant)。

np.linalg.det(a)

参数：

  • 数组 (a)： 需要计算行列式的方阵目标(array_like)。

返回值：

  • 成功： 返回该矩阵的行列式数值(float)。

示例：

a = np.array([[1, 2], [3, 4]])
det_val = np.linalg.det(a)  # 结果：-2.0 (1*4 - 2*3)

3. linalg.inv - 矩阵求逆

作用：计算目标方阵的逆矩阵(Inverse)。注：矩阵必须是方阵且为非奇异矩阵(即行列式不为0)！

矩阵和逆矩阵相乘是单位矩阵

np.linalg.inv(a)

参数：

  • 数组 (a)： 需要求逆的目标矩阵(方阵)(array_like)。

返回值：

  • 成功： 返回原矩阵的逆矩阵(ndarray)。

示例：

x = np.array([[1, 2], [3, 4]])
y = np.linalg.inv(x)  # 结果为 [[-2., 1.], [1.5, -0.5]]

4. linalg.solve - 求解线性方程组

作用：求解形式为 Ax = b 的线性矩阵方程组的确切解 x。

np.linalg.solve(a, b)

参数：

  • 系数矩阵 (a)： 含有线性方程组各元系数的方阵(array_like)。
  • 常数/因变量 (b)： 方程等号右侧的常数/因变量数组(array_like)。

返回值：

  • 成功： 返回该方程组的精确解数组(ndarray)。

示例：

# 求解方程组:
# 1*x0 + 2*x1 = 1
# 3*x0 + 5*x1 = 2
a = np.array([[1, 2], [3, 5]])
b = np.array([1, 2])

x = np.linalg.solve(a, b)  # 结果：[-1.,  1.]
# numpy # python # AIGC
Logo
脑启社区

脑启社区是一个专注类脑智能领域的开发者社区。欢迎加入社区，共建类脑智能生态。社区为开发者提供了丰富的开源类脑工具软件、类脑算法模型及数据集、类脑知识库、类脑技术培训课程以及类脑应用案例等资源。

更多推荐

生命体AI和数字生命有什么区别

它和动物植物是平等的，是新物种。数字生命：纯数字闭环，仅在计算机 / 虚拟世界中存在，依赖算力、存储、网络，不直接作用于物理世界。数字生命：依赖全脑模拟、意识上传、数字进化算法（如 Tierra），目标是在数字中重建意识与自我。数字生命：生存与复制优先，核心是在数字环境中自我维持、繁衍、进化，类似生物的 “生存本能”。生命体 AI：依托生命体 AI 大脑芯片、类脑计算、多模态感知、情感计算，实现自

avatar 脑启社区
cover

YOLOv11【第十四章：脑机接口与生物计算篇·第11节】BCI 数据集制作：OpenBCI + YOLOv11 标注规范

avatar 脑启社区
cover

YOLOv11【第十四章：脑机接口与生物计算篇·第12节】YOLOv11 辅助脑机康复：中风患者视觉注意力检测

avatar 脑启社区