我们在小学的时候，学完了什么是数字之后，接下来学习的是什么呢？

答：数字的加、减、乘、除的基本运算

同理，上一篇学习了什么是向量之后，我们接着来学习向量的基本运算

我们先来看一个东西，如下图

相信，很多人都不会陌生，我们高中学习物理的时候，都学习过平行四边形定则。两个力合成时，以表示这两个力的线段为邻边作平行四边形，这个平行四边形的对角线就表示合力的大小和方向，这就叫做平行四边形定则(Parallelogram law)。

但是为什么会这样啊？大家想过没有？？

虽然可以从不同的角度，不同的学科来解释，但是这里数学的几何来直观的解释：

我们知道力是矢量，也就是向量，既有大小又有方向

我们使用下面数学的这个例子来说明平行四边形法则：

我们可以理解为：

从原点出发，先走到(5，2)这个位置，再从(5，2)这个位置出发，再走(2，5)这个向量所对应的这么多的位移，最终我们到达的这个位置就是向量加法的结果最终的结果相当于从(0，0)这个位置到达了(7，7)这个位置的位移

连接起点(0，0)和终点(7，7)就有一个三角形的形状，这不就是我们物理中学习的三角形定则吗？

其实；三角形定则是平行四边形定则的简化。平行四边形定则的实质是一样的 ，都是矢量运算法则的表述方式。

如果我们在三角形的另外一侧相应的补上和这两个向量平行的两条边的话，就出现了平行四边形

总结这个过程：

从原点(0，0)出发，先向x轴方向移动了5个单位，再向y轴移动了2个单位，这个就是(5，2)这个向量表示的含义

接着，从(5，2)这个坐标点，先向x轴移动2个单位，再向y轴移动5个单位，(2，5)向量表示的含义

最终我们从原点(0，0)，总共向x轴移动了7个单位，总共向y轴移动了7个单位，这就是我们得到的向量(7，7)

总结出结论：

抽象，从2维扩展到3维：

同样扩展到n维：

这里向量的减法就不做说明和演示了，因为减法的本质其实可以理解为加法，因为“减去一个数相当于加上这个数的相反数”

向量的数量乘法：

总结：

下面使用Python来实现向量的基本运算：

class Vector:

def __init__(self, lst):

self._values = list(lst)

def __add__(self, another):

"""向量加法，返回结果向量"""

assert len(self) == len(another), \

"Error in adding. Length of vectors must be same."

# return Vector([a + b for a, b in zip(self._values, another._values)])

return Vector([a + b for a, b in zip(self, another)])

def __sub__(self, another):

"""向量减法，返回结果向量"""

assert len(self) == len(another), \

"Error in subtracting. Length of vectors must be same."

return Vector([a - b for a, b in zip(self, another)])

def __mul__(self, k):

"""返回数量乘法的结果向量：self * k"""

return Vector([k * e for e in self])

def __rmul__(self, k):

"""返回数量乘法的结果向量：k * self"""

return self * k

def __pos__(self):

"""返回向量取正的结果向量"""

return 1 * self

def __neg__(self):

"""返回向量取负的结果向量"""

return -1 * self

def __iter__(self):

"""返回向量的迭代器"""

return self._values.__iter__()

def __getitem__(self, index):

"""取向量的第index个元素"""

return self._values[index]

def __len__(self):

"""返回向量长度(有多少个元素)"""

return len(self._values)

def __repr__(self):

return "Vector({})".format(self._values)

def __str__(self):

return "({})".format(", ".join(str(e) for e in self._values))

测试代码：

from playLA.Vector import Vector

if __name__ == "__main__":

vec = Vector([5, 2])

print(vec)

print("len(vec) ={}".format(len(vec)))

print("vec[0] ={}, vec[1] ={}".format(vec[0], vec[1]))

vec2 = Vector([3, 1])

print("{}+{}={}".format(vec, vec2, vec + vec2))

print("{}-{}={}".format(vec, vec2, vec - vec2))

print("{}*{}={}".format(vec, 3, vec * 3))

print("{}*{}={}".format(3, vec, 3 * vec))

print("+{}={}".format(vec, +vec))

print("-{}={}".format(vec, -vec))

运行结果：

向量运算的基本性质：

回忆我们⼩学时学习的数的运算，我们也要先有数的运算的相关性质，之后才敢进⾏更加复杂的运算

⽐如：加法交换律，乘法交换律，加法结合律，乘法结合律，等等

对于向量运算，我们也要这么做

零向量

Python实现零向量：

只需要在我们的Vector方法中添加一个这样的类方法：

@classmethod

def zero(cls, dim):

"""返回一个dim维的零向量"""

return cls([0] * dim)

测试效果：

总结：

两个视角看待了向量：有向的线段

高维空间中的数据点

两个视角可以相互转换

Python中的线性代数运算

这里，为了熟悉Python语言的特性，我们采用一种最原始的方式去定义线性代数运算的相关函数。

如果是真实应用场景，则直接使用NumPy的函数即可。

1.向量

创建一个向量

我们可以把Python中的向量理解为有限维空间中的点。

height_weight_age=[70,170,40]

grades=[95,80,75,62]

向量运算

#### 加法定义——两个向量

defvector_add(v,w):

"""add coresponding elements"""

return[v_i+w_i

forv_i,w_iinzip(v,w)]

#### 减法定义

defvector_substract(v,w):

"""substracts coresponding elements"""

return[v_i-w_i

forv_i,w_iinzip(v,w)]

#### 向量加法——多个向量(list of vectors)

####### method 1:

defvector_sum(vectors):

"""sums of all coresponding elements"""

result=vectors[0]

forvectorinvectors[1:]:

result=vector_add(result,vector)

returnresult

######## mothod 2:

defvector_sum(vecotrs):

returnreduce(vector_add,vectors)

######## mothod 3:

fromfunctoolsimportpartial

vector_sum=partial(reduce,vector_add)

### 向量的数乘运算

defscalar_multiply(c,v):

"""c is a number,v is a vector"""

return[c*v_iforv_iinv]

### 向量的均值运算

defvector_mean(vectors):

"""compute the vector whose i-th element is the mean of

the i-th elements of the input vectors"""

n=len(vecotrs)

returnscalar_multiply(1/n,vector_sum())

### 向量的点乘

defdot(v,w):

returnsum(v_i*w_i

forv_i,w_iinzip(v,w))

### 向量的平房和

defsum_of_squares(v):

"""v_1*v_1+v_2*v_2+...+v_n*v_n"""

returndot(v,v)

### 向量的模

importmath

defmagnitude(v):

returnmath.sqrt(sum_of_squares(v))

### 向量的距离

##### method 1:

defsquared_distance(v,w):

""""""

returnsum_of_squares(vector_substract(v,w))

##### method 2:

defdistance(v,w):

returnmagnitude(vector_substract(v,w))

##### method 3:

defdistance(v,w):

returnmath.sqrt(squared_distance(v,w))

2.矩阵

矩阵是一个二维的数字集合。我们可以通过列表的列表来表达一个矩阵，这样，内层列表是等长的，并且每个内层列表表达矩阵的一行。

### 定义一个向量

A=[[1,2,3],

[4,5,6]]

B=[[1,2],

[3,4],

[7,8]]

### 获得矩阵的行数和列数

defshape(A):

num_rows=len(A)

num_cols=len(A[0])ifAelse0

returnnum_rows,num_cols

### 提取某一行

defget_row(A,i):

returnA[i]

###提取某一列

defget_column(A,j):

return[A_i[j]# j-th element of row A_i

forA_iinA]# for each row in A

### 定制特殊矩阵生成函数：如单位矩阵

defmake_matrix(num_rows,num_cols,entry_fn):

"""return a matrix whose (i,j)-th entry is entry_fn(i,j)"""

return[[entry_fn(i,j)

forjinrange(num_cols)]

foriinrange(num_rows)]

###

defis_diagonal(i,j):

return1ifi==jelse0

make_matrix(5,5,is_diagonal)

[[1,0,0,0,0],

[0,1,0,0,0],

[0,0,1,0,0],

[0,0,0,1,0],

[0,0,0,0,1]]我有建立一个python学习交流群，在群里我们相互帮助，相互关心，相互分享内容，这样出问题帮助你的人就比较多，群号是301，还有056，最后是069，这样就可以找到大神聚合的群，如果你只愿意别人帮助你，不愿意分享或者帮助别人，那就请不要加了，你把你会的告诉别人这是一种分享。

学习是对自己最好的投资，而机会属于有准备的人，这是一个看脸的时代，但最终拼的是实力。人和人之间的差距不在于智商，而在于如何利用业余时间，所以没有等出来的辉煌，只有干出来的精彩。其实只要你想学习，什么时候开始都不晚，不要担心这担心那，你只需努力，剩下的交给时间，而你之所以还没有变强，只因你还不够努力，要记得付出不亚于任何人的努力。

你的想法再精彩，那是想法的价值

而你的价值，永远体现在行动之中

如果还停留在想的价值中，请赶快行动，

如果你学习还停止在原处，请咨询我帮助你开始