前言

很明显这是接着（一）的续集，这是numpy的基础学习。上一篇主要说了numpy的创造和合并，以及numpy数组的合并和分解。主要是说比array.array差不多，但是array没有那么多复杂的功能。numpy.array 有这个。这里说的是矩阵一些通用功能

Universal Function

把数组当作矩阵或者向量进行计算叫做Universal Function。这里会把数组中所有的元素进行计算。

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

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

除法

X/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]])

取整除法

X//2

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

幂运算

X ** 2

array([[  1,   4,   9,  16,  25],
       [ 36,  49,  64,  81, 100],
       [121, 144, 169, 196, 225]])

取余

X % 2
array([[1, 0, 1, 0, 1],
       [0, 1, 0, 1, 0],
       [1, 0, 1, 0, 1]])

等等

np.abs(X)
np.sin(X)
np.exp(X
np.power(X,2)
np.log(X)
np.log2(X)
np.lig10(X)

矩阵间的运算

矩阵之间的运算无非就是矩阵的+ ，-，*，／

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


B=np.full((2,2),fill_value=10)
B 
array([[10, 10],
       [10, 10]])

这里无论是加减乘除都是相对应元素上的加减乘除。

A+B
array([[10, 11],
       [12, 13]])
A-B
A*B
A/B 

如果要真正做矩阵的乘法的话，维度一定要对应起来。

A.dot(B)
array([[ 0, 10],
       [20, 30]])

不光可以求两个矩阵的计算。
还可以求矩阵的转置和矩阵的逆

求转置

A.T
array([[0, 2],
       [1, 3]])

求矩阵的逆

这个就比较麻烦，因为我们学过矩阵知道，方阵才有逆。

invA=np.linalg.inv(A)
intvA

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

如果矩阵不是 方阵可以求伪逆

X=np.arange(16).reshape([2,8])
array([[ 0,  1,  2,  3,  4,  5,  6,  7],
       [ 8,  9, 10, 11, 12, 13, 14, 15]])
invX=np.linalg.pinv(X)
invX

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,  -1.04083409e-17],
       [  6.99404762e-02,  -1.04166667e-02],
       [  1.04166667e-01,  -2.08333333e-02]])

向量与矩阵之间的运算

这是机器学习中常见的运算。
这里值得一说的是一个一维向量就是一个numpy的array，但是我们学过的向量也分行向量 、列向量。其实numpy可以自己判断！
首先看看一些“奇怪”的设计。

向量与矩阵的减法

这个怎么可能呢？违背常理，线性代数中只有两个矩阵维度相同才能做这样的操作不是么？

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

array([1, 2])

A=np.arange(4).reshape(2,2)
A

array([[0, 1],
       [2, 3]])

v+A
array([[1, 3],
       [3, 5]])

我们发现numpy中向量与矩阵的加法就是矩阵的每一行的每个元素加上这个向量的每个元素。
相当于

np.vstack([v]*A.shape[0])+A

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

其实向量的堆叠不需要使用vstack 可以用专门的函数tile
它可以把向量看成一个单元，然后进行单元堆叠

np.tile(v,(2,1)) #行上堆叠两次，列上一次
array([[1, 2],
       [1, 2]])

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

向量与矩阵的乘法

numpy可以自动判断向量是行向量还是列向量体现在矩阵的乘法。
看

v.dot(A) # E行*列，矩阵乘法
array([4, 7])

这里就当成了一个行向量。

A.dot(v)
array([2, 8])

这里就成了列向量。神奇！