python全1向量_Python学线性代数（1）向量相关话题

实现我们自己的向量类

Vector.py

class Vector:

def __init__(self, lst):

self._values = lst

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) = {}".format(len(vec)))

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

05-Implement-Vector-Operations

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

建立main_vector.py测试：

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

08-Implementation-of-Zero-Vector

class Vector:

def __init__(self, lst):

self._values = list(lst)

@classmethod

def zero(cls, dim):

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

return cls([0] * dim)

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, 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))

zero2 = Vector.zero(2)

print(zero2)

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

关于向量的更多话题

02-Normalization-Implementation

_globals.py

EPSILON = 1e-8

init.py

from ._globals import EPSILON

Vector.py

import math

from ._globals import EPSILON

class Vector:

def __init__(self, lst):

self._values = list(lst)

@classmethod

def zero(cls, dim):

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

return cls([0] * dim)

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, 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 norm(self):

"""返回向量的模"""

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

def normalize(self):

"""返回向量的单位向量"""

if self.norm() < EPSILON:

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

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

# return 1 / self.norm() * Vector(self._values)

# return Vector([e / self.norm() for e in self])

def __mul__(self, k):

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

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

def __rmul__(self, k):

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

return self * k

def __truediv__(self, k):

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

return (1 / k) * self

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

05-Implementations-of-Dot-Product

import math

from ._globals import EPSILON

class Vector:

def __init__(self, lst):

self._values = list(lst)

@classmethod

def zero(cls, dim):

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

return cls([0] * dim)

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, 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 norm(self):

"""返回向量的模"""

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

def normalize(self):

"""返回向量的单位向量"""

if self.norm() < EPSILON:

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

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

def dot(self, another):

"""向量点乘，返回结果标量"""

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

"Error in dot product. Length of vectors must be same."

return sum(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 __truediv__(self, k):

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

return (1 / k) * self

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

zero2 = Vector.zero(2)

print(zero2)

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

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

print("norm({}) = {}".format(vec2, vec2.norm()))

print("norm({}) = {}".format(zero2, zero2.norm()))

print("normalize {} is {}".format(vec, vec.normalize()))

print(vec.normalize().norm())

print("normalize {} is {}".format(vec2, vec2.normalize()))

print(vec2.normalize().norm())

try:

zero2.normalize()

except ZeroDivisionError:

print("Cannot normalize zero vector {}.".format(zero2))

print(vec.dot(vec2))

07-Vectors-in-Numpy

main_numpy_vector.py

import numpy as np

if __name__ == "__main__":

print(np.__version__)

# np.array 基础

lst = [1, 2, 3]

lst[0] = "Linear Algebra"

print(lst)

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

print(vec)

# vec[0] = "Linear Algebra"

# vec[0] = 666

# print(vec)

# np.array的创建

print(np.zeros(5))

print(np.ones(5))

print(np.full(5, 666))

# np.array的基本属性

print(vec)

print("size =", vec.size)

print("size =", len(vec))

print(vec[0])

print(vec[-1])

print(vec[0: 2])

print(type(vec[0: 2]))

# np.array的基本运算

vec2 = np.array([4, 5, 6])

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

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

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

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

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

print(np.linalg.norm(vec))

print(vec / np.linalg.norm(vec))

print(np.linalg.norm(vec / np.linalg.norm(vec)))

# zero3 = np.zeros(3)

# print(zero3 / np.linalg.norm(zero3))