• 2 向量运算Python中的实现
千次阅读
2021-01-13 18:46:45

在PyCharm中实现自己的线性代数包。

创建 Python Package ==> PlayLA

创建 向量类，函数库 ==> Vector.py

from ._global import EPSILON

import math

class Vector:

def __init__(self,lst):

self._values =list(lst)

@classmethod

def zero(cls,dim):

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

return cls([0] * dim)

def normalize(self):

'返回向量的单位向量'

if self.norm() < EPSILON:

raise ZeroDivisionError('Normalize error! norm is zero.')

return Vector(self._values) / self.norm()

def norm(self):

'返回向量的模'

return math.sqrt(sum(e**2 for e in self))

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

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

'Error in adding. length of vectors must be same.'

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

def __sub__(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, another)])

def __mul__(self, k):

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

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

def __truediv__(self, k):

'返回数量除法的结果向量：self / k'

return (1 / k) * 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))

验证函数功能是否完善。

创建一个文件 ==> main_vector.py

from playLA.Vector import Vector

if __name__ == '__main__':

vec = Vector([5,2])

print(vec)

print(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))

zero2 = Vector.zero(2)

print(zero2)

print('{} + {} = {}'.format(vec, zero2, vec + zero2))

print('norm({}) = {}'.format(vec,vec.norm()))

print('norm({}) = {}'.format(vec,vec2.norm()))

print('norm({}) = {}'.format(vec,zero2.norm()))

# 输出结果为

vec[0] = 5 , vec[1] = 2

(5, 2) + (3, 1) = (8, 3)

(5, 2) - (3, 1) = (2, 1)

(5, 2) * 3 = (15, 6)

3 * (5, 2) = (15, 6)

+(5, 2) = (5, 2)

-(5, 2) = (-5, -2)

原文链接:https://blog.csdn.net/IAN27/article/details/108236660

更多相关内容
• 向量向量 import numpy as np a = np.array([1,2,3,4]) print(type(a)) print(a) <class 'numpy.ndarray'> [1 2 3 4] 列向量向量 相当于一个 n×1n\times1n×1 的矩阵 import numpy as np a = np....

# 向量

## 行向量

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

<class 'numpy.ndarray'>
[1 2 3 4]


## 列向量

列向量 相当于一个 n × 1 n\times1 的矩阵

import numpy as np
a = np.array([[1,2,3,4]])
print(type(a))
print(a)
print(a.shape)
print(type(a.T))
print(a.T)
print(a.T.shape)

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


## 向量的加法

[ 1 2 3 ] + [ 5 6 7 ] = [ 6 8 10 ] \begin{bmatrix} 1 \\ 2 \\ 3 \end{bmatrix} + \begin{bmatrix} 5 \\ 6 \\ 7 \end{bmatrix} = \begin{bmatrix} 6 \\ 8 \\ 10 \end{bmatrix}

import numpy as np
u = np.array([[1,2,3]]).T
v = np.array([[5,6,7]]).T
print(u+v)

[[ 6]
[ 8]
[10]]


## 向量的数量乘法

3 × [ 1 2 3 ] = [ 3 6 9 ] 3 \times \begin{bmatrix} 1 \\ 2 \\ 3 \end{bmatrix} = \begin{bmatrix} 3 \\ 6 \\ 9 \end{bmatrix}

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

[[3]
[6]
[9]]


## 向量间的乘法

### 向量的内积(点乘) np.dot()

参与内积运算的两个向量必须维数相等
运算规则：先将对应位置上的元素相乘，然后合并相加
向量内积的最终运算结果是一个标量

( 3 5 2 ) ⋅ ( 1 4 7 ) = 3 × 1 + 5 × 4 + 2 × 7 = 37 \begin{pmatrix} 3 & 5 & 2 \end{pmatrix} \cdot \begin{pmatrix} 1 & 4 & 7 \end{pmatrix} = 3\times1 + 5\times4 + 2\times7 = 37

import numpy as np
u = np.array([3,5,2])
v = np.array([1,4,7])
print(np.dot(u,v))

37


### 二维向量的外积

表示两个向量张成的平行四边形的"面积",如果两个向量的夹角大于 18 0 ∘ 180^\circ , 则向量外积的运算结果为负

( 3 5 ) × ( 1 4 ) = 7 \begin{pmatrix} 3 & 5 \end{pmatrix} \times \begin{pmatrix} 1 & 4 \end{pmatrix} = 7

import numpy as np
u = np.array([3,5])
v = np.array([1,4])
print(np.cross(u,v))
print(type(np.cross(u,v)))
print(np.cross(u,v).shape)

7
<class 'numpy.ndarray'>
()


### 三维向量的外积

表示两个向量张成的平面的法向量，所得结果是向量

( 3 3 9 ) × ( 1 4 12 ) = ( 0 − 27 9 ) \begin{pmatrix} 3 & 3 & 9 \end{pmatrix} \times \begin{pmatrix} 1 & 4 & 12 \end{pmatrix} = \begin{pmatrix} 0 & -27 & 9 \end{pmatrix}

import numpy as np
u = np.array([3,3,9])
v = np.array([1,4,12])
print(np.cross(u,v))
print(type(np.cross(u,v)))
print(np.cross(u,v).shape)

[  0 -27   9]
<class 'numpy.ndarray'>
(3,)


## 向量的线性组合：先数乘后叠加

3 × [ 1 2 3 ] + 4 × [ 4 5 6 ] + 5 × [ 7 8 9 ] = [ 54 66 78 ] 3 \times \begin{bmatrix} 1 \\ 2 \\ 3 \end{bmatrix} + 4\times \begin{bmatrix} 4 \\ 5 \\ 6 \end{bmatrix} + 5\times \begin{bmatrix} 7 \\ 8 \\ 9 \end{bmatrix} = \begin{bmatrix} 54 \\ 66 \\ 78 \end{bmatrix}

import numpy as np
u = np.array([[1,2,3]]).T
v = np.array([[4,5,6]]).T
w = np.array([[7,8,9]]).T
print(3*u+4*v+5*w)

[[54]
[66]
[78]]

展开全文
• 答：数字的加、减、乘、除的基本运算同理，上一篇学习了什么是向量之后，我们接着来学习向量的基本运算我们先来看一个东西，如下图相信，很多人都不会陌生，我们高中学习物理的时候，都学习过平行四边形定则。...

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

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

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

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

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

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

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]

向量运算

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

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

returnresult

######## mothod 2:

defvector_sum(vecotrs):

######## mothod 3:

fromfunctoolsimportpartial

### 向量的数乘运算

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，这样就可以找到大神聚合的群，如果你只愿意别人帮助你，不愿意分享或者帮助别人，那就请不要加了，你把你会的告诉别人这是一种分享。

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

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

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

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

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

展开全文
• 代码层面编译执行层面硬件层面算法算法层面代码层面简单的 for 循环如下sum=0for x in range(10):sum+=x但我们知道 这种 1,2,3...n 相加有公式的 ,那 python 如果能提供一个这样的函数 sumRange, 速度就快了.def ...
• Python脚本语言中如何实现三维向量的加减，点乘，叉乘的运算呢？ 本例子将给大家介绍在类中调用函数的方法解决这个问题
• (1) 定义一个零向量（4维）： &gt;&gt;&gt;a=zeros(4) &gt;&gt;&gt;a array([0.,0.,0.,0.]) 定义一个List: b=[1,2,3,4] (2)向量可直接与List相加： &gt;&gt;&gt;c=a+b ...
• 引言几乎所有的语言，包括Matlab、Python、Java，甚至C++、C，都会有一些能够进行线性代数运算的包、库等等，而这些包或者库都是由一些具有博士、硕士学位的数值分析的专家开发的，非常优秀。当进行机器学习编码的...
• Python中，列表支持与整数的乘法运算，但表示的是列表元素的重复，并生成新列表，如：>>> [1,2,3]*3[1, 2, 3, 1, 2, 3, 1, 2, 3]Python列表不支持与整数的加、减、除运算，也不支持列表之间的减、乘、除操作，而...
• 即list1[0]乘以list2[0]然后相加并且以此类推 ist1 = [111,222,333,444,555,666,777,888,999] list2 = [999,777,555,333,111,888] count = 0 for i in range(100): #为了防止两个列表长度不一致 ...
• Pythonic的Python向量夹角余弦值计算 通过公式我们知道，cos⁡(x⃗,y⃗)=x⃗⋅y⃗∣x⃗∣×∣y⃗∣\cos{(\vec{x}, \vec{y})} = \frac{\vec{x}\cdot\vec{y}}{|\vec{x}|\times|\vec{y}|}cos(x,y​)=∣x∣×∣y​∣x⋅y...
• # 向量相对于投影向量的垂直向量  def component_orthogonal_to(self, basis):  try:  projection = self.component_parallel_to(basis)  return self.minus(projection)  except Exception as e:  if str(e) ...
• python学习笔记，包含一般函数-向量化函数-二元运算-ufunc对象
• 加法（减法）运算 向量 >>>a = np.asarray([1, 2, 3]) >>>b = np.asarray([1, 1, 1]) >>>a+b array([2, 3, 4]) 矩阵 >>>a = np.asarray([[1, 1, 1], [2, 2, 2]]) >>>...
• 患难与困苦是磨练人格的最高学府。——苏格拉底(公元前470年～公元前399年)Adversity and pinch are the highest institution of higher learning of ... 399)这里，我们使用专门用来处理数组array的Python包NumP...
• 向量空间夹角余弦值数学公式 欧氏空间中定义了标准内积,就是对应分量相乘之和.这一点也和2,3维空间中内积定义的一样. 那么向量a,b夹角的余弦为： cos=(ab的内积)/(|a||b|) 即：a,b的内积除以它们的模的乘积等于二者...
• #定义：向量化计算是一种特殊的并行计算的方式，它可以在同一时间执行多次操作，通常是对不同的数据执行同样的一个或一批指令，或者说把指令应用于一个数组/向量。 #1. 四则运算 #规则：相同位置的数据进行运算...
• 支持向量机，能在N维平面中，找到最明显得对数据进行分类的一个超平面！看下面这幅图： 如上图中，在二维平面中，有红和蓝两类点。要对这两类点进行分类，可以有很多种分类方法，就如同图中多条绿线，都
• ## Python中向量化运算

千次阅读 2019-07-02 15:19:46
#生成等差数列 #一般的赋值需要通过for函数 r1_10=range(1,10,1) for i in r1_10: print(i) import numpy numpy.arange(2,10,3) r=numpy.arange(2,10,3) #向量运算 ...#向量运算，比较运算 r...
• 向量范数与矩阵范数定义和python相关运算示例1.范数(norm)的意义要更好的理解范数，就要从函数、几何与矩阵的角度去理解。 我们都知道，函数与几何图形往往是有对应的关系，这个很好想象，特别是在三维以下的空间内...
• 这样仅仅用简洁的表达式就可以代替Python的for循环。 我们先使用NumPy的random.normalvariate()生成一个平均收盘股价为10元（即期望为10），振幅为1元（即标准差为1），样本数量为1000的正态分布随机数组，如下所示...
• 第一节 构造函数通过创建一个二维向量的类(或结构体)，实现向量的表示及其运算。1. 首先，将类命名为“Vector2D”2. 添加两个属性 X 和 Y ，分别表示二维向量的两个分量3. 实现构造函数，实例化时即初始化 X，Y 的值...
• python 向量交叉乘积与模计算 import numpy as np # 二维向量 交叉乘积 hxv = np.random.randint(1, 10, (3, 2), np.int32) hmv = np.random.randint(1, 10, (3, 2), np.int32) print('向量数组一\n', hxv) print('...
• 向量向量化指的是将需要循环才能操作数组的 Python 函数转化为直接操作整个数组的函数。向量化能够使得程序更短、可读性更好，且程序的运行速度更快
• 余弦相似度 import numpy as np def cos_sim(vector_a, vector_b): """ 计算两个向量之间的余弦相似度 :param vector_a: 向量 a :param vector_b: 向量 b :return: sim """ vector_a = np.mat(vector_a) vector_b =...
• 今天小编就为大家分享一篇python 实现多维数组转向量，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
• Language)提供Device管理、Context管理、Stream管理、内存管理、模型加载与执行、算子加载与执行、媒体数据处理等python API库供用户开发深度神经网络应用，用于实现目标识别、图像分类等功能。用户可以通过第三方...
• python中 为什么 ‘>>> -5%3 1 ’>> 5%-3 -1 原来,python中，符号 % 其实是取模，不是取余。 取余与取模的差别： 当两个数均为正数是，取余与取模的结果是一致的，而当两个数一正一负时结果就不一样...

...