numpy--矩阵运算

一.单个矩阵之间的运算

import numpy as np
a=np.array([1,2,3])
a*2

'''
array([2, 4, 6])
'''

b=np.arange(1,16).reshape(3,5)

'''array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10],
       [11, 12, 13, 14, 15]])'''

b-1
'''
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
'''
b/2

'''
array([[0.5, 1. , 1.5, 2. , 2.5],
       [3. , 3.5, 4. , 4.5, 5. ],
       [5.5, 6. , 6.5, 7. , 7.5]])
'''
b//2

'''
array([[0, 1, 1, 2, 2],
       [3, 3, 4, 4, 5],
       [5, 6, 6, 7, 7]], dtype=int32)
'''
np.sin(b)

'''array([[ 0.84147098,  0.90929743,  0.14112001, -0.7568025 , -0.95892427],
       [-0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849, -0.54402111],
       [-0.99999021, -0.53657292,  0.42016704,  0.99060736,  0.65028784]])
'''
np.cos(b)

'''
array([[ 0.54030231, -0.41614684, -0.9899925 , -0.65364362,  0.28366219],
       [ 0.96017029,  0.75390225, -0.14550003, -0.91113026, -0.83907153],
       [ 0.0044257 ,  0.84385396,  0.90744678,  0.13673722, -0.75968791]])
'''

np.tan(b)

'''
array([[ 1.55740772e+00, -2.18503986e+00, -1.42546543e-01,
         1.15782128e+00, -3.38051501e+00],
       [-2.91006191e-01,  8.71447983e-01, -6.79971146e+00,
        -4.52315659e-01,  6.48360827e-01],
       [-2.25950846e+02, -6.35859929e-01,  4.63021133e-01,
         7.24460662e+00, -8.55993401e-01]])
'''

np.log(b)

'''
array([[0.        , 0.69314718, 1.09861229, 1.38629436, 1.60943791],
       [1.79175947, 1.94591015, 2.07944154, 2.19722458, 2.30258509],
       [2.39789527, 2.48490665, 2.56494936, 2.63905733, 2.7080502 ]])
'''
np.log10(b)

'''
array([[0.        , 0.30103   , 0.47712125, 0.60205999, 0.69897   ],
       [0.77815125, 0.84509804, 0.90308999, 0.95424251, 1.        ],
       [1.04139269, 1.07918125, 1.11394335, 1.14612804, 1.17609126]])
'''

1/b
'''
array([[1.        , 0.5       , 0.33333333, 0.25      , 0.2       ],
       [0.16666667, 0.14285714, 0.125     , 0.11111111, 0.1       ],
       [0.09090909, 0.08333333, 0.07692308, 0.07142857, 0.06666667]])
'''

 

二.多个矩阵之间的运算

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

'''
array([[1, 2],
       [3, 4]])
'''
B=np.full((2,2),10)

'''
array([[10, 10],
       [10, 10]])
'''
A+B

'''
array([[11, 12],
       [13, 14]])
'''
A*B  #这个不是矩阵的乘法（是numpy模块中）

'''
array([[10, 20],
       [30, 40]])
'''
#矩阵之间的乘法运算需要调用函数来进行dot()函数来进行

A.dot(B)

'''
array([[30, 30],
       [70, 70]])
'''
A/B

'''
array([[0.1, 0.2],
       [0.3, 0.4]])
'''
#矩阵之间的乘法运算要符合矩阵能够想乘的规则，既 --前面一个矩阵的列数等于后面一个矩阵的行数

#求矩阵的转秩
A.T

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

三.向量和矩阵之间的运算

v=np.array([1,2])

'''
array([1, 2])
'''

v+A

'''
array([[2, 4],
       [4, 6]])
'''
v*2

'''
array([2, 4])
'''
np.vstack([v]*A.shape[0])


'''
array([[1, 2],
       [1, 2]])
'''
np.tile(v,(2,1))

'''
array([[1, 2],
       [1, 2]])
'''
np.vstack([v]*A.shape[0])+A
'''
array([[2, 4],
       [4, 6]])
'''
np.tile(v,(2,1))+A

'''
array([[2, 4],
       [4, 6]])
'''
v*A

'''
array([[1, 4],
       [3, 8]])
'''
v.dot(A)

'''
array([ 7, 10])
'''

A.dot(v)
'''
array([ 5, 11])
'''

#矩阵的逆
A=array([[1, 2],
       [3, 4]])

np.linalg.inv(A)
'''
array([[-2. ,  1. ],
       [ 1.5, -0.5]])
'''
invA=np.linalg.inv(A)
A.dot(invA)

'''
array([[1.0000000e+00, 0.0000000e+00],
       [8.8817842e-16, 1.0000000e+00]])
'''

invA.dot(A)

'''
array([[1.00000000e+00, 0.00000000e+00],
       [1.11022302e-16, 1.00000000e+00]])
'''


#伪逆矩阵
#求矩阵的逆矩阵的要求是矩阵必须是一个方阵，如果不是方阵，则没有逆矩阵，如果需要强行就逆矩阵的话，则是一个伪的逆矩阵

#例如
X=np.arange(16).reshape(2,8)
'''
array([[ 0,  1,  2,  3,  4,  5,  6,  7],
       [ 8,  9, 10, 11, 12, 13, 14, 15]])
'''
np.linalg.inv(X)  #报错


np.linalg.pinv(X)


'''
array([[-1.35416667e-01,  5.20833333e-02],
       [-1.01190476e-01,  4.16666667e-02],
       [-6.69642857e-02,  3.12500000e-02],
       [-3.27380952e-02,  2.08333333e-02],
       [ 1.48809524e-03,  1.04166667e-02],
       [ 3.57142857e-02, -7.30583920e-18],
       [ 6.99404762e-02, -1.04166667e-02],
       [ 1.04166667e-01, -2.08333333e-02]])
'''

pinvX=np.linalg.pinv(X)
pinvX.shape
'''(8, 2)'''

X.dot(pinvX)

'''
array([[ 1.00000000e+00, -2.77555756e-16],
       [ 1.69309011e-15,  1.00000000e+00]])
'''

pinvX.dot(X)

'''
array([[ 4.16666667e-01,  3.33333333e-01,  2.50000000e-01,
         1.66666667e-01,  8.33333333e-02,  4.78783679e-16,
        -8.33333333e-02, -1.66666667e-01],
       [ 3.33333333e-01,  2.73809524e-01,  2.14285714e-01,
         1.54761905e-01,  9.52380952e-02,  3.57142857e-02,
        -2.38095238e-02, -8.33333333e-02],
       [ 2.50000000e-01,  2.14285714e-01,  1.78571429e-01,
         1.42857143e-01,  1.07142857e-01,  7.14285714e-02,
         3.57142857e-02,  2.84494650e-16],
       [ 1.66666667e-01,  1.54761905e-01,  1.42857143e-01,
         1.30952381e-01,  1.19047619e-01,  1.07142857e-01,
         9.52380952e-02,  8.33333333e-02],
       [ 8.33333333e-02,  9.52380952e-02,  1.07142857e-01,
         1.19047619e-01,  1.30952381e-01,  1.42857143e-01,
         1.54761905e-01,  1.66666667e-01],
       [-5.84467136e-17,  3.57142857e-02,  7.14285714e-02,
         1.07142857e-01,  1.42857143e-01,  1.78571429e-01,
         2.14285714e-01,  2.50000000e-01],
       [-8.33333333e-02, -2.38095238e-02,  3.57142857e-02,
         9.52380952e-02,  1.54761905e-01,  2.14285714e-01,
         2.73809524e-01,  3.33333333e-01],
       [-1.66666667e-01, -8.33333333e-02, -2.22044605e-16,
         8.33333333e-02,  1.66666667e-01,  2.50000000e-01,
         3.33333333e-01,  4.16666667e-01]])
'''