Python 数据分析三剑客之 NumPy（六）：矩阵 / 线性代数库与 IO 操作
NumPy 系列文章：
Python 数据分析三剑客之 NumPy（一）：理解 NumPy / 数组基础 Python 数据分析三剑客之 NumPy（二）：数组索引 / 切片 / 广播 / 拼接 / 分割 Python 数据分析三剑客之 NumPy（三）：数组的迭代与位运算 Python 数据分析三剑客之 NumPy（四）：字符串函数总结与对比 Python 数据分析三剑客之 NumPy（五）：数学 / 算术 / 统计 / 排序 / 条件 / 判断函数合集 Python 数据分析三剑客之 NumPy（六）：矩阵 / 线性代数库与 IO 操作 文章目录【1x00】NumPy 矩阵库【1x01】numpy.mat()【1x02】numpy.asmatrix()【1x03】numpy.matrix()【1x04】mat() / asmatrix() / matrix() 的区别【1x05】numpy.bmat()【1x06】numpy.matlib.empty()【1x07】numpy.matlib.zeros()【1x08】numpy.matlib.ones()【1x09】numpy.matlib.eye()【1x10】numpy.matlib.identity()【1x11】numpy.matlib.repmat()【1x12】numpy.matlib.rand()【1x13】numpy.matlib.randn()【2x00】NumPy 线性代数库【2x01】numpy.dot()【2x02】numpy.vdot()【2x03】numpy.inner()【2x04】numpy.outer()【2x05】numpy.matmul()【2x06】numpy.tensordot()【2x07】numpy.linalg.det()【2x08】numpy.linalg.solve()【2x09】numpy.linalg.inv()【3x00】NumPy IO 操作【3x01】numpy.save()【3x02】numpy.load()【3x03】numpy.savez()【3x04】numpy.savetxt()【3x05】numpy.loadtxt()【3x06】numpy.genfromtxt()这里是一段防爬虫文本，请读者忽略。
本文原创首发于 CSDN，作者 TRHX。
博客首页：https://itrhx.blog.csdn.net/
本文链接：https://itrhx.blog.csdn.net/article/details/105511641
【1x00】NumPy 矩阵库
numpy.matlib 模块是 NumPy 的矩阵库，该矩阵库包含多种函数，函数返回的是一个矩阵，而不是 Ndarray 对象。
官方文档介绍：https://numpy.org/doc/1.18/reference/routines.matlib.html
【1x01】numpy.mat()numpy.mat() 函数将输入数组转换为为矩阵。
基本语法：numpy.mat(data[, dtype=None])
| 参数 | 描述 |
|---|---|
| data | 输入数据，如果 data 为字符串，则需要用逗号或空格分隔列，用分号分隔行 |
| dtype | 输出矩阵的数据类型，可选项 |
应用举例：
>>> import numpy as np
>>> a = np.mat([1, 2, 3])
>>> a
matrix([[1, 2, 3]])
>>> a[0]
matrix([[1, 2, 3]])
>>> a[0,1]
2
>>> import numpy as np
>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
[3, 4]])
>>> b = np.mat(a)
>>> b
matrix([[1, 2],
[3, 4]])
【1x02】numpy.asmatrix()
numpy.asmatrix() 函数将输入数组转换为为矩阵。
基本语法：numpy.asmatrix(data[, dtype=None])
| 参数 | 描述 |
|---|---|
| data | 输入数据，如果 data 为字符串，则需要用逗号或空格分隔列，用分号分隔行 |
| dtype | 输出矩阵的数据类型，可选项 |
应用举例：
>>> import numpy as np
>>> a = np.array([[1, 2], [3, 4]])
>>> np.asmatrix(a)
matrix([[1, 2],
[3, 4]])
【1x03】numpy.matrix()
numpy.matrix() 函数从类似数组的对象或数据字符串中返回一个矩阵。
注意：此函数已经不建议再使用，在未来的版本当中可能会被删除。
基本语法：class numpy.matrix(data[, dtype=None, copy=True])
| 参数 | 描述 |
|---|---|
| data | 数组或者字符串，如果 data 为字符串，则需要用逗号或空格分隔列，用分号分隔行 |
| dtype | 输出矩阵的数据类型，可选项 |
| copy | 是否复制数据到一个新矩阵，可选项 |
应用举例：
>>> import numpy as np
>>> a = np.matrix('1 2; 3 4')
>>> a
matrix([[1, 2],
[3, 4]])
>>>
>>> b = np.matrix([[1, 2], [3, 4]])
>>> b
matrix([[1, 2],
[3, 4]])
【1x04】mat() / asmatrix() / matrix() 的区别
如果输入已经是一个矩阵或一个数组，则 mat() 和 asmatrix() 函数不会执行复制操作，相当于 matrix(data, copy=False)
对比举例：
>>> import numpy as np
>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.mat(a)
>>> c = np.matrix(a)
>>> d = np.asmatrix(a)
>>>
>>> a
array([[1, 2],
[3, 4]])
>>> b
matrix([[1, 2],
[3, 4]])
>>> c
matrix([[1, 2],
[3, 4]])
>>> d
matrix([[1, 2],
[3, 4]])
>>>
>>> a[1][1] = 0
>>>
>>> a
array([[1, 2],
[3, 0]])
>>> b
matrix([[1, 2],
[3, 0]])
>>> c # matrix() 函数默认执行 copy 操作，所以数据不变
matrix([[1, 2],
[3, 4]])
>>> d
matrix([[1, 2],
[3, 0]])
【1x05】numpy.bmat()
numpy.bmat() 函数用于从字符串、嵌套序列或数组生成矩阵对象，一般用于创建复合矩阵。
基本语法：numpy.bmat(obj[, ldict=None, gdict=None])
| 参数 | 描述 |
|---|---|
| obj | 数组或者字符串，如果 data 为字符串，则需要用逗号或空格分隔列，用分号分隔行 |
| ldict | 字典，用于替换当前帧中的本地操作数。如果 obj 不是字符串或 gdict 为 None，则将被忽略 |
| gdict | 字典，用于替换当前帧中的全局操作数。如果 obj 不是字符串则忽略 |
应用举例：
>>> import numpy as np
>>> a = np.mat('1 1; 1 1')
>>> b = np.mat('2 2; 2 2')
>>> c = np.mat('3 4; 5 6')
>>> d = np.mat('7 8; 9 0')
>>>
>>> np.bmat([[a, b], [c, d]])
matrix([[1, 1, 2, 2],
[1, 1, 2, 2],
[3, 4, 7, 8],
[5, 6, 9, 0]])
>>> np.bmat(np.r_[np.c_[a, b], np.c_[c, d]])
matrix([[1, 1, 2, 2],
[1, 1, 2, 2],
[3, 4, 7, 8],
[5, 6, 9, 0]])
>>> np.bmat('a,b; c,d')
matrix([[1, 1, 2, 2],
[1, 1, 2, 2],
[3, 4, 7, 8],
[5, 6, 9, 0]])
【1x06】numpy.matlib.empty()
numpy.matlib.empty() 函数用于创建一个给定形状和数据类型的新矩阵。
基本语法：numpy.matlib.empty(shape[, dtype=None, order='C'])
| 参数 | 描述 |
|---|---|
| shape | 定义新矩阵的形状 |
| dtype | 数据类型，可选项 |
| order | 以行优先（C）或列优先（Fortran）的顺序存储多维数据在内存中，可选项 |
应用举例：
>>> import numpy as np
>>> print(np.matlib.empty((2, 2)))
[[9.90263869e+067 8.01304531e+262]
[2.60799828e-310 0.00000000e+000]]
>>> print(np.matlib.empty((2, 2), dtype=int))
[[ -793016358 -243407933]
[ -959331519 -2060787213]]
【1x07】numpy.matlib.zeros()
numpy.matlib.zeros() 函数创建一个以 0 填充的给定形状和类数据型的矩阵。
基本语法：numpy.matlib.zeros(shape[, dtype=None, order='C'])
| 参数 | 描述 |
|---|---|
| shape | 定义新矩阵的形状 |
| dtype | 数据类型，可选项 |
| order | 以行优先（C）或列优先（Fortran）的顺序存储多维数据在内存中，可选项 |
应用举例：
>>> import numpy as np
>>> np.matlib.zeros((2, 3))
matrix([[0., 0., 0.],
[0., 0., 0.]])
【1x08】numpy.matlib.ones()
numpy.matlib.ones() 函数创建一个以 1 填充的给定形状和类数据型的矩阵。
基本语法：numpy.matlib.ones(shape[, dtype=None, order='C'])
| 参数 | 描述 |
|---|---|
| shape | 定义新矩阵的形状 |
| dtype | 数据类型，可选项 |
| order | 以行优先（C）或列优先（Fortran）的顺序存储多维数据在内存中，可选项 |
应用举例：
>>> import numpy as np
>>> np.matlib.ones((2, 3))
matrix([[1., 1., 1.],
[1., 1., 1.]])
【1x09】numpy.matlib.eye()
numpy.matlib.eye() 函数创建一个对角线元素为 1，其他位置为零的矩阵。
基本语法：numpy.matlib.eye(n[, M=None, k=0, dtype=, order='C'])
| 参数 | 描述 |
|---|---|
| n | 返回的矩阵的行数，int 类型 |
| M | 返回的矩阵的列数，int 类型，可选项，默认为 n |
| k | 对角线索引，可选项，0 表示主对角线，正值表示上对角线，负值表示下对角线，该对角线上元素的值将会是 1 |
| dtype | 返回矩阵的数据类型，可选项 |
| order | 以行优先（C）或列优先（Fortran）的顺序存储多维数据在内存中，可选项 |
应用举例：
>>> import numpy as np
>>> print(np.matlib.eye(n=3, k=1))
[[0. 1. 0.]
[0. 0. 1.]
[0. 0. 0.]]
>>> print(np.matlib.eye(n=3, k=-1))
[[0. 0. 0.]
[1. 0. 0.]
[0. 1. 0.]]
>>> print(np.matlib.eye(n=3, M=4, k=0, dtype=int))
[[1 0 0 0]
[0 1 0 0]
[0 0 1 0]]
【1x10】numpy.matlib.identity()
numpy.matlib.identity() 函数创建一个给定大小的单位矩阵。
单位矩阵：在矩阵的乘法中，有一种矩阵起着特殊的作用，如同数的乘法中的1，这种矩阵被称为单位矩阵。它是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为1。除此以外全都为0。
基本语法：numpy.matlib.identity(n[, dtype=None])
| 参数 | 描述 |
|---|---|
| n | 返回的单位矩阵的大小，int 类型 |
| dtype | 可选项，返回的单位矩阵的数据类型 |
应用举例：
>>> import numpy as np
>>> print(np.matlib.identity(3, dtype=int))
[[1 0 0]
[0 1 0]
[0 0 1]]
【1x11】numpy.matlib.repmat()
numpy.matlib.repmat() 函数用于重复数组或矩阵 m*n 次。
基本语法：numpy.matlib.repmat(a, m, n)
| 参数 | 描述 |
|---|---|
| a | 待处理的数组对象 |
| m,n | 沿第一轴和第二轴重复的次数 |
应用举例：
>>> import numpy as np
>>> a = np.array(1)
>>> b = np.arange(4)
>>> a
array(1)
>>> b
array([0, 1, 2, 3])
>>>
>>> print(np.matlib.repmat(a, 2, 3))
[[1 1 1]
[1 1 1]]
>>> print(np.matlib.repmat(b, 2, 2))
[[0 1 2 3 0 1 2 3]
[0 1 2 3 0 1 2 3]]
【1x12】numpy.matlib.rand()
numpy.matlib.rand() 函数创建一个给定大小的矩阵，其中的数据在 [0, 1) 区间随机取值来填充。
基本语法：numpy.matlib.rand(*args)
参数解释：*args：输出矩阵的形状，如果给定为 N 个整数，则每个整数指定一维的大小，如果以元组形式给出，则该元组表示输出矩阵完整的形状。
应用举例：
>>> import numpy as np
>>> print(np.matlib.rand(2, 3))
[[0.27957871 0.48748368 0.0970184 ]
[0.71062224 0.92503824 0.72415015]]
>>>
>>> print(np.matlib.rand((2, 3)))
[[0.08814715 0.0307317 0.77775332]
[0.81158748 0.09173265 0.77497881]]
>>>
>>> print(np.matlib.rand(2, 3), 4) # 如果第一个参数是元组，则其他参数将被忽略
[[0.53407924 0.56006372 0.63903716]
[0.56132381 0.90300814 0.44074964]] 4
【1x13】numpy.matlib.randn()
numpy.matlib.randn() 函数创建一个标准正态分布的随机矩阵。
标准正态分布，是一个在数学、物理及工程等领域都非常重要的概率分布，在统计学的许多方面有着重大的影响力。期望值μ=0，即曲线图象对称轴为Y轴，标准差 σ=1 条件下的正态分布，记为 N（0，1）。
标准正态分布又称为 u 分布，是以 0 为均数、以 1 为标准差的正态分布，记为 N（0，1）
基本语法：numpy.matlib.randn(*args)
参数解释：*args：输出矩阵的形状，如果给定为 N 个整数，则每个整数指定一维的大小，如果以元组形式给出，则该元组表示输出矩阵完整的形状。
应用举例：
>>> import numpy as np
>>> print(np.matlib.randn(2, 3))
[[ 0.82976978 -0.9798698 0.71262414]
[ 2.31211127 -0.5090537 1.12357032]]
>>>
>>> print(2.5 * np.matlib.randn((2, 4)) + 3) # 2 x 4 矩阵 N(3, 6.25)
[[-0.66974538 4.9354863 2.46138048 7.05576713]
[ 0.80688217 1.79017491 3.78979646 -1.99071372]]
【2x00】NumPy 线性代数库
线性代数是数学的一个分支，它的研究对象是向量，向量空间（或称线性空间），线性变换和有限维的线性方程组。NumPy 中也提供了线性代数函数库 numpy.linalg。
官方文档介绍：https://numpy.org/doc/1.18/reference/routines.linalg.html
【2x01】numpy.dot()numpy.dot() 函数用于计算两个数组的点积。
基本语法：numpy.dot(a, b[, out=None])
| 参数 | 描述 |
|---|---|
| a | 第一个数组 |
| b | 第二个数组 |
| out | 可选项，放置结果的备用输出数组 |
dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])，即结果数组中的每个元素都是数组 a 的最后一维上的所有元素与数组 b 的倒数第二维上的所有元素的乘积和。
应用举例：
>>> import numpy as np
>>> a = np.array([[1,2],[3,4]])
>>> b = np.array([[11,12],[13,14]])
>>> print(np.dot(a,b)) # [[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]]
[[37 40]
[85 92]]
>>>
>>> c = np.arange(3*4*5*6).reshape((3,4,5,6))
>>> d = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))
>>> print(np.dot(c, d)[2,3,2,1,2,2])
499128
>>> print(sum(c[2,3,2,:] * d[1,2,:,2]))
499128
【2x02】numpy.vdot()
numpy.vdot() 函数返回两个向量的点积，如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数是多维数组，它会被展开。
共轭复数：两个实部相等，虚部互为相反数的复数互为共轭复数。
基本语法：numpy.vdot(a, b)
应用举例：
>>> import numpy as np
>>> a = np.array([1+2j, 3+4j])
>>> b = np.array([5+6j, 7+8j])
>>> print(np.vdot(a, b)) # a 的共轭复数用于计算：(1-2j) * (5+6j) + (3-4j) * (7+8j)
(70-8j)
>>> print(np.vdot(b, a)) # b 的共轭复数用于计算：(1+2j) * (5-6j) + (3+4j) * (7-8j)
(70+8j)
>>>
>>>
>>> c = np.array([[1, 4], [5, 6]])
>>> d = np.array([[4, 1], [2, 2]])
>>> print(np.vdot(c, d)) # 1*4 + 4*1 + 5*2 + 6*2
30
【2x03】numpy.inner()
numpy.inner() 函数计算一维数组的点积，对于其他维度，返回最后一个轴上的和的乘积。
基本语法：numpy.inner(a, b)
应用举例：
>>> import numpy as np
>>> a = np.array([[1,2],[3,4]])
>>> b = np.array([[11,12],[13,14]])
>>> print(np.inner(a,b)) # [[1*11+2*12, 1*13+2*14], [3*11+4*12, 3*13+4*14]]
[[35 41]
[81 95]]
>>>
>>>
>>> c = np.array([1,2,3])
>>> d = np.array([0,1,0])
>>> print(np.inner(c,d)) # 1*0+2*1+3*0
2
【2x04】numpy.outer()
numpy.outer() 函数计算两个向量的外积。
基本语法：numpy.outer(a, b[, out=None])
| 参数 | 描述 |
|---|---|
| a | 第一个向量，如果不是一维的则在计算前会将其展平 |
| b | 第一个向量，如果不是一维的则在计算前会将其展平 |
| out | 结果存储的位置，可选项，类似于 (M, N) 结构的 Ndarray 对象 |
外积一般指两个向量的向量积，若两向量：a = [a0, a1, ..., aM] b = [b0, b1, ..., bN]，外积如下：
[[a0*b0 a0*b1 ... a0*bN ]
[a1*b0 .
[ ... .
[aM*b0 aM*bN ]]
应用举例：
>>> import numpy as np
>>> a = np.array([1, 2, 3, 4])
>>> b = np.array([5, 6, 7, 8])
>>> print(np.outer(a, b))
[[ 5 6 7 8]
[10 12 14 16]
[15 18 21 24]
[20 24 28 32]]
>>>
>>> c = np.array(['a', 'b', 'c'], dtype=object)
>>> print(np.outer(c, [1, 2, 3]))
[['a' 'aa' 'aaa']
['b' 'bb' 'bbb']
['c' 'cc' 'ccc']]
【2x05】numpy.matmul()
numpy.matmul() 函数计算两个矩阵的乘积。
矩阵的乘积运算：
设 A 为 m x p 的矩阵，B 为 p x n 的矩阵，那么称 m x n 的矩阵 C 为矩阵 A 与 B 的乘积，记作 C = AB，其中矩阵 C 中的第 i 行第 j 列元素可以表示为：
(AB)ij=∑k=1paikbkj=ai1b1j+ai2b2j+...+aipbpj (AB)_{ij} = \sum_{k=1}^p a_{ik}b_{kj} = a_{i1}b_{1j} + a_{i2}b_{2j} + ... + a_{ip}b_{pj} (AB)ij=k=1∑paikbkj=ai1b1j+ai2b2j+...+aipbpj
A=[a1,1a1,2a1,3a2,1a2,2a2,3]B=[b1,1b1,2b2,1b2,2b3,1b3,2] A = \left[ \begin{matrix} a_{1,1} & a_{1,2} & a_{1,3} \\ a_{2,1} & a_{2,2} & a_{2,3} \end{matrix} \right] \qquad\qquad\qquad\qquad\qquad\qquad B = \left[ \begin{matrix} b_{1,1} & b_{1,2} \\ b_{2,1} & b_{2,2} \\ b_{3,1} & b_{3,2} \end{matrix} \right] A=[a1,1a2,1a1,2a2,2a1,3a2,3]B=⎣⎡b1,1b2,1b3,1b1,2b2,2b3,2⎦⎤
C=AB=[a1,1b1,1a1,2b2,1a1,3b3,1,a1,1b1,2a1,2b2,2a1,3b3,2a2,1b1,1a2,2b2,1a2,3b3,1,a2,1b1,2a2,2b2,2a2,3b3,2] C = AB = \left[ \begin{matrix} a_{1,1}b_{1,1} & a_{1,2}b_{2,1} & a_{1,3}b_{3,1}, & a_{1,1}b_{1,2} & a_{1,2}b_{2,2} & a_{1,3}b_{3,2} \\ a_{2,1}b_{1,1} & a_{2,2}b_{2,1} & a_{2,3}b_{3,1}, & a_{2,1}b_{1,2} & a_{2,2}b_{2,2} & a_{2,3}b_{3,2} \end{matrix} \right] C=AB=[a1,1b1,1a2,1b1,1a1,2b2,1a2,2b2,1a1,3b3,1,a2,3b3,1,a1,1b1,2a2,1b1,2a1,2b2,2a2,2b2,2a1,3b3,2a2,3b3,2]
矩阵相乘的条件：
当矩阵 A 的列数（column）等于矩阵 B 的行数（row）时，A 与 B 可以相乘； 矩阵 C 的行数等于矩阵 A 的行数，C 的列数等于 B 的列数； 乘积 C 的第 m 行第 n 列的元素等于矩阵 A 的第 m 行的元素与矩阵 B 的第 n 列对应元素乘积之和。应用举例：
>>> import numpy as np
>>> a = np.array([[1,0], [0,1]])
>>> b = np.array([[4,1], [2,2]])
>>> print(np.matmul(a, b))
[[4 1]
[2 2]]
>>>
>>> c = np.array([[1,0], [0,1]])
>>> d = np.array([1,2])
>>> print(np.matmul(c, d))
[1 2]
>>> print(np.matmul(d, c))
[1 2]
>>>
>>> e = np.arange(8).reshape(2,2,2)
>>> f = np.arange(4).reshape(2,2)
>>> print(np.matmul(e, f))
[[[ 2 3]
[ 6 11]]
[[10 19]
[14 27]]]
【2x06】numpy.tensordot()
numpy.tensordot() 函数计算两个不同维度矩阵的乘积。
基本语法：numpy.tensordot(a, b, axes=2)
| 参数 | 描述 |
|---|---|
| a | 第一个矩阵 |
| b | 第二个矩阵 |
| axis | 指定收缩的轴 如果是一个整型 m，表示指定数组 a 的后 m 个轴和数组 b 的前 m 个轴分别进行内积，即对应位置元素相乘、再整体求和 如果是一个列表 [m, n]，那么表示 a 的第 m+1 个 (索引为m) 轴和 b 的第 n+1 (索引为n) 个轴进行内积 |
应用举例：
>>> import numpy as np
>>> a = np.random.randint(0, 9, (3, 4))
>>> b = np.random.randint(0, 9, (4, 5))
>>> a
array([[4, 0, 3, 6],
[1, 3, 2, 2],
[6, 1, 3, 4]])
>>> b
array([[1, 0, 0, 7, 6],
[3, 8, 7, 5, 0],
[4, 7, 0, 8, 0],
[3, 8, 5, 0, 1]])
>>> print(np.tensordot(a, b, 1))
[[34 69 30 52 30]
[24 54 31 38 8]
[33 61 27 71 40]]
>>>
>>> c = np.array(range(1, 9)).reshape(2, 2, 2)
>>> d = np.array(('a', 'b', 'c', 'd'), dtype=object).reshape(2, 2)
>>> c
array([[[1, 2],
[3, 4]],
[[5, 6],
[7, 8]]])
>>> d
array([['a', 'b'],
['c', 'd']], dtype=object)
>>> print(np.tensordot(c, d))
['abbcccdddd' 'aaaaabbbbbbcccccccdddddddd']
【2x07】numpy.linalg.det()
numpy.linalg.det() 函数计算矩阵的行列式。
阵行列式是指矩阵的全部元素构成的行列式，设 A=(aij) 是数域 P 上的一个 n 阶矩阵，则所有 A=(aij) 中的元素组成的行列式称为矩阵 A 的行列式，记为 |A| 或 det(A)
一个 2×2 矩阵的行列式可表示如下：
det=[abcd]=ad−bc det = \left[ \begin{matrix} a & b \\ c & d \end{matrix} \right] = ad - bc det=[acbd]=ad−bc
应用举例：
>>> import numpy as np
>>> a = np.array([[1, 2], [3, 4]])
>>> print(np.linalg.det(a))
-2.0000000000000004
【2x08】numpy.linalg.solve()
numpy.linalg.solve() 函数求解线性矩阵方程或线性标量方程组。
{3x+y=9x+2y=8用矩阵可表示为：[3112][xy]=[98] \left \{ \begin{aligned} 3x+y=9 \\ x+2y=8 \end{aligned} \right. \qquad用矩阵可表示为：\qquad \left[ \begin{matrix} 3 & 1 \\ 1 & 2 \end{matrix} \right] \left[ \begin{matrix} x & y \end{matrix} \right] = \left[ \begin{matrix} 9 & 8 \end{matrix} \right] {3x+y=9x+2y=8用矩阵可表示为：[3112][xy]=[98]
应用举例：
>>> import numpy as np
>>> a = np.array([[3,1], [1,2]])
>>> b = np.array([9,8])
>>> print(np.linalg.solve(a, b))
[2. 3.]
【2x09】numpy.linalg.inv()
numpy.linalg.inv() 函数计算矩阵的逆矩阵。
设 A 是数域上的一个 n 阶矩阵，若在相同数域上存在另一个 n 阶矩阵 B，使得：AB = BA = E，则我们称 B 是 A 的逆矩阵，而 A 则被称为可逆矩阵。注：E 为单位矩阵。
应用举例：
>>> import numpy as np
>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.linalg.inv(a)
>>> print(b)
[[-2. 1. ]
[ 1.5 -0.5]]
>>>
>>> a * b == b * a
array([[ True, True],
[ True, True]])
【3x00】NumPy IO 操作
NumPy IO 操作即读写磁盘上的文本数据或二进制数据，在 NumPy 中有专门的 .npy / npy 文件，.npy 文件用于储存单个 Ndarray 对象；.npz 文件用于储存多个 Ndarray 对象。
numpy.save() 函数将数组保存到二进制文件（.npy 文件）中。
基本语法：numpy.save(file, arr[, allow_pickle=True, fix_imports=True])
| 参数 | 描述 |
|---|---|
| file | 要保存的文件名，可以带路径，文件后缀为 .npy，若路径末尾没有后缀，则会默认加上 .npy 后缀 |
| arr | 要保存的数组 |
| allow_pickle | bool 值，可选项，是否允许使用 Python pickle 保存数组对象 Python pickle 用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化 pickle 序列化后的数据，可读性差，人一般无法识别 |
| fix_imports | bool 值，可选项，强制以 Python 2 兼容方式对 Python 3 上的数组对象进行处理 如果 fix_imports 为True，则 pickle 将尝试将新的 Python 3 名称映射到 Python 2 中使用的旧模块名称，以便 pickle 数据流可被 Python 2 读取 |
应用举例：
>>> import numpy as np
>>> a = np.array([[1,2,3], [4,5,6]])
>>> np.save('D:\\file\\outfile.npy', a)
【3x02】numpy.load()
numpy.load() 函数用于读取 .npy / npz 文件里面的内容。
基本语法：numpy.load(file[, mmap_mode=None, allow_pickle=False, fix_imports=True, encoding='ASCII'])
| 参数 | 描述 |
|---|---|
| file | 要读取的 npy 文件对象 |
| mmap_mode | 可选项，读取文件的模式，可选参数 r+ r w+ c，与 Python 读取文件模式类似，模式含义参见 numpy.memmap |
| allow_pickle | bool 值，可选项，是否允许使用 Python pickle 保存数组对象 Python pickle 用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化 pickle 序列化后的数据，可读性差，人一般无法识别 |
| fix_imports | bool 值，可选项，强制以 Python 2 兼容方式对 Python 3 上的数组对象进行处理 如果 fix_imports 为True，则 pickle 将尝试将新的 Python 3 名称映射到 Python 2 中使用的旧模块名称，以便 pickle 数据流可被 Python 2 读取 |
| encoding | str 类型，可选项，读取 Python2 字符串时使用什么编码 仅当在 Python3 中加载 Python 2 生成的 pickled 文件（包括包含对象数组的 npy/npz 文件）时才有用 不允许使用 latin1、ASCII 和 bytes 以外的值，因为它们可能损坏数字数据。默认值为 ASCII |
应用举例：
>>> import numpy as np
>>> a = np.array([[1,2,3], [4,5,6]])
>>> np.save('D:\\file\\outfile.npy', a)
>>> np.load('D:\\file\\outfile.npy')
array([[1, 2, 3],
[4, 5, 6]])
【3x03】numpy.savez()
numpy.savez() 函数将多个数组保存到二进制文件（.npz 文件）中。
基本语法：numpy.savez(file, *args[, **kwds])
| 参数 | 描述 |
|---|---|
| file | 要保存的文件名，可以带路径，文件后缀为 .npz，若路径末尾没有后缀，则会默认加上 .npz 后缀 |
| args | 保存的数组，由于 Python 不知道外面 savez 的数组的名称，因此将使用 arr_0，arr_1 等名称保存数组，这些参数可以是任何表达式 |
| kwds | 关键字参数，可选项，数组将与关键字名称一起保存在文件中 |
应用举例：
>>> import numpy as np
>>> a = np.array([[1,2,3],[4,5,6]])
>>> b = np.arange(0, 1.0, 0.1)
>>> c = np.sin(b) # c 使用关键字参数 sin_array
>>> np.savez('D:\\file\\outfile.npz', a, b, sin_array=c)
>>> r = np.load('D:\\file\\outfile.npz')
>>> print(r.files) # 查看各个数组名称
['sin_array', 'arr_0', 'arr_1']
>>>
>>> print(r['arr_0']) # 数组 a
[[1 2 3]
[4 5 6]]
>>>
>>> print(r['arr_1']) # 数组 b
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
>>>
>>> print(r['sin_array']) # 数组 c
[0. 0.09983342 0.19866933 0.29552021 0.38941834 0.47942554
0.56464247 0.64421769 0.71735609 0.78332691]
【3x04】numpy.savetxt()
numpy.savetxt() 函数将数组保存到文本文件中（txt）。
基本语法：numpy.savetxt(fname, X[, fmt='%.18e', delimiter=' ', newline='n', header='', footer='', comments='# ', encoding=None])
| 参数 | 描述 |
|---|---|
| fname | 要保存的文件名，可以带路径，如果文件后缀为 .gz，则文件将自动以压缩格式 gzip 保存 |
| X | 要保存的数组 |
| fmt | 格式序列或多格式字符串，可选项 |
| delimiter | 指定各种分隔符、针对特定列的转换器函数、需要跳过的行数等，可选项 |
| newline | 字符串或字符分隔线，可选项 |
| header | 写入文件开头的字符串，可选项 |
| footer | 写入文件末尾的字符串，可选项 |
| comments | 注释，在 header 和 footer 字符串之前添加的字符串，可选项 |
| encoding | 对输出文件进行编码，可选项 |
应用举例：
>>> import numpy as np
>>> a = np.array([1,2,3,4,5])
>>> np.savetxt('D:\\file\\outfile.txt', a)
>>> np.loadtxt('D:\\file\\outfile.txt')
array([1., 2., 3., 4., 5.])
>>>
>>> b = np.arange(0,10,0.5).reshape(4,-1)
>>> np.savetxt('D:\\file\\outfile2.txt', b, fmt="%d", delimiter=',') # 保存为整数，以逗号分隔
>>> np.loadtxt('D:\\file\\outfile2.txt', delimiter=',') # 读取数据时也要指定相同的分隔符
array([[0., 0., 1., 1., 2.],
[2., 3., 3., 4., 4.],
[5., 5., 6., 6., 7.],
[7., 8., 8., 9., 9.]])
【3x05】numpy.loadtxt()
numpy.loadtxt() 函数用于读取文本文件（txt）里面的内容。
基本语法：numpy.loadtxt(fname[, dtype=, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes', max_rows=None])
重要参数解释：
| 参数 | 描述 |
|---|---|
| fname | 要读取的文件，文件名或生成器。如果文件扩展名是 .gz 或 .bz2，则首先将文件解压缩，注意，生成器应返回字节字符串 |
| dtype | 可选项，结果数组的数据类型 |
| comments | str 或 str 序列，可选项，用于指示注释开始的字符或字符列表 |
| delimiter | str 类型，可选项，指定分隔符 |
| skiprows | int 类型，可选项，跳过前 n 行，一般用于跳过第一行表头 |
| usecols | int 类型的索引值，读取指定的列 |
| unpack | bool 值，可选项，如果为True，则会对返回的数组进行转置 |
| ndmin | int 类型，可选项，返回的数组将至少具有 ndmin 维度，否则一维轴将被压缩 |
| encoding | str 类型，可选项，用于解码输入文件的编码 |
| max_rows | int 类型，可选项，读取 skiprows 行之后的最大行内容。默认值是读取所有行 |
应用举例：
>>> import numpy as np
>>> a = np.array([1,2,3,4,5])
>>> np.savetxt('D:\\file\\outfile.txt', a)
>>> np.loadtxt('D:\\file\\outfile.txt')
array([1., 2., 3., 4., 5.])
【3x06】numpy.genfromtxt()
numpy.genfromtxt() 函数同样用于读取文本文件（txt）里面的内容。该函数比 loadtxt() 函数功能更加强大，genfromtxt() 主要面向结构数组和缺失数据处理。
官方文档介绍：https://numpy.org/doc/1.18/reference/generated/numpy.genfromtxt.html
推荐文章：https://www.cnblogs.com/Simplelee/p/8975763.html
主要语法：numpy.genfromtxt(fname[, dtype=, comments='#', delimiter=None, skip_header=0, skip_footer=0, converters=None, missing_values=None, filling_values=None, usecols=None, encoding='bytes'])
主要参数解释：
| 参数 | 描述 |
|---|---|
| fname | 要读取的文件，文件名或生成器。如果文件扩展名是 .gz 或 .bz2，则首先将文件解压缩，注意，生成器应返回字节字符串 |
| dtype | 可选项，结果数组的数据类型 |
| comments | str 或 str 序列，可选项，用于指示注释开始的字符或字符列表 |
| delimiter | str 类型，可选项，指定分隔符 |
| skip_header | int 类型，可选项，文件开头要跳过的行数 |
| skip_footer | int 类型，可选项，文件末尾要跳过的行数 |
| converters | 变量，可选项，将列的数据转换为值的一组函数 还可以为丢失的数据提供默认值： converters = {3: lambda s: float(s or 0)} |
| missing_values | 变量，可选项，与缺少的数据相对应的字符串集，默认情况下使用空格表示缺失 |
| filling_values | 变量，可选项，缺少数据时用作默认值的一组值 |
| usecols | 序列，可选项，读取指定的列 |
| encoding | str 类型，可选项，用于解码输入文件的编码 |
应用举例：
>>> import numpy as np
>>> a = np.array([1,2,3,4,5])
>>> np.savetxt('D:\\file\\outfile.txt', a)
>>> np.genfromtxt('D:\\file\\outfile.txt')
array([1., 2., 3., 4., 5.])
>>>
>>> b = np.arange(0,10,0.5).reshape(4,-1)
>>> np.savetxt('D:\\file\\outfile2.txt', b, fmt="%d", delimiter=",")
>>> np.genfromtxt('D:\\file\\outfile2.txt', delimiter=',')
array([[0., 0., 1., 1., 2.],
[2., 3., 3., 4., 4.],
[5., 5., 6., 6., 7.],
[7., 8., 8., 9., 9.]])
作者：TRHX • 鲍勃
