# Python 数据分析三剑客之 NumPy（六）：矩阵 / 线性代数库与 IO 操作

TRHX

2020-03-30

Python 数据分析 / NumPy

字数统计:

6,835字

阅读时长≈

31分

NumPy 系列文章：

- Python 数据分析三剑客之 NumPy（一）：理解 NumPy / 数组基础
- Python 数据分析三剑客之 NumPy（二）：数组索引 / 切片 / 广播 / 拼接 / 分割
- Python 数据分析三剑客之 NumPy（三）：数组的迭代与位运算
- Python 数据分析三剑客之 NumPy（四）：字符串函数总结与对比
- Python 数据分析三剑客之 NumPy（五）：数学 / 算术 / 统计 / 排序 / 条件 / 判断函数合集
- Python 数据分析三剑客之 NumPy（六）：矩阵 / 线性代数库与 IO 操作

专栏：

【NumPy 专栏】【Pandas 专栏】【Matplotlib 专栏】

推荐学习资料与网站：

【NumPy 中文网】【Pandas 中文网】【Matplotlib 中文网】【NumPy、Matplotlib、Pandas 速查表】

    1
    2
    3
    4
    5

    这里是一段防爬虫文本，请读者忽略。
    本文原创首发于 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 | 输出矩阵的数据类型，可选项

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8

    >>> 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

    1
    2
    3
    4
    5
    6
    7
    8
    9

    >>> 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 | 输出矩阵的数据类型，可选项

应用举例：

    1
    2
    3
    4
    5

    >>> 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 | 是否复制数据到一个新矩阵，可选项

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

    >>> 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)`

对比举例：

    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

    >>> 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 不是字符串则忽略

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21

    >>> 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）的顺序存储多维数据在内存中，可选项

应用举例：

    1
    2
    3
    4
    5
    6
    7

    >>> 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）的顺序存储多维数据在内存中，可选项

应用举例：

    1
    2
    3
    4

    >>> 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）的顺序存储多维数据在内存中，可选项

应用举例：

    1
    2
    3
    4

    >>> 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=<class 'float'>, order='C'])`

参数 | 描述
--- | ---
n | 返回的矩阵的行数，int 类型
M | 返回的矩阵的列数，int 类型，可选项，默认为 n
k | 对角线索引，可选项，0 表示主对角线，正值表示上对角线，负值表示下对角线，该对角线上元素的值将会是 1
dtype | 返回矩阵的数据类型，可选项
order | 以行优先（C）或列优先（Fortran）的顺序存储多维数据在内存中，可选项

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

    >>> 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 | 可选项，返回的单位矩阵的数据类型

应用举例：

    1
    2
    3
    4
    5

    >>> 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 | 沿第一轴和第二轴重复的次数

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14

    >>> 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 个整数，则每个整数指定一维的大小，如果以元组形式给出，则该元组表示输出矩阵完整的形状。

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

    >>> 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 个整数，则每个整数指定一维的大小，如果以元组形式给出，则该元组表示输出矩阵完整的形状。

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8

    >>> 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]]

    1
    2
    3
    4
    5

    这里是一段防爬虫文本，请读者忽略。
    本文原创首发于 CSDN，作者 TRHX。
    博客首页：https://itrhx.blog.csdn.net/
    本文链接：https://itrhx.blog.csdn.net/article/details/105511641
    未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！

## 【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 | 可选项，放置结果的备用输出数组

- 如果 a 和 b 均为一维数组，计算的是这两个数组对应下标元素的乘积和（数学上称之为内积）；
- 如果 a 和 b 均为二维数组，计算的是两个数组的矩阵乘积；
- 如果 a 和 b 均为多维数组，它的通用计算公式为：`dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])`，即结果数组中的每个元素都是数组 a 的最后一维上的所有元素与数组 b 的倒数第二维上的所有元素的乘积和。

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

    >>> 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)`

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

    >>> 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)`

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

    >>> 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]`，外积如下：

    1
    2
    3
    4

    [[a0*b0  a0*b1 ... a0*bN ]
     [a1*b0    .
     [ ...          .
     [aM*b0            aM*bN ]]

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14

    >>> 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} = \sum{k=1}^p a_{ik}b_{kj} = a_{i1}b_{1j} + a_{i2}b_{2j} + … + a_{ip}b_{pj} $$

$$
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]
$$

$$
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]
$$

矩阵相乘的条件：

- 当矩阵 A 的列数（column）等于矩阵 B 的行数（row）时，A 与 B 可以相乘；
- 矩阵 C 的行数等于矩阵 A 的行数，C 的列数等于 B 的列数；
- 乘积 C 的第 m 行第 n 列的元素等于矩阵 A 的第 m 行的元素与矩阵 B 的第 n 列对应元素乘积之和。

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22

    >>> 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) 个轴进行内积

应用举例：

    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

    >>> 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 = \left[ \begin{matrix} a & b \ c & d \end{matrix} \right] = ad - bc $$

应用举例：

    1
    2
    3
    4

    >>> 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()` 函数求解线性矩阵方程或线性标量方程组。

$$
\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]
$$

应用举例：

    1
    2
    3
    4
    5

    >>> 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 为单位矩阵。

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

    >>> 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 对象。

### 【3x01】numpy.save()

`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 读取

应用举例：

    1
    2
    3

    >>> 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`

应用举例：

    1
    2
    3
    4
    5
    6

    >>> 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 | 关键字参数，可选项，数组将与关键字名称一起保存在文件中

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19

    >>> 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 | 对输出文件进行编码，可选项

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

    >>> 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=<class 'float'>, 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 行之后的最大行内容。默认值是读取所有行

应用举例：

    1
    2
    3
    4
    5

    >>> 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=<class 'float'>, 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 类型，可选项，用于解码输入文件的编码

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

    >>> 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.]])

    1
    2
    3
    4
    5

    这里是一段防爬虫文本，请读者忽略。
    本文原创首发于 CSDN，作者 TRHX。
    博客首页：https://itrhx.blog.csdn.net/
    本文链接：https://itrhx.blog.csdn.net/article/details/105511641
    未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！

您的喜欢是作者写作最大的动力！❤️

- PayPal
- AliPay
- WeChatPay
- QQPay

Donate

最后更新于 2020年7月6日

NumPy

矩阵

线性代数

IO操作

###### 上一页

#### Python 数据分析三剑客之 Matplotlib（一）：初识 Matplotlib 与其 Matplotibrc 配置文件

###### Matplotlib matplotibrc

###### 下一页

#### Python 数据分析三剑客之 NumPy（五）：数学 / 算术 / 统计 / 排序 / 条件 / 判断函数合集

###### NumPy 数学函数 算术函数 统计函数 排序函数 条件函数 判断函数

#### 评论

## ๑۩ﺴ TRHX ﺴ۩๑

本文目录
欢迎光临

Hexo QQ 交流群 Telegram 交流群

CSDN 内容合伙人

文章分类

- BLOG
  (4)
- CDN
  (1)
- Hexo
  (9)
- Java
  (1)
- Linux
  (2)
- Markdown
  (2)
- Python 数据分析
  (27)
- Matplotlib
  (11)
- NumPy
  (6)
- Pandas
  (10)
- Python3 学习笔记
  (41)
- 基础学习
  (9)
- 学习经验
  (4)
- 爬虫学习
  (18)
- 爬虫实战
  (10)
- VPS
  (1)
- WEB前端
  (2)
- 图床
  (1)

热门标签
12306 3D图 58同城 Ajax BLOG Beautiful Soup CDN Coding Pages DataFrame Deepin Elicpse GitHub Pages Github Github Pages GroupBy HTTPS Hexo ICP备案 IO操作 Index JDBC JS 预加载 LaTeX Markdown Material X Matplotlib MongoDB MySQL NumPy PEP8 Pandas PicGo Pygame Python Redis SEO SQL Server 2012 SSR Selenium Series Ubuntu User-Agent VMware VPS XPath if语句 input()函数 instant.page jsDelivr lxml matplotibrc pyspider requests spfk urllib while循环 主题个性化 代理 位运算 公安备案 函数 函数应用 分割 切片 列表 判断函数 前程无忧 变量 合并数据集 哔哩哔哩 图例 图床 图形验证码 垃圾 备份 子图 字典 字符串函数 安居客 层级索引 年终总结 广播 异常 技巧 拼接 排序 排序函数 操作列表 散点图 数学函数 数据分裂 数据可视化 数据合并 数据替换 数据类型 数据读写 数据重塑 数组 文件 文件储存 无界面浏览器 时间序列 映射 条件函数 条形图 极区图 极坐标图 柱状图 模块 正则表达式 滑动验证码 点触验证码 爬虫 猫眼电影 瓜子二手车 画布 直方图 矩阵 等值线图 等高线图 算术函数 算术运算 类 索引 线性代数 线性图 统计函数 统计描述 统计计算 继承 编辑器 缺失值 网格 肺炎疫情 虎扑论坛 补丁 豆瓣电影 迭代 雷达图 饼状图
最近在听