线性代数学习

向量：一组数的基本表示方法 和向量相对应，一个数字，成为标量 向量是线性代数研究的基本元素

import math
from ._global import EPSILON


class Vector:
    def __init__(self, lst):
        self._values = list(lst)  # 相当于复制了一次lst，使得这个类更符合不可更改类型

    @classmethod
    def zero(cls, dim):
        """返回一个dim维的零向量"""
        return cls([0] * dim)

    def norm(self):
        """返回向量的模"""
        return math.sqrt(sum(e ** 2 for e in self))

    def normalize(self):
        """返回向量的单位向量"""
        # if self.norm() == 0:
        if self.norm() < EPSILON:
            raise ZeroDivisionError("Normalize error! norm is zero!")
        # return Vector([e / self.norm() for e in self])
        return 1 / self.norm() * Vector(self._values)

    def __add__(self, another):
        """向量加法，返回结果向量"""
        assert len(self) == len(another), \
            "Error in adding. Length of vectors must be same."
        # 因为实现了__iter__，就不这样写了
        # 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, other):
        assert len(self) == len(other), \
            "Error in adding. Length of vectors must be same."
        return Vector([a - b for a, b in zip(self, other)])

    def __mul__(self, k):
        """返回数量乘法的结果向量：self * k"""
        return Vector([k * e for e in self])

    def dot(self, another):
        """向量点乘，返回结果标量"""
        assert len(self) == len(another), \
            "Error in adding. Length of vectors must be same."
        return sum(a * b for a, b in zip(self, another))

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

复制代码

在实现这个向量类时，学习到很多实现细节：向量类设计为不可更改类（在加法运算时，返回新的类，而不是对原有的self._values进行更改）。 那在构造函数中，传入一个list，当list变化时，便会影响self._values的值。所以用list(lst)方式进行了一次复制。

向量的模：即向量的大小

单位向量：长度保持为1的向量

矩阵

矩阵是向量的拓展，就像向量是数的拓展

矩阵的基本运算：