实验楼 - Python Numpy 100题实验（八）：线性代数函数以及fromfunction函数等

谁践踏了优雅 2022-05-08 10:42 234阅读 0赞

本次的主要内容有：

*  对线性代数函数例如逆矩阵函数，特征值以及特征值向量函数等的应用
 *  fromfunction（）函数的使用

### 求解给定矩阵的逆矩阵并验证 ###

a = np.random.randint(1, 5, (3,3))  # 注意这样的话要多试几次，因为随机数生成的矩阵可能会是奇异矩阵。。
    print('Arrray a:')
    print(a)
    b = np.linalg.inv(a)
    print('Inverse Matrix:')
    print(b)
    print(np.dot(a, b))          # 验证一下矩阵相乘的结果是不是单位阵
    assert np.allclose(np.dot(a, b), np.eye(3))    # 或者用这种方式

输出：

Arrray a:
    [[1 4 4]
     [1 2 4]
     [2 4 4]]
    Inverse Matrix:
    [[-1.    0.    1.  ]
     [ 0.5  -0.5   0.  ]
     [ 0.    0.5  -0.25]]
    [[1. 0. 0.]
     [0. 1. 0.]
     [0. 0. 1.]]

### 使用Numpy计算矩阵的特征值以及特征向量 ###

线性代数的方法直接调用即可

a = np.array([[1,2,3], [4,5,6], [7,8,9]])
    print('Array a:')
    print(a)
    w, v = np.linalg.eig(a)
    print('Eigen value:')
    print(w)
    print('Eigen vector:')
    print(v)

输出：

Array a:
    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    Eigen value:
    [ 1.61168440e+01 -1.11684397e+00 -1.30367773e-15]
    Eigen vector:
    [[-0.23197069 -0.78583024  0.40824829]
     [-0.52532209 -0.08675134 -0.81649658]
     [-0.8186735   0.61232756  0.40824829]]

### 使用Numpy计算Ndarray两相邻元素的差值 ###

diff函数的应用，也就是计算相邻的元素之间的差，所以每一次计算都会比之前的数组减少一个元素

a = np.random.randint(1, 10, 10)
    print('Array a:')
    print(a)
    # 计算一次差值
    print(np.diff(a, n=1))
    # 计算两次差值
    print(np.diff(a, n=2))
    # 计算三次差值
    print(np.diff(a, n=3))

输出：

Array a:
    [1 5 1 2 6 1 2 3 2 8]
    [ 4 -4  1  4 -5  1  1 -1  6]
    [-8  5  3 -9  6  0 -2  7]
    [ 13  -2 -12  15  -6  -2   9]

### 使用Numpy将Ndarray相邻元素依次累加 ###

对于一个数组，输出一个数组，输出数组的每一个元素对应从第一个元素累加到这个位置元素的和

a = np.random.randint(1, 10, 10)
    print('Array a:')
    print(a)
    print(np.cumsum(a))

输出：

Array a:
    [8 9 1 2 9 6 2 1 6 9]
    [ 8 17 18 20 29 35 37 38 44 53]

Numpy好变态啊。。这种函数都有。。。

### 使用Numpy按列连接两个数组 ###

这里注意两种方法区别：

a = np.array([1,2,3])
    b = np.array([4,5,6])
    
    print([a,b])
    c = [a, b]
    print(type(c))      #  注意看这里 简单写在一块之后输出的是列表
    print(np.array(c))
    print(type(np.array(c)))   
    
    d = np.c_[a, b]     # 使用 numpy.c_函数直接生成的就是数组
    print(d)
    print(d.T)
    print(type(d))

输出：

[array([1, 2, 3]), array([4, 5, 6])]
    <class 'list'>
    [[1 2 3]
     [4 5 6]]
    <class 'numpy.ndarray'>
    [[1 4]
     [2 5]
     [3 6]]
    [[1 2 3]
     [4 5 6]]
    <class 'numpy.ndarray'>

### 使用Numpy按行连接两个数组 ###

与按列的方式是对应的，一个是column的简写，一个是row的间歇嘛，不过要注意函数后边是中括号。

a = np.array([1,2,3])
    b = np.array([4,5,6])
    
    print(np.r_[a, b])

输出：

[1 2 3 4 5 6]

### 使用Numpy打印九九乘法表 ###

果然，不管是学习哪种语言，九九乘法表都是与hello world一样的存在啊

不过使用Numpy有超级简单的实现方式：

np.fromfunction(lambda i, j: (i + 1) * (j + 1), (9, 9))

输出：

array([[ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.],
           [ 2.,  4.,  6.,  8., 10., 12., 14., 16., 18.],
           [ 3.,  6.,  9., 12., 15., 18., 21., 24., 27.],
           [ 4.,  8., 12., 16., 20., 24., 28., 32., 36.],
           [ 5., 10., 15., 20., 25., 30., 35., 40., 45.],
           [ 6., 12., 18., 24., 30., 36., 42., 48., 54.],
           [ 7., 14., 21., 28., 35., 42., 49., 56., 63.],
           [ 8., 16., 24., 32., 40., 48., 56., 64., 72.],
           [ 9., 18., 27., 36., 45., 54., 63., 72., 81.]])

好吧，其实跟我们传统的乘法表不太一样。。

这里主要是要注意fromfunciton函数的使用，这个函数我们可以非常方便地使用函数规则创建数组，先看几个例子：

例子一：

def f(x, y):
        return 10*x + y
    
    b =np.fromfunction(f, (5,4), dtype=np.int)
    print(b)

输出：

[[ 0  1  2  3]
     [10 11 12 13]
     [20 21 22 23]
     [30 31 32 33]
     [40 41 42 43]]

例子二：

a = np.fromfunction(lambda i,j: i==j ,(3,3), dtype=np.int)
    print(a)

[[ True False False]
     [False  True False]
     [False False  True]]

我觉得看完这两个例子，基本就搞清楚基本用法了，第一个参数指定了规则，也就是函数了，第二个参数制定了输出的形状，第三个参数则是指定了传入函数数据的类型。一般这个函数与lambda函数放在一起使用，会使程序简洁一些。

以上~