Oort.

0%

NumPy 库

发表于 更新于 分类于
本文字数： 13k 阅读时长 ≈ 12 分钟

1、安装

NumPy是第三方库，需要手动安装

1
pip3 install numpy

2、NumPy支持类型

类型 解释
bool 布尔类型，1 个字节，值为 True 或 False。
int 整数类型，通常为 int64 或 int32 。
intc 与 C 里的 int 相同，通常为 int32 或 int64。
intp 用于索引，通常为 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 位浮点表示。

1、创建numpy数组时指定变量类型

1
2
3
4
import numpy as np
# a: int = 10 指定变量a的类型为int
a: np.ndarray = np.array([1.0, 2.0, 3.0], dtype=np.float)
# numpy创建数组时使用'dtype'指定数组的变量类型

2、类型转换

在 NumPy 中，还有一系列以 as 开头的方法，它们可以将特定输入转换为数组，亦可将数组转换为矩阵、标量，ndarray 等

  • asarray(a，dtype，order)：将特定输入转换为数组。
  • asanyarray(a，dtype，order)：将特定输入转换为 ndarray。
  • asmatrix(data，dtype)：将特定输入转换为矩阵。
  • asfarray(a，dtype)：将特定输入转换为 float 类型的数组。
  • asarray_chkfinite(a，dtype，order)：将特定输入转换为数组，检查 NaN 或 infs。
  • asscalar(a)：将大小为 1 的数组转换为标量。
1
2
3
a = np.arange(4).reshape(2, 2)
a = np.asmatrix(a)  # 将二维数组转化为矩阵类型
print(type(a))

3、NumPy创建数组

1、创建 ndarray 数组的方式：

  • 从列表、元组等数据结构转换
1
2
3
4
5
6
7
8
9
numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
# object：列表、元组等。
# dtype：数据类型。如果未给出，则类型为被保存对象所需的最小类型。
# copy：布尔类型，默认 True，表示复制对象。
# order：顺序。
# subok：布尔类型，表示子类是否被传递。
# ndmin：生成的数组应具有的最小维数。
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([(1, 2), (3, 4), (5, 6)])
  • 使用 numpy.arange、numpy.ones、numpy.zeros 等方法创建

numpy.arange() 的功能是在给定区间内创建一系列均匀间隔的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
numpy.arange(start, stop, step, dtype=None)
# start：开始
# stop：停止
# step：步长
# dtype：数据类型
# 区间 [开始， 停止)，这是一个半开半闭区间。设置 step 步长用于设置值之间的间隔。 dtype可以设置返回ndarray 的值类型。
a = np.arange(1, 10, 0.5, dtype='float32')


# linspace 用于在指定的区间内返回间隔均匀的值。
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
# start：序列的起始值
# stop：序列的结束值
# num：生成的样本数
# endpoint：布尔值，如果为真，则最后一个样本包含在序列内
# retstep：布尔值，如果为真，返回间距
# dtype：数组的类型
a = np.linspace(0, 10, 10, endpoint=False)


# numpy.ones 用于快速创建数值全部为 1 的多维数组，numpy.zeros 用于快速创建数值全部为 0 的多维数组。
numpy.ones(shape, dtype=None, order='C')
numpy.zeros(shape, dtype=None, order='C')
# shape：用于指定数组形状，例如（1， 2）或 3
# dtype：数据类型
# order：{'C'，'F'}，按行或列方式储存数组
a = np.ones((3, 2))
b = np.zeros((2, 3))


# numpy.eye 用于创建一个二维数组，其特点是k 对角线上的值为 1，其余值全部为0。
numpy.eye(N, M=None, k=0, dtype=<type 'float'>)
# N：输出数组的行数
# M：输出数组的列数
# k：对角线索引：0（默认）是指主对角线，正值是指上对角线，负值是指下对角线
a = np.eye(5, 4)

  • 从存储空间读取数组

  • 使用字符串或缓冲区从原始字节创建数组

  • 使用特殊函数，如 random

2、ndarray 数组属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
a: np.ndarray = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 数组转置'ndarray.T'，与'ndarray.transpose()'相同
a.T

# 数据类型'ndarray.dtype'
a.dtype

# 'ndarray.imag' 用来输出数组包含元素的虚部
a.imag

# 'ndarray.real'用来输出数组包含元素的实部。
a.real

# 'ndarray.size'用来输出数组中的总包含元素数。
a.size

# 'ndarray.itemsize'输出一个数组元素的字节数。
a.itemsize

# 'ndarray.nbytes'用来输出数组的元素总字节数。
a.nbytes

# 'ndarray.ndim'用来输出数组维度。
a.ndim

# 'ndarray.shape'用来输出数组形状。
a.shape

# ndarray.strides用来遍历数组时，输出每个维度中步进的字节数组。
a.strides

4、数组维度和形状

1、重设形状

reshape 可以在不改变数组数据的同时，改变数组的形状。

1
2
3
4
5
6
7
8
# numpy.reshape(a, newshape)
# a表示原数组
# newshape用于指定新的形状
a: np.ndarray = np.arange(10)
# 下面两条语句等价
a = np.reshape(a, (5, 2))
a = a.reshape((5, 2))
print(a.shape)

resize对数组尺寸进行重新设定。(reshape 在改变形状时，不会影响原数组，相当于对原数组做了一份拷贝。而 resize 则是对原数组执行操作。)

1
2
3
4
5
6
# numpy.resize(a，new_shape)
# a表示原数组
# newshape用于指定新的形状
a: np.ndarray = np.arange(10)
a.resize(2, 5)
print(a)

2、数组展开

ravel 的目的是将任意形状的数组扁平化，变为 1 维数组。

1
2
3
4
5
6
7
8
9
# numpy.ravel(a, order='C')
# a 表示原数组
# order 表示变换时的读取顺序，默认是按照行依次读取，当 order = 'F' 时，可以按列依次读取排序。
a = np.arange(10).reshape((5, 2))
# 下面两条语句等价
a: np.ndarray = np.ravel(a, order='C')
a: np.ndarray = a.ravel(order='C')
print(a)
print(a.shape)

3、轴移动

moveaxis 可以将数组的轴移动到新的位置。

1
2
3
4
5
6
7
# numpy.moveaxis(a, source, destination)
# a：数组
# source：要移动的轴的原始位置
# destination：要移动的轴的目标位置
a: np.ndarray = np.ones((1, 2, 3))
a = np.moveaxis(a, 0, -1)
print(a.shape)

4、轴交换

和 moveaxis 不同的是，swapaxes 可以用来交换数组的轴。

1
2
3
4
5
6
7
# numpy.swapaxes(a, axis1, axis2)
# a：数组。
# axis1：需要交换的轴 1 位置。
# axis2：需要与轴 1 交换位置的轴 2 位置。
a: np.ndarray = np.ones((1, 4, 3))
a = np.swapaxes(a, 0, 2)
print(a.shape)

5、数组转置

transpose 类似于矩阵的转置，它可以将 2 维数组的横轴和纵轴交换。

1
2
3
4
5
6
7
8
# numpy.transpose(a, axes=None)
# a：数组
# axis：该值默认为 none，表示转置。如果有值，那么则按照值替换轴
a: np.ndarray = np.arange(4).reshape(2, 2)
# 下面两条语句等价
a = np.transpose(a)
a = a.transpose()
print(a)

6、维度改变

atleast_xd 支持将输入数据直接视为 x维。这里的 x 可以表示：1，2，3。

1
2
3
4
5
6
7
8
9
# numpy.atleast_1d()
# numpy.atleast_2d()
# numpy.atleast_3d()
a: np.ndarray = np.atleast_1d([1, 2, 3])
b: np.ndarray = np.atleast_2d([4, 5, 6])
c: np.ndarray = np.atleast_3d([7, 8, 9])
print(a)
print(b)
print(c)

7、数组链接

concatenate 可以将多个数组沿指定轴连接在一起。(需要保证连接处的维数一致)

1
2
3
4
5
6
7
8
# numpy.concatenate((a1, a2, ...), axis=0)
# (a1, a2, ...)：需要连接的数组。
# axis：指定连接轴。
a = np.array([[1, 2], [3, 4], [5, 6]])
b = np.array([[7, 8], [9, 10]])
c = np.array([[11, 12]])
d = np.concatenate((a, b, c), axis=0)
print(d)

8、数组堆叠

在 NumPy 中，以下方法可用于数组的堆叠：

  • stack(arrays，axis)：沿着新轴连接数组的序列。
  • column_stack()：将 1 维数组作为列堆叠到 2 维数组中。
  • hstack()：按水平方向堆叠数组。
  • vstack()：按垂直方向堆叠数组。
  • dstack()：按深度方向堆叠数组。
1
2
3
4
5
6
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.stack((a, b))
d = np.stack((a, b), axis=-1)
print(c)
print(d)

9、拆分

split 及与之相似的一系列方法主要是用于数组的拆分

  • split(ary，indices_or_sections，axis)：将数组拆分为多个子数组。
  • dsplit(ary，indices_or_sections)：按深度方向将数组拆分成多个子数组。
  • hsplit(ary，indices_or_sections)：按水平方向将数组拆分成多个子数组。
  • vsplit(ary，indices_or_sections)：按垂直方向将数组拆分成多个子数组。
1
2
3
4
5
6
7
8
9
# 拆分一维
a = np.arange(10)
b = np.split(a, 5)
print(b)

# 拆分多维
a = np.arange(10).reshape(2, 5)
b = np.split(a, 2)
print(b)

10、删除

delete沿特定轴删除数组中的子数组。

1
2
3
4
5
6
7
# numpy.delete(arr，obj，axis) 
# arr: 数组
# obj: 要删除列所的索引
# axis: 沿某一轴
a: np.ndarray = np.arange(8).reshape(2, 2, 2)
b = np.delete(a, 1, 2)
print(b)

11、插入

insert依据索引在特定轴之前插入值。(注意 append方法返回值，默认是展平状态下的 1 维数组)

1
2
3
4
5
6
7
8
9
# numpy.insert(arr，obj，values，axis)
# arr: 数组
# obj: 要插位置的索引
# values: 要插入的值
# axis: 沿某一轴
a: np.ndarray = np.arange(12).reshape(3, 4)
b = np.arange(4)
c = np.insert(a, 3, b, 0)
print(c)

12、附加

append将值附加到数组的末尾，并返回 1 维数组。

1
2
3
4
5
6
7
8
# numpy.append(arr，values，axis)
# arr: 数组
# values: 要插入的值
# axis: 沿某一轴
a: np.ndarray = np.arange(6).reshape(2, 3)
b: np.ndarray = np.arange(3)
c = np.append(a, b)
print(c)

13、数组翻转

  • fliplr(m)：左右翻转数组。
  • flipud(m)：上下翻转数组。
1
2
3
4
5
6
7
8
9
10
11
12
# numpy.flip(m, axis=None)
# numpy.fliplr(m)
# numpy.flipud(m)
# m: 原数组
# axis： 沿某一轴翻转
a = np.arange(16).reshape(4, 4)
b = np.fliplr(a)
c = np.flipud(a)
d = np.flip(a, axis=1)
print(b)
print(c)
print(d)

5、索引与切片

1、数组索引

一维数组索引

1
2
3
4
5
6
7
a: np.ndarray = np.arange(10)
# 获取索引值为 1 的数据。
print(a[1])
# 分别获取索引值为 1，4，5 的数据。
tmp = a[[1, 4, 5]]
print(tmp)
print(type(tmp))

二维数组索引

1
2
3
4
5
6
7
8
9
10
11
12
13
a: np.ndarray = np.arange(20).reshape(4, 5)
# 获取第 2 行，第 3 列的数据。
print(a[1, 2])
print(a[1][2])

# 获取a[1,3]和a[2,4]
b = a[[1, 2], [3, 4]]
print(b)

# 获取a[0,1,1]和a[1,2,2]
a: np.ndarray = np.arange(30).reshape(2, 5, 3)
b = a[[0, 1], [1, 2], [1, 2]]
print(b)

2、数组切片

一维数组切片

1
2
3
4
5
6
# Ndarray[start:stop:step]
# [start:stop:step] 分别代表 [起始索引:截至索引:步长]。
a = np.arange(10)
print(a[:5])
print(a[5:10])
print(a[0:10:2])

二维数组切片

1
2
3
4
5
# Ndarray[start:stop:step,...,start:stop:step]
# [start:stop:step] 分别代表 [起始索引:截至索引:步长]。
a = np.arange(20).reshape(4, 5)
print(a[0:3, 2:4])
print(a[:, ::2])

6、排序、搜索、计数

1、排序

1
2
3
4
5
6
7
# numpy.sort(a, axis=-1, kind='quicksort', order=None)
# a：数组。
# axis：要排序的轴。如果为None，则在排序之前将数组铺平。默认值为 - 1，沿最后一个轴排序。
# kind：{'quicksort'，'mergesort'，'heapsort'}，排序算法。默认值为 quicksort。
a = np.random.rand(20).reshape(4, 5)
b = np.sort(a)
print(b)
  • numpy.lexsort(keys ,axis)：使用多个键进行间接排序。
  • numpy.argsort(a ,axis,kind,order)：沿给定轴执行间接排序。
  • numpy.msort(a)：沿第 1 个轴排序。
  • numpy.sort_complex(a)：针对复数排序。

2、搜索和计数

  • argmax(a ,axis,out)：返回数组中指定轴的最大值的索引。
  • nanargmax(a ,axis)：返回数组中指定轴的最大值的索引,忽略 NaN。
  • argmin(a ,axis,out)：返回数组中指定轴的最小值的索引。
  • nanargmin(a ,axis)：返回数组中指定轴的最小值的索引,忽略 NaN。
  • argwhere(a)：返回数组中非 0 元素的索引,按元素分组。
  • nonzero(a)：返回数组中非 0 元素的索引。
  • flatnonzero(a)：返回数组中非 0 元素的索引,并铺平。
  • where(条件,x,y)：根据指定条件,从指定行、列返回元素。
  • searchsorted(a,v ,side,sorter)：查找要插入元素以维持顺序的索引。
  • extract(condition,arr)：返回满足某些条件的数组的元素。
  • count_nonzero(a)：计算数组中非 0 元素的数量。

7、NumPy数值计算

1、Numpy随机数

NumPy 的随机数功能非常强大，主要由 numpy.random 模块完成。

该模块与Python标准库中的random库相同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# numpy.random.rand(d0, d1, ..., dn)
# 指定一个数组，并使用[0, 1) 区间随机数据填充，这些数据均匀分布。
# (d0, d1, ..., dn)是对数组形状的描述
a: np.ndarray = np.random.rand(2, 5)
print(a)

# numpy.random.randn(d0, d1, ..., dn)
# 指定一个数组，并使用[0, 1) 区间随机数据填充，这些数据均匀分布。从标准正态分布中返回一个或多个样本值。
# (d0, d1, ..., dn)是对数组形状的描述
b: np.ndarray = np.random.randn(1, 10)
print(b)

# randint(low, high, size, dtype)
# 生成[low, high) 的随机整数。(注意这是一个半开半闭区间)
# size: 数组的大小
c: np.ndarray = np.random.randint(2, 5, (3, 4))
print(c)

# random_sample(size)
# 在[0, 1) 区间内生成指定 size 的随机浮点数。
d: np.ndarray = np.random.random_sample((4, 5))
print(d)

# choice(a, size, replace, p)
# 在给定的数组里随机抽取几个值，该方法类似于随机抽样。
# replace: 元素是否能够重复
e: np.ndarray = np.random.choice(10, 5, replace=False)
# 从[0,9]中随机选出5个不重复的数
print(e)

概率密度分布

  • numpy.random.beta(a，b，size)：从 Beta 分布中生成随机数。
  • numpy.random.binomial(n, p, size)：从二项分布中生成随机数。
  • numpy.random.chisquare(df，size)：从卡方分布中生成随机数。
  • numpy.random.dirichlet(alpha，size)：从 Dirichlet 分布中生成随机数。
  • numpy.random.exponential(scale，size)：从指数分布中生成随机数。
  • numpy.random.f(dfnum，dfden，size)：从 F 分布中生成随机数。
  • numpy.random.gamma(shape，scale，size)：从 Gamma 分布中生成随机数。
  • numpy.random.geometric(p，size)：从几何分布中生成随机数。
  • numpy.random.gumbel(loc，scale，size)：从 Gumbel 分布中生成随机数。
  • numpy.random.hypergeometric(ngood, nbad, nsample, size)：从超几何分布中生成随机数。
  • numpy.random.laplace(loc，scale，size)：从拉普拉斯双指数分布中生成随机数。
  • numpy.random.logistic(loc，scale，size)：从逻辑分布中生成随机数。
  • numpy.random.lognormal(mean，sigma，size)：从对数正态分布中生成随机数。
  • numpy.random.logseries(p，size)：从对数系列分布中生成随机数。
  • numpy.random.multinomial(n，pvals，size)：从多项分布中生成随机数。
  • numpy.random.multivariate_normal(mean, cov, size)：从多变量正态分布绘制随机样本。
  • numpy.random.negative_binomial(n, p, size)：从负二项分布中生成随机数。
  • numpy.random.noncentral_chisquare(df，nonc，size)：从非中心卡方分布中生成随机数。
  • numpy.random.noncentral_f(dfnum, dfden, nonc, size)：从非中心 F 分布中抽取样本。
  • numpy.random.normal(loc，scale，size)：从正态分布绘制随机样本。
  • numpy.random.pareto(a，size)：从具有指定形状的 Pareto II 或 Lomax 分布中生成随机数。
  • numpy.random.poisson(lam，size)：从泊松分布中生成随机数。
  • numpy.random.power(a，size)：从具有正指数 a-1 的功率分布中在 0，1 中生成随机数。
  • numpy.random.rayleigh(scale，size)：从瑞利分布中生成随机数。
  • numpy.random.standard_cauchy(size)：从标准 Cauchy 分布中生成随机数。
  • numpy.random.standard_exponential(size)：从标准指数分布中生成随机数。
  • numpy.random.standard_gamma(shape，size)：从标准 Gamma 分布中生成随机数。
  • numpy.random.standard_normal(size)：从标准正态分布中生成随机数。
  • numpy.random.standard_t(df，size)：从具有 df 自由度的标准学生 t 分布中生成随机数。
  • numpy.random.triangular(left，mode，right，size)：从三角分布中生成随机数。
  • numpy.random.uniform(low，high，size)：从均匀分布中生成随机数。
  • numpy.random.vonmises(mu，kappa，size)：从 von Mises 分布中生成随机数。
  • numpy.random.wald(mean，scale，size)：从 Wald 或反高斯分布中生成随机数。
  • numpy.random.weibull(a，size)：从威布尔分布中生成随机数。
  • numpy.random.zipf(a，size)：从 Zipf 分布中生成随机数。

2、数学函数

1、三角函数
  • numpy.sin(x)：三角正弦。
  • numpy.cos(x)：三角余弦。
  • numpy.tan(x)：三角正切。
  • numpy.arcsin(x)：三角反正弦。
  • numpy.arccos(x)：三角反余弦。
  • numpy.arctan(x)：三角反正切。
  • numpy.hypot(x1,x2)：直角三角形求斜边。
  • numpy.degrees(x)：弧度转换为度。
  • numpy.radians(x)：度转换为弧度。
  • numpy.deg2rad(x)：度转换为弧度。
  • numpy.rad2deg(x)：弧度转换为度。
2、双曲函数
  • numpy.sinh(x)：双曲正弦。
  • numpy.cosh(x)：双曲余弦。
  • numpy.tanh(x)：双曲正切。
  • numpy.arcsinh(x)：反双曲正弦。
  • numpy.arccosh(x)：反双曲余弦。
  • numpy.arctanh(x)：反双曲正切。
3、数值修约

数值修约, 又称数字修约, 是指在进行具体的数字运算前, 按照一定的规则确定一致的位数, 然后舍去某些数字后面多余的尾数的过程。比如, 我们常听到的「4 舍 5 入」就属于数值修约中的一种。

  • numpy.around(a)：平均到给定的小数位数。
  • numpy.round_(a)：将数组舍入到给定的小数位数。
  • numpy.rint(x)：修约到最接近的整数。
  • numpy.fix(x, y)：向 0 舍入到最接近的整数。
  • numpy.floor(x)：返回输入的底部(标量 x 的底部是最大的整数 i)。
  • numpy.ceil(x)：返回输入的上限(标量 x 的底部是最小的整数 i).
  • numpy.trunc(x)：返回输入的截断值。
4、求和、求积、差分

下面这些方法用于数组内元素或数组间进行求和、求积以及进行差分。

  • numpy.prod(a, axis, dtype, keepdims)：返回指定轴上的数组元素的乘积。
  • numpy.sum(a, axis, dtype, keepdims)：返回指定轴上的数组元素的总和。
  • numpy.nanprod(a, axis, dtype, keepdims)：返回指定轴上的数组元素的乘积, 将 NaN 视作 1。
  • numpy.nansum(a, axis, dtype, keepdims)：返回指定轴上的数组元素的总和, 将 NaN 视作 0。
  • numpy.cumprod(a, axis, dtype)：返回沿给定轴的元素的累积乘积。
  • numpy.cumsum(a, axis, dtype)：返回沿给定轴的元素的累积总和。
  • numpy.nancumprod(a, axis, dtype)：返回沿给定轴的元素的累积乘积, 将 NaN 视作 1。
  • numpy.nancumsum(a, axis, dtype)：返回沿给定轴的元素的累积总和, 将 NaN 视作 0。
  • numpy.diff(a, n, axis)：计算沿指定轴的第 n 个离散差分。
  • numpy.ediff1d(ary, to_end, to_begin)：数组的连续元素之间的差异。
  • numpy.gradient(f)：返回 N 维数组的梯度。
  • numpy.cross(a, b, axisa, axisb, axisc, axis)：返回两个(数组）向量的叉积。
  • numpy.trapz(y, x, dx, axis)：使用复合梯形规则沿给定轴积分。
5、指数和对数
  • numpy.exp(x)：计算输入数组中所有元素的指数。
  • numpy.log(x)：计算自然对数。
  • numpy.log10(x)：计算常用对数。
  • numpy.log2(x)：计算二进制对数。
6、算术运算
  • numpy.add(x1, x2)：对应元素相加。
  • numpy.reciprocal(x)：求倒数 1/x。
  • numpy.negative(x)：求对应负数。
  • numpy.multiply(x1, x2)：求解乘法。
  • numpy.divide(x1, x2)：相除 x1/x2。
  • numpy.power(x1, x2)：类似于 x1^x2。
  • numpy.subtract(x1, x2)：减法。
  • numpy.fmod(x1, x2)：返回除法的元素余项。
  • numpy.mod(x1, x2)：返回余项。
  • numpy.modf(x1)：返回数组的小数和整数部分。
  • numpy.remainder(x1, x2)：返回除法余数。
7、矩阵和向量积
  • numpy.dot(a, b)：求解两个数组的点积。
  • numpy.vdot(a, b)：求解两个向量的点积。
  • numpy.inner(a, b)：求解两个数组的内积。
  • numpy.outer(a, b)：求解两个向量的外积。
  • numpy.matmul(a, b)：求解两个数组的矩阵乘积。
  • numpy.tensordot(a, b)：求解张量点积。
  • numpy.kron(a, b)：计算 Kronecker 乘积。
9、代数运算
  • numpy.linalg.cholesky(a)：Cholesky 分解。
  • numpy.linalg.qr(a ,mode)：计算矩阵的 QR 因式分解。
  • numpy.linalg.svd(a ,full_matrices,compute_uv)：奇异值分解。
  • numpy.linalg.eig(a)：计算正方形数组的特征值和右特征向量。
  • numpy.linalg.eigh(a, UPLO)：返回 Hermitian 或对称矩阵的特征值和特征向量。
  • numpy.linalg.eigvals(a)：计算矩阵的特征值。
  • numpy.linalg.eigvalsh(a, UPLO)：计算 Hermitian 或真实对称矩阵的特征值。
  • numpy.linalg.norm(x ,ord,axis,keepdims)：计算矩阵或向量范数。
  • numpy.linalg.cond(x ,p)：计算矩阵的条件数。
  • numpy.linalg.det(a)：计算数组的行列式。
  • numpy.linalg.matrix_rank(M ,tol)：使用奇异值分解方法返回秩。
  • numpy.linalg.slogdet(a)：计算数组的行列式的符号和自然对数。
  • numpy.trace(a ,offset,axis1,axis2,dtype,out)：沿数组的对角线返回总和。
  • numpy.linalg.solve(a, b)：求解线性矩阵方程或线性标量方程组。
  • numpy.linalg.tensorsolve(a, b ,axes)：为 x 解出张量方程 a x = b
  • numpy.linalg.lstsq(a, b ,rcond)：将最小二乘解返回到线性矩阵方程。
  • numpy.linalg.inv(a)：计算逆矩阵。
  • numpy.linalg.pinv(a ,rcond)：计算矩阵的（Moore-Penrose）伪逆。
  • numpy.linalg.tensorinv(a ,ind)：计算 N 维数组的逆。
9、其他
  • numpy.angle(z, deg)：返回复参数的角度。
  • numpy.real(val)：返回数组元素的实部。
  • numpy.imag(val)：返回数组元素的虚部。
  • numpy.conj(x)：按元素方式返回共轭复数。
  • numpy.convolve(a, v, mode)：返回线性卷积。
  • numpy.sqrt(x)：平方根。
  • numpy.cbrt(x)：立方根。
  • numpy.square(x)：平方。
  • numpy.absolute(x)：绝对值, 可求解复数。
  • numpy.fabs(x)：绝对值。
  • numpy.sign(x)：符号函数。
  • numpy.maximum(x1, x2)：最大值。
  • numpy.minimum(x1, x2)：最小值。
  • numpy.nan_to_num(x)：用 0 替换 NaN。
  • numpy.interp(x, xp, fp, left, right, period)：线性插值。

0、参考

NumPy 中文

NumPy 数值计算基础入门