img

Dylan

Blockchain / IoT

Minfeng Qi

Personal Blog

Welcome to my Blog

Python Numpy

Contents

Numpy是一个开源的Python科学计算库，用于快速处理任意维度的数组,支持常见的数组和矩阵操作.

创建数组对象

创建ndarray对象有很多种方法，下面就如何创建一维数组、二维数组和多维数组进行说明。

一维数组

  • 方法一：使用array函数，通过list创建数组对象

    代码：

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

    输出：

    array([1, 2, 3, 4, 5])

  • 方法二：使用arange函数，指定取值范围创建数组对象

    代码：

    array2 = np.arange(0, 20, 2)
array2

    输出：

    array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])

  • 方法三：使用linspace函数，用指定范围均匀间隔的数字创建数组对象

    代码：

    array3 = np.linspace(-5, 5, 101)
array3

  • 方法四：使用numpy.random模块的函数生成随机数创建数组对象

    产生10个[0,1)范围的随机小数，代码：

    array4 = np.random.rand(10)
array4

    输出：

    array([0.45556132, 0.67871326, 0.4552213 , 0.96671509, 0.44086463,
       0.72650875, 0.79877188, 0.12153022, 0.24762739, 0.6669852 ])

    产生10个[1,100)范围的随机整数，代码：

    array5 = np.random.randint(1, 101, 10)
array5

    输出：

    array([29, 97, 87, 47, 39, 19, 71, 32, 79, 34])

    产生20个μ=50，σ=10的正态分布随机数，代码：

    array6 = np.random.normal(50, 10, 20)
array6

二维数组

  • 方法一：使用array函数，通过嵌套的list创建数组对象

    代码：

    array7 = np.array([[1, 2, 3], [4, 5, 6]])
array7

    输出：

    array([[1, 2, 3],
       [4, 5, 6]])

  • 方法二：使用zeros、ones、full函数指定数组的形状创建数组对象

    使用zeros函数，代码：

    array8 = np.zeros((3, 4))
array8

    输出：

    array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])

    使用ones函数，代码：

    array9 = np.ones((3, 4))
array9

    输出：

    array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

    使用full函数，代码：

    array10 = np.full((3, 4), 10)
array10

    输出：

    array([[10, 10, 10, 10],
       [10, 10, 10, 10],
       [10, 10, 10, 10]])

  • 方法三：使用eye函数创建单位矩阵

    代码：

    array11 = np.eye(4)
array11

    输出：

    array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])

  • 方法四：通过reshape将一维数组变成二维数组

    代码：

    array12 = np.array([1, 2, 3, 4, 5, 6]).reshape(2, 3)
array12

    输出：

    array([[1, 2, 3],
       [4, 5, 6]])

    提示：reshape是ndarray对象的一个方法，使用reshape方法时需要确保调形后的数组元素个数与调形前数组元素个数保持一致，否则将会产生异常。

  • 方法五：通过numpy.random模块的函数生成随机数创建数组对象

    产生[0,1)范围的随机小数构成的3行4列的二维数组，代码：

    array13 = np.random.rand(3, 4)
array13

    输出：

    array([[0.54017809, 0.46797771, 0.78291445, 0.79501326],
       [0.93973783, 0.21434806, 0.03592874, 0.88838892],
       [0.84130479, 0.3566601 , 0.99935473, 0.26353598]])

    产生[1,100)范围的随机整数构成的3行4列的二维数组，代码：

    array14 = np.random.randint(1, 100, (3, 4))
array14

    输出：

    array([[83, 30, 64, 53],
       [39, 92, 53, 43],
       [43, 48, 91, 72]])

多维数组

  • 使用随机的方式创建多维数组

    代码：

    array15 = np.random.randint(1, 100, (3, 4, 5))
array15

    输出：

    array([[[94, 26, 49, 24, 43],
        [27, 27, 33, 98, 33],
        [13, 73,  6,  1, 77],
        [54, 32, 51, 86, 59]],
  
       [[62, 75, 62, 29, 87],
        [90, 26,  6, 79, 41],
        [31, 15, 32, 56, 64],
        [37, 84, 61, 71, 71]],
  
       [[45, 24, 78, 77, 41],
        [75, 37,  4, 74, 93],
        [ 1, 36, 36, 60, 43],
        [23, 84, 44, 89, 79]]])

  • 将一维二维的数组调形为多维数组

    一维数组调形为多维数组，代码：

    array16 = np.arange(1, 25).reshape((2, 3, 4))
array16

    输出：

    array([[[ 1,  2,  3,  4],
        [ 5,  6,  7,  8],
        [ 9, 10, 11, 12]],
  
       [[13, 14, 15, 16],
        [17, 18, 19, 20],
        [21, 22, 23, 24]]])

    二维数组调形为多维数组，代码：

    array17 = np.random.randint(1, 100, (4, 6)).reshape((4, 3, 2))
array17

    输出：

    array([[[60, 59],
        [31, 80],
        [54, 91]],
  
       [[67,  4],
        [ 4, 59],
        [47, 49]],
  
       [[16,  4],
        [ 5, 71],
        [80, 53]],
  
       [[38, 49],
        [70,  5],
        [76, 80]]])

  • 读取图片获得对应的三维数组

    代码：

    array18 = plt.imread('guido.jpg')

数组对象的属性

  1. size属性：数组元素个数

    代码：

    array19 = np.arange(1, 100, 2)
array20 = np.random.rand(3, 4)
print(array19.size, array20.size)

    输出：

    50 12

  2. shape属性：数组的形状

    代码：

    print(array19.shape, array20.shape)

    输出：

    (50,) (3, 4)

  3. dtype属性：数组元素的数据类型

    代码：

    print(array19.dtype, array20.dtype)

    输出：

    int64 float64

  4. ndim属性：数组的维度

    代码：

    print(array19.ndim, array20.ndim)

    输出：

    1 2

  5. itemsize属性：数组单个元素占用内存空间的字节数

    代码：

    array21 = np.arange(1, 100, 2, dtype=np.int8)
print(array19.itemsize, array20.itemsize, array21.itemsize)

    输出：

    8 8 1

    说明：在使用arange创建数组对象时，通过dtype参数指定元素的数据类型。可以看出，np.int8代表的是8位有符号整数，只占用1个字节的内存空间，取值范围是[−128,127]。

  6. nbytes属性：数组所有元素占用内存空间的字节数

    代码：

    print(array19.nbytes, array20.nbytes, array21.nbytes)

    输出：

    400 96 50

  7. flat属性：数组（一维化之后）元素的迭代器

    代码：

    from typing import Iterable
   
print(isinstance(array20.flat, np.ndarray), isinstance(array20.flat, Iterable))

    输出：

    False True

  8. base属性：数组的基对象（如果数组共享了其他数组的内存空间）

    代码：

    array22 = array19[:]
print(array22.base is array19, array22.base is array21)

    输出：

    True False

数组的索引和切片

和Python中的列表类似，NumPy的ndarray对象可以进行索引和切片操作，通过索引可以获取或修改数组中的元素，通过切片可以取出数组的一部分。

  1. 索引运算（普通索引）

    一维数组，代码：

    array23 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
print(array23[0], array23[array23.size - 1])
print(array23[-array23.size], array23[-1])

    输出：

    1 9
1 9

    二维数组，代码：

    array24 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(array24[2])
print(array24[0][0], array24[-1][-1])
print(array24[1][1], array24[1, 1])

    输出：

    [7 8 9]
1 9
5 5
[[ 1  2  3]
 [ 4 10  6]
 [ 7  8  9]]

    代码：

    array24[1][1] = 10
print(array24)
array24[1] = [10, 11, 12]
print(array24)

    输出：

    [[ 1  2  3]
 [ 4 10  6]
 [ 7  8  9]]
[[ 1  2  3]
 [10 11 12]
 [ 7  8  9]]

  2. 切片运算（切片索引）

    切片是形如[开始索引:结束索引:步长]的语法，通过指定开始索引（默认值无穷小）、结束索引（默认值无穷大）和步长（默认值1），从数组中取出指定部分的元素并构成新的数组。因为开始索引、结束索引和步长都有默认值，所以它们都可以省略，如果不指定步长，第二个冒号也可以省略。一维数组的切片运算跟Python中的list类型的切片非常类似，此处不再赘述，二维数组的切片可以参考下面的代码，相信非常容易理解。

    代码：

    print(array24[:2, 1:])

    输出：

    [[2 3]
 [5 6]]

    代码：

    print(array24[2])
print(array24[2, :])

    输出：

    [7 8 9]
[7 8 9]

    代码：

    print(array24[2:, :])

    输出：

    [[7 8 9]]

    代码：

    print(array24[:, :2])

    输出：

    [[1 2]
 [4 5]
 [7 8]]

    代码：

    print(array24[1, :2])
print(array24[1:2, :2])

    输出：

    [4 5]
[[4 5]]

    代码：

    print(array24[::2, ::2])

    输出：

    [[1 3]
 [7 9]]

    代码：

    print(array24[::-2, ::-2])

    输出：

    [[9 7]
 [3 1]]

  3. 花式索引（fancy index）

    花式索引（Fancy indexing）是指利用整数数组进行索引，这里所说的整数数组可以是NumPy的ndarray，也可以是Python中list、tuple等可迭代类型，可以使用正向或负向索引。

    一维数组的花式索引，代码：

    array25 = np.array([50, 30, 15, 20, 40])
array25[[0, 1, -1]]

    输出：

    array([50, 30, 40])

    二维数组的花式索引，代码：

    array26 = np.array([[30, 20, 10], [40, 60, 50], [10, 90, 80]])
# 取二维数组的第1行和第3行
array26[[0, 2]]

    输出：

    array([[30, 20, 10],
       [10, 90, 80]])

    代码：

    # 取二维数组第1行第2列，第3行第3列的两个元素
array26[[0, 2], [1, 2]]

    输出：

    array([20, 80])

    代码：

    # 取二维数组第1行第2列，第3行第2列的两个元素
array26[[0, 2], 1]

    输出：

    array([20, 90])

  4. 布尔索引

    布尔索引就是通过布尔类型的数组对数组元素进行索引，布尔类型的数组可以手动构造，也可以通过关系运算来产生布尔类型的数组。

    代码：

    array27 = np.arange(1, 10)
array27[[True, False, True, True, False, False, False, False, True]]

    输出：

    array([1, 3, 4, 9])

    代码：

    array27 >= 5

    输出：

    array([False, False, False, False,  True,  True,  True,  True,  True])

    代码：

    # ~运算符可以实现逻辑变反，看看运行结果跟上面有什么不同
~(array27 >= 5)

    输出：

    array([ True,  True,  True,  True, False, False, False, False, False])

    代码：

    array27[array27 >= 5]

    输出：

    array([5, 6, 7, 8, 9])

提示：切片操作虽然创建了新的数组对象，但是新数组和原数组共享了数组中的数据，简单的说，如果通过新数组对象或原数组对象修改数组中的数据，其实修改的是同一块数据。花式索引和布尔索引也会创建新的数组对象，而且新数组复制了原数组的元素，新数组和原数组并不是共享数据的关系，这一点通过前面讲的数组的base属性也可以了解到，大家一定要注意。

数组对象的方法

统计方法

ndarray对象的统计方法主要包括：sum、mean、std、var、min、max、argmin、argmax、cumsum等，分别用于对数组中的元素求和、求平均、求标准差、求方差、找最大、找最小、求累积和等，请参考下面的代码。

array28 = np.array([1, 2, 3, 4, 5, 5, 4, 3, 2, 1])
print(array28.sum())
print(array28.mean())
print(array28.max())
print(array28.min())
print(array28.std())
print(array28.var())
print(array28.cumsum())

输出：

30
3.0
5
1
1.4142135623730951
2.0
[ 1  3  6 10 15 20 24 27 29 30]

####其他方法

  1. all() / any()方法：判断数组是否所有元素都是True / 判断数组是否有为True的元素。

  2. astype()方法：拷贝数组，并将数组中的元素转换为指定的类型。

  3. dot()方法：实现一个数组和另一个数组的点积运算。

    一维数组的点积运算，代码：

    array29 = np.array([3, 4])
array30 = np.array([5, 6])
array29.dot(array30)

    输出：

    39

    二维数组的点积运算，代码：

    array31 = np.array([[1, 2, 3], [4, 5, 6]])
array32 = np.array([[1, 2], [3, 4], [5, 6]])
array31.dot(array32)

    输出：

    array([[22, 28],
       [49, 64]])

  4. dump()方法：保存数组到文件中，可以通过NumPy中的load函数从保存的文件中加载数据创建数组。

    代码：

    array31.dump('array31-data')
array32 = np.load('array31-data', allow_pickle=True)
array32

    输出：

    array([[1, 2],
       [3, 4],
       [5, 6]])

  5. fill()方法：向数组中填充指定的元素。

  6. flatten()方法：将多维数组扁平化为一维数组。

    代码：

    array32.flatten()

    输出：

    array([1, 2, 3, 4, 5, 6])

  7. nonzero()方法：返回非0元素的索引。

  8. round()方法：对数组中的元素做四舍五入操作。

  9. sort()方法：对数组进行就地排序。

    代码：

    array33 = np.array([35, 96, 12, 78, 66, 54, 40, 82])
array33.sort()
array33

    输出：

    array([12, 35, 40, 54, 66, 78, 82, 96])

  10. swapaxes()和transpose()方法：交换数组指定的轴。

    代码：

    # 指定需要交换的两个轴，顺序无所谓
array32.swapaxes(0, 1)

    输出：

    array([[1, 3, 5],
       [2, 4, 6]])

    代码：

    # 对于二维数组，transpose相当于实现了矩阵的转置
array32.transpose()

    输出：

    array([[1, 3, 5],
       [2, 4, 6]])

  11. take()方法：从数组中取指定索引的元素，类似于花式索引。

    代码：

    array34 = array33.take([0, 2, -3, -1])
array34

    输出：

    array([12, 40, 78, 96])

  12. tolist()方法：将数组转成Python中的list。

数组的运算

使用NumPy最为方便的是当需要对数组元素进行运算时，不用编写循环代码遍历每个元素，所有的运算都会自动的矢量化（使用高效的提前编译的底层语言代码来对数据序列进行数学操作）。简单的说就是，NumPy中的数学运算和数学函数会自动作用于数组中的每个成员。

数组跟标量的运算

代码：

array35 = np.arange(1, 10)
print(array35 + 10)
print(array35 * 10)

输出：

[11 12 13 14 15 16 17 18 19]
[10 20 30 40 50 60 70 80 90]

数组跟数组的运算

代码：

array36 = np.array([1, 1, 1, 2, 2, 2, 3, 3, 3])
print(array35 + array36)
print(array35 * array36)
print(array35 ** array36)

输出：

[ 2  3  4  6  7  8 10 11 12]
[ 1  2  3  8 10 12 21 24 27]
[  1   2   3  16  25  36 343 512 729]

通用一元函数

通用函数是对ndarray中的数据执行元素级运算的函数。你可以将其看做普通函数（接收一个标量值作为参数，返回一个标量值）的矢量化包装器，如下所示。

代码：

print(np.sqrt(array35))
print(np.log2(array35))

输出：

[1.         1.41421356 1.73205081 2.         2.23606798 2.44948974
 2.64575131 2.82842712 3.        ]
[0.         1.         1.5849625  2.         2.32192809 2.5849625
 2.80735492 3.         3.169925  ]

表1：通用一元函数

函数 说明
abs / fabs 求绝对值的函数
sqrt 求平方根的函数，相当于array ** 0.5
square 求平方的函数，相当于array ** 2
exp 计算ex的函数
log / log10 / log2 对数函数（e为底 / 10为底 / 2为底）
sign 符号函数（1 - 正数；0 - 零；-1 - 负数）
ceil / floor 上取整 / 下取整
isnan 返回布尔数组，NaN对应True，非NaN对应False
isfinite / isinf 判断数值是否为无穷大的函数
cos / cosh / sin 三角函数
sinh / tan / tanh 三角函数
arccos / arccosh / arcsin 反三角函数
arcsinh / arctan / arctanh 反三角函数
rint / around 四舍五入函数

通用二元函数

代码：

array37 = np.array([[4, 5, 6], [7, 8, 9]])
array38 = np.array([[1, 2, 3], [3, 2, 1]])
print(array37 * array38)
print(np.power(array37, array38))

输出：

[[ 4 10 18]
 [21 16  9]]
[[  4  25 216]
 [343  64   9]]

表2：通用二元函数

函数 说明
add(x, y) / substract(x, y) 加法函数 / 减法函数
multiply(x, y) / divide(x, y) 乘法函数 / 除法函数
floor_divide(x, y) / mod(x, y) 整除函数 / 求模函数
allclose(x, y) 检查数组x和y元素是否几乎相等
power(x, y) 数组x的元素xi和数组y的元素yi，计算xyii
maximum(x, y) / fmax(x, y) 两两比较元素获取最大值 / 获取最大值（忽略NaN）
minimum(x, y) / fmin(x, y) 两两比较元素获取最小值 / 获取最小值（忽略NaN）
inner(x, y) 内积运算
cross(x, y) / outer(x, y) 叉积运算 / 外积运算
intersect1d(x, y) 计算x和y的交集，返回这些元素构成的有序数组
union1d(x, y) 计算x和y的并集，返回这些元素构成的有序数组
in1d(x, y) 返回由判断x 的元素是否在y中得到的布尔值构成的数组
setdiff1d(x, y) 计算x和y的差集，返回这些元素构成的数组
setxor1d(x, y) 计算x和y的对称差，返回这些元素构成的数组
**补充说明：在二维空间内，两个向量A=[a1 a2]和B=[b1 b2]的叉积是这样定义的：A×B= a1a2 b1b2 =a1b2−a2b1，其中 a1a2 b1b2 称为行列式。但是一定要注意，叉积并不等同于行列式，行列式的运算结果是一个标量，而叉积运算的结果是一个向量。如果不明白，我们可以看看三维空间两个向量，A=[a1 a2 a3]和B=[b1 b2 b3]的叉积是⟨i^ a2a3 b2b3 ,−j^ a1a3 b1b3 ,k^ a1a2 b1b2 ⟩，其中i^,j^,k^代表每个维度的单位向量。

广播机制

上面的例子中，两个二元运算的数组形状是完全相同的，我们再来研究一下，两个形状不同的数组是否可以直接做二元运算或使用二元函数进行运算，请看下面的例子。

代码：

array39 = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2], [3, 3, 3]])
array40 = np.array([1, 2, 3])
array39 + array40

输出：

array([[1, 2, 3],
       [2, 3, 4],
       [3, 4, 5],
       [4, 5, 6]])

代码：

array41 = np.array([[1], [2], [3], [4]])
array39 + array41

输出：

array([[1, 1, 1],
       [3, 3, 3],
       [5, 5, 5],
       [7, 7, 7]])

通过上面的例子，我们发现形状不同的数组仍然有机会进行二元运算，但也绝对不是任意的数组都可以进行二元运算。简单的说，只有两个数组后缘维度相同或者其中一个数组后缘维度为1时，两个数组才能进行二元运算。所谓后缘维度，指的是数组shape属性对应的元组中最后一个元素的值（从后往前数最后一个维度的值），例如，我们之前打开的图像对应的数组后缘维度为3，3行4列的二维数组后缘维度为4，而有5个元素的一维数组后缘维度为5。后缘维度相同或者其中一个数组为1就可以应用广播机制对元素进行扩散，从而满足两个数组对应元素做运算的需求，如下图所示。

img

img

img

其他常用函数

除了上面讲到的函数外，NumPy中还提供了很多用于处理数组的函数，ndarray对象的很多方法也可以通过直接调用函数来实现，下表给出了一些常用的函数。

表3：NumPy其他常用函数

函数 说明
unique 去除数组重复元素，返回唯一元素构成的有序数组
copy 返回拷贝数组得到的数组
sort 返回数组元素排序后的拷贝
split / hsplit / vsplit 将数组拆成若干个子数组
stack / hstack / vstack 将多个数组堆叠成新数组
concatenate 沿着指定的轴连接多个数组构成新数组
append / insert 向数组末尾追加元素 / 在数组指定位置插入元素
argwhere 找出数组中非0元素的位置
extract / select / where 按照指定的条件从数组中抽取或处理数组元素
flip 沿指定的轴翻转数组中的元素
fromiter 通过迭代器创建数组对象
fromregex 通过读取文件和正则表达式解析获取数据创建数组对象
repeat / tile 通过对元素的重复来创建新数组
roll 沿指定轴对数组元素进行移位
resize 重新调整数组的大小
place / put 将数组中满足条件的元素/指定的元素替换为指定的值
ptp 沿指定的轴计算极差（最大值与最小值的差）
median 沿指定轴计算中位数
partition 用选定的元素对数组进行一次划分并返回划分后的数组

提示：上面的resize函数和ndarray对象的resize方法是有区别的，resize函数在调整数组大小时会重复数组中的元素作为填补多出来的元素的值，而ndarry对象的resize方法是用0来填补多出来的元素。这些小细节不清楚暂时也不要紧，但是如果用到对应的功能了就要引起注意。

代码：

array42 = np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]])
array43 = np.array([[4, 4, 4], [5, 5, 5], [6, 6, 6]])
np.hstack((array42, array43))

输出：

array([[1, 1, 1, 4, 4, 4],
       [2, 2, 2, 5, 5, 5],
       [3, 3, 3, 6, 6, 6]])

代码：

np.vstack((array42, array43))

输出：

array([[1, 1, 1],
       [2, 2, 2],
       [3, 3, 3],
       [4, 4, 4],
       [5, 5, 5],
       [6, 6, 6]])

代码：

np.concatenate((array42, array43))

输出：

array([[1, 1, 1],
       [2, 2, 2],
       [3, 3, 3],
       [4, 4, 4],
       [5, 5, 5],
       [6, 6, 6]])

代码：

np.concatenate((array42, array43), axis=1)

输出：

array([[1, 1, 1, 4, 4, 4],
       [2, 2, 2, 5, 5, 5],
       [3, 3, 3, 6, 6, 6]])

矩阵运算

NumPy中矩阵相关函数

  1. 创建矩阵对象。

    代码：

    # matrix构造函数可以传入类数组对象也可以传入字符串
m1 = np.matrix('1 2 3; 4 5 6')
m1

    输出：

    matrix([[1, 2, 3],
        [4, 5, 6]])

    代码：

    # asmatrix函数也可以写成mat函数，它们其实是同一个函数
m2 = np.asmatrix(np.array([[1, 1], [2, 2], [3, 3]]))
m2

    输出：

    matrix([[1, 1],
        [2, 2],
        [3, 3]])

    代码：

    # 矩阵乘法运算，等同于m1.dot(m2)
m1 * m2

    输出：

    matrix([[14, 14],
        [32, 32]])

  2. 矩阵对象的属性。

    属性 说明
    A 获取矩阵对象对应的ndarray对象
    A1 获取矩阵对象对应的扁平化后的ndarray对象
    I 可逆矩阵的逆矩阵
    T 矩阵的转置
    H 矩阵的共轭转置
    shape 矩阵的形状
    size 矩阵元素的个数

  3. 矩阵对象的方法。

矩阵对象的方法跟之前讲过的ndarray数组对象的方法基本差不多，此处不再进行赘述。

NumPy的线性代数模块

NumPy的linalg模块中有一组标准的矩阵分解运算以及诸如求逆和行列式之类的函数，它们跟MATLAB和R等语言所使用的是相同的行业标准线性代数库，下面的表格列出了numpy以及linalg模块中常用的跟线性代数相关的函数。

函数 说明
diag 以一维数组的形式返回方阵的对角线元素或将一维数组转换为方阵（非对角元素元素为0）
vdot 向量的点积
dot 数组的点积（矩阵乘法）
inner 数组的内积
outer 数组的叉积
trace 计算对角线元素的和
norm 求模运算
det 计算行列式的值（在方阵上计算得到的标量）
matrix_rank 计算矩阵的秩
eig 计算矩阵的特征值（eigenvalue）和特征向量（eigenvector）
inv 计算非奇异矩阵（n阶方阵）的逆矩阵
pinv 计算矩阵的摩尔-彭若斯（Moore-Penrose）广义逆
qr QR分解（把矩阵分解成一个正交矩阵与一个上三角矩阵的积）
svd 计算奇异值分解（singular value decomposition）
solve 解线性方程组Ax=b，其中A是一个方阵
lstsq 计算Ax=b的最小二乘解

大家如果有兴趣可以用下面的代码验证上面的函数。

代码：

m3 = np.array([[1., 2.], [3., 4.]])
np.linalg.inv(m3)

输出：

array([[-2. ,  1. ],
       [ 1.5, -0.5]])

代码：

m4 = np.array([[1, 3, 5], [2, 4, 6], [4, 7, 9]])
np.linalg.det(m4)

输出：

2

代码：

# 解线性方程组ax=b
# 3x + y = 9，x + 2y = 8
a = np.array([[3,1], [1,2]])
b = np.array([9, 8])
np.linalg.solve(a, b)

输出：

array([2., 3.])