Python 定义一个完整的 vector 类

最新推荐文章于 2024-07-11 09:11:19 发布
最新推荐文章于 2024-07-11 09:11:19 发布
阅读量7.2k 收藏 12
点赞数 3
分类专栏： Python学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012193416/article/details/89396261
版权

第一版：
 

# BEGIN VECTOR_V1
from array import array
import reprlib
import math


class Vector:
    typecode = 'd'

    def __init__(self, components):
        self._components = array(self.typecode, components)  # <1>

    def __iter__(self):
        return iter(self._components)  # <2>

    def __repr__(self):
        components = reprlib.repr(self._components)  # <3>
        components = components[components.find('['):-1]  # <4>
        return 'Vector({})'.format(components)

    def __str__(self):
        return str(tuple(self))

    def __bytes__(self):
        return (bytes([ord(self.typecode)]) +
                bytes(self._components))  # <5>

    def __eq__(self, other):
        return tuple(self) == tuple(other)

    def __abs__(self):
        return math.sqrt(sum(x * x for x in self))  # <6>

    def __bool__(self):
        return bool(abs(self))

    @classmethod
    def frombytes(cls, octets):
        typecode = chr(octets[0])
        memv = memoryview(octets[1:]).cast(typecode)
        return cls(memv)  # <7>
# END VECTOR_V1

第二版： 可切片的序列

from array import array
import reprlib
import math
import numbers


class Vector:
    typecode = 'd'

    def __init__(self, components):
        self._components = array(self.typecode, components)

    def __iter__(self):
        return iter(self._components)

    def __repr__(self):
        components = reprlib.repr(self._components)
        components = components[components.find('['):-1]
        return 'Vector({})'.format(components)

    def __str__(self):
        return str(tuple(self))

    def __bytes__(self):
        return (bytes([ord(self.typecode)]) +
                bytes(self._components))

    def __eq__(self, other):
        return tuple(self) == tuple(other)

    def __abs__(self):
        return math.sqrt(sum(x * x for x in self))

    def __bool__(self):
        return bool(abs(self))

# BEGIN VECTOR_V2
    def __len__(self):
        return len(self._components)

    def __getitem__(self, index):
        cls = type(self)  # <1>
        if isinstance(index, slice):  # <2>
            return cls(self._components[index])  # <3>
        elif isinstance(index, numbers.Integral):  # <4>
            return self._components[index]  # <5>
        else:
            msg = '{cls.__name__} indices must be integers'
            raise TypeError(msg.format(cls=cls))  # <6>
# END VECTOR_V2

    @classmethod
    def frombytes(cls, octets):
        typecode = chr(octets[0])
        memv = memoryview(octets[1:]).cast(typecode)
        return cls(memv)

V2中最大的变化在于实现 __len__ 和 __getitem__ 从而实现了切片功能，这两个方法也是 vector 表现为序列所必需的

若使用 [1:4]，返回的是 slice ，slice 是内置的类型，通过审查 slice ，发现它有 start,stop和step 数据属性，以及 indices 方法。indices 中，给定长度为 len 的序列，计算 s 标识的扩展切片的起始和结束索引，以及步幅，超过边界的索引会被截掉。

 Vector 第三版： 动态存取属性

from array import array
import reprlib
import math
import numbers


class Vector:
    typecode = 'd'

    def __init__(self, components):
        self._components = array(self.typecode, components)

    def __iter__(self):
        return iter(self._components)

    def __repr__(self):
        components = reprlib.repr(self._components)
        components = components[components.find('['):-1]
        return 'Vector({})'.format(components)

    def __str__(self):
        return str(tuple(self))

    def __bytes__(self):
        return (bytes([ord(self.typecode)]) +
                bytes(self._components))

    def __eq__(self, other):
        return tuple(self) == tuple(other)

    def __abs__(self):
        return math.sqrt(sum(x * x for x in self))

    def __bool__(self):
        return bool(abs(self))

    def __len__(self):
        return len(self._components)

    def __getitem__(self, index):
        cls = type(self)
        if isinstance(index, slice):
            return cls(self._components[index])
        elif isinstance(index, numbers.Integral):
            return self._components[index]
        else:
            msg = '{.__name__} indices must be integers'
            raise TypeError(msg.format(cls))

# BEGIN VECTOR_V3_GETATTR
    shortcut_names = 'xyzt'

    def __getattr__(self, name):
        cls = type(self)  # <1>
        if len(name) == 1:  # <2>
            pos = cls.shortcut_names.find(name)  # <3>
            if 0 <= pos < len(self._components):  # <4>
                return self._components[pos]
        msg = '{.__name__!r} object has no attribute {!r}'  # <5>
        raise AttributeError(msg.format(cls, name))
# END VECTOR_V3_GETATTR

# BEGIN VECTOR_V3_SETATTR
    def __setattr__(self, name, value):
        cls = type(self)
        if len(name) == 1:  # <1>
            if name in cls.shortcut_names:  # <2>
                error = 'readonly attribute {attr_name!r}'
            elif name.islower():  # <3>
                error = "can't set attributes 'a' to 'z' in {cls_name!r}"
            else:
                error = ''  # <4>
            if error:  # <5>
                msg = error.format(cls_name=cls.__name__, attr_name=name)
                raise AttributeError(msg)
        super().__setattr__(name, value)  # <6>

# END VECTOR_V3_SETATTR

    @classmethod
    def frombytes(cls, octets):
        typecode = chr(octets[0])
        memv = memoryview(octets[1:]).cast(typecode)
        return cls(memv)

__getattr__ 和 __setattr__ ,前者是为了获取 vector 分量，后者是对已有分量的保护，v.x 不可以直接赋值，因为 x已经成为v的属性了，v.x 的值改变了，但是v的值未改变。

Vector 第四版： 散列和快速等值测试

from array import array
import reprlib
import math
import numbers
import functools
import operator


class Vector:
    typecode = 'd'

    def __init__(self, components):
        self._components = array(self.typecode, components)

    def __iter__(self):
        return iter(self._components)

    def __repr__(self):
        components = reprlib.repr(self._components)
        components = components[components.find('['):-1]
        return 'Vector({})'.format(components)

    def __str__(self):
        return str(tuple(self))

    def __bytes__(self):
        return (bytes([ord(self.typecode)]) +
                bytes(self._components))

    def __eq__(self, other):
        return (len(self) == len(other) and
                all(a == b for a, b in zip(self, other)))

    def __hash__(self):
        hashes = (hash(x) for x in self)
        return functools.reduce(operator.xor, hashes, 0)

    def __abs__(self):
        return math.sqrt(sum(x * x for x in self))

    def __bool__(self):
        return bool(abs(self))

    def __len__(self):
        return len(self._components)

    def __getitem__(self, index):
        cls = type(self)
        if isinstance(index, slice):
            return cls(self._components[index])
        elif isinstance(index, numbers.Integral):
            return self._components[index]
        else:
            msg = '{cls.__name__} indices must be integers'
            raise TypeError(msg.format(cls=cls))

    shortcut_names = 'xyzt'

    def __getattr__(self, name):
        cls = type(self)
        if len(name) == 1:
            pos = cls.shortcut_names.find(name)
            if 0 <= pos < len(self._components):
                return self._components[pos]
        msg = '{.__name__!r} object has no attribute {!r}'
        raise AttributeError(msg.format(cls, name))

    @classmethod
    def frombytes(cls, octets):
        typecode = chr(octets[0])
        memv = memoryview(octets[1:]).cast(typecode)
        return cls(memv)

第五版： 格式化

# BEGIN VECTOR_V5
"""
A multi-dimensional ``Vector`` class, take 5

A ``Vector`` is built from an iterable of numbers::

    >>> Vector([3.1, 4.2])
    Vector([3.1, 4.2])
    >>> Vector((3, 4, 5))
    Vector([3.0, 4.0, 5.0])
    >>> Vector(range(10))
    Vector([0.0, 1.0, 2.0, 3.0, 4.0, ...])


Tests with 2-dimensions (same results as ``vector2d_v1.py``)::

    >>> v1 = Vector([3, 4])
    >>> x, y = v1
    >>> x, y
    (3.0, 4.0)
    >>> v1
    Vector([3.0, 4.0])
    >>> v1_clone = eval(repr(v1))
    >>> v1 == v1_clone
    True
    >>> print(v1)
    (3.0, 4.0)
    >>> octets = bytes(v1)
    >>> octets
    b'd\\x00\\x00\\x00\\x00\\x00\\x00\\x08@\\x00\\x00\\x00\\x00\\x00\\x00\\x10@'
    >>> abs(v1)
    5.0
    >>> bool(v1), bool(Vector([0, 0]))
    (True, False)


Test of ``.frombytes()`` class method:

    >>> v1_clone = Vector.frombytes(bytes(v1))
    >>> v1_clone
    Vector([3.0, 4.0])
    >>> v1 == v1_clone
    True


Tests with 3-dimensions::

    >>> v1 = Vector([3, 4, 5])
    >>> x, y, z = v1
    >>> x, y, z
    (3.0, 4.0, 5.0)
    >>> v1
    Vector([3.0, 4.0, 5.0])
    >>> v1_clone = eval(repr(v1))
    >>> v1 == v1_clone
    True
    >>> print(v1)
    (3.0, 4.0, 5.0)
    >>> abs(v1)  # doctest:+ELLIPSIS
    7.071067811...
    >>> bool(v1), bool(Vector([0, 0, 0]))
    (True, False)


Tests with many dimensions::

    >>> v7 = Vector(range(7))
    >>> v7
    Vector([0.0, 1.0, 2.0, 3.0, 4.0, ...])
    >>> abs(v7)  # doctest:+ELLIPSIS
    9.53939201...


Test of ``.__bytes__`` and ``.frombytes()`` methods::

    >>> v1 = Vector([3, 4, 5])
    >>> v1_clone = Vector.frombytes(bytes(v1))
    >>> v1_clone
    Vector([3.0, 4.0, 5.0])
    >>> v1 == v1_clone
    True


Tests of sequence behavior::

    >>> v1 = Vector([3, 4, 5])
    >>> len(v1)
    3
    >>> v1[0], v1[len(v1)-1], v1[-1]
    (3.0, 5.0, 5.0)


Test of slicing::

    >>> v7 = Vector(range(7))
    >>> v7[-1]
    6.0
    >>> v7[1:4]
    Vector([1.0, 2.0, 3.0])
    >>> v7[-1:]
    Vector([6.0])
    >>> v7[1,2]
    Traceback (most recent call last):
      ...
    TypeError: Vector indices must be integers


Tests of dynamic attribute access::

    >>> v7 = Vector(range(10))
    >>> v7.x
    0.0
    >>> v7.y, v7.z, v7.t
    (1.0, 2.0, 3.0)

Dynamic attribute lookup failures::

    >>> v7.k
    Traceback (most recent call last):
      ...
    AttributeError: 'Vector' object has no attribute 'k'
    >>> v3 = Vector(range(3))
    >>> v3.t
    Traceback (most recent call last):
      ...
    AttributeError: 'Vector' object has no attribute 't'
    >>> v3.spam
    Traceback (most recent call last):
      ...
    AttributeError: 'Vector' object has no attribute 'spam'


Tests of hashing::

    >>> v1 = Vector([3, 4])
    >>> v2 = Vector([3.1, 4.2])
    >>> v3 = Vector([3, 4, 5])
    >>> v6 = Vector(range(6))
    >>> hash(v1), hash(v3), hash(v6)
    (7, 2, 1)


Most hash values of non-integers vary from a 32-bit to 64-bit CPython build::

    >>> import sys
    >>> hash(v2) == (384307168202284039 if sys.maxsize > 2**32 else 357915986)
    True


Tests of ``format()`` with Cartesian coordinates in 2D::

    >>> v1 = Vector([3, 4])
    >>> format(v1)
    '(3.0, 4.0)'
    >>> format(v1, '.2f')
    '(3.00, 4.00)'
    >>> format(v1, '.3e')
    '(3.000e+00, 4.000e+00)'


Tests of ``format()`` with Cartesian coordinates in 3D and 7D::

    >>> v3 = Vector([3, 4, 5])
    >>> format(v3)
    '(3.0, 4.0, 5.0)'
    >>> format(Vector(range(7)))
    '(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0)'


Tests of ``format()`` with spherical coordinates in 2D, 3D and 4D::

    >>> format(Vector([1, 1]), 'h')  # doctest:+ELLIPSIS
    '<1.414213..., 0.785398...>'
    >>> format(Vector([1, 1]), '.3eh')
    '<1.414e+00, 7.854e-01>'
    >>> format(Vector([1, 1]), '0.5fh')
    '<1.41421, 0.78540>'
    >>> format(Vector([1, 1, 1]), 'h')  # doctest:+ELLIPSIS
    '<1.73205..., 0.95531..., 0.78539...>'
    >>> format(Vector([2, 2, 2]), '.3eh')
    '<3.464e+00, 9.553e-01, 7.854e-01>'
    >>> format(Vector([0, 0, 0]), '0.5fh')
    '<0.00000, 0.00000, 0.00000>'
    >>> format(Vector([-1, -1, -1, -1]), 'h')  # doctest:+ELLIPSIS
    '<2.0, 2.09439..., 2.18627..., 3.92699...>'
    >>> format(Vector([2, 2, 2, 2]), '.3eh')
    '<4.000e+00, 1.047e+00, 9.553e-01, 7.854e-01>'
    >>> format(Vector([0, 1, 0, 0]), '0.5fh')
    '<1.00000, 1.57080, 0.00000, 0.00000>'
"""

from array import array
import reprlib
import math
import numbers
import functools
import operator
import itertools  # <1>


class Vector:
    typecode = 'd'

    def __init__(self, components):
        self._components = array(self.typecode, components)

    def __iter__(self):
        return iter(self._components)

    def __repr__(self):
        components = reprlib.repr(self._components)
        components = components[components.find('['):-1]
        return 'Vector({})'.format(components)

    def __str__(self):
        return str(tuple(self))

    def __bytes__(self):
        return (bytes([ord(self.typecode)]) +
                bytes(self._components))

    def __eq__(self, other):
        return (len(self) == len(other) and
                all(a == b for a, b in zip(self, other)))

    def __hash__(self):
        hashes = (hash(x) for x in self)
        return functools.reduce(operator.xor, hashes, 0)

    def __abs__(self):
        return math.sqrt(sum(x * x for x in self))

    def __bool__(self):
        return bool(abs(self))

    def __len__(self):
        return len(self._components)

    def __getitem__(self, index):
        cls = type(self)
        if isinstance(index, slice):
            return cls(self._components[index])
        elif isinstance(index, numbers.Integral):
            return self._components[index]
        else:
            msg = '{.__name__} indices must be integers'
            raise TypeError(msg.format(cls))

    shortcut_names = 'xyzt'

    def __getattr__(self, name):
        cls = type(self)
        if len(name) == 1:
            pos = cls.shortcut_names.find(name)
            if 0 <= pos < len(self._components):
                return self._components[pos]
        msg = '{.__name__!r} object has no attribute {!r}'
        raise AttributeError(msg.format(cls, name))

    def angle(self, n):  # <2>
        r = math.sqrt(sum(x * x for x in self[n:]))
        a = math.atan2(r, self[n-1])
        if (n == len(self) - 1) and (self[-1] < 0):
            return math.pi * 2 - a
        else:
            return a

    def angles(self):  # <3>
        return (self.angle(n) for n in range(1, len(self)))

    def __format__(self, fmt_spec=''):
        if fmt_spec.endswith('h'):  # hyperspherical coordinates
            fmt_spec = fmt_spec[:-1]
            coords = itertools.chain([abs(self)],
                                     self.angles())  # <4>
            outer_fmt = '<{}>'  # <5>
        else:
            coords = self
            outer_fmt = '({})'  # <6>
        components = (format(c, fmt_spec) for c in coords)  # <7>
        return outer_fmt.format(', '.join(components))  # <8>

    @classmethod
    def frombytes(cls, octets):
        typecode = chr(octets[0])
        memv = memoryview(octets[1:]).cast(typecode)
        return cls(memv)
# END VECTOR_V5

 

Kun Li
关注
专栏目录
Python入门练习题（6）-定义 Vector(空间向量) 类型
Hello Word!
08-11 9723
定义 Vector(空间向量) 类型 要求:拥有空间特征，模，单位向量，可进行相等判断及加、减、数乘、数量积、向量积等基本运算，并自己定义内部方法，多多益善。同时需给出格式化输出及说明文档。 鼓励先定义三维Point类然后通过继承和多态定义Vector。 class Point: def __init__(self, x=0.0, y=0.0, z=0.0): ...
Python 实现简单 Vector 类
Python高效编程
01-21 1万+
这一节，我们来实现一个简单的 Vector 类。 Vector 类有两个属性，为 x，y 坐标，即对应向量的横纵坐标。 首先，实现重载 + 号的方法def __add__，及实现两个向量的加法。具体做法是：将加号两边的 Vector 对象的 x, y值相加，得到新的 x, y值并且返回一个新的向量对象。 __sub__方法实现了 Vector 对象的减法，和加法差不多。让向量对象的对应属性相减，并...
C++基础（十四）：vector
最新发布
weixin_47040031的博客
07-11 1553
vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小，为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。
python实现 vector
a_qianghello的博客
09-07 1万+
#_*_coding:utf-8_*_ list = [] list1 = [] for i in range(0,6): for j in range(0,i+1): list.append(j) list1.append(list) list = [] print(list1)  
Python Vector 操作
u011699626的博客
05-14 684
我们知道，平面内矢量叉乘方向是垂于与平面的方向，因此，二维矢量叉乘得到的结果是一个数，而这个数实际上的意义是其他两个方向为。由于减法与加法互为逆运算，减法也可以看作是加上也给负数，因此，矢量减法的做法可类比上述矢量加法。显然，简单的数组相乘并不等同于矢量点乘，少了一步求和运算。中的数组本身就可以看作是一个矢量，因此，矢量加法就是数组简答地相加。中，我们可以很容易得到结果，这里特来介绍一下。模块用法的可以学习本人专栏 -------作为编程语言，这是因为不同于其他编程语言，中有更简单的方式------
50行Python代码实现经典游戏，不仅是划水神器，更是学习利器！
python爬虫人工智能大数据
06-25 5025
Free Python Games非常适合学生，它不仅具有高度的组织性和灵活性，而且能够激发人们探索和理解能力。--Terri FurtonFree Python Games在轻松的环境...
python定义一个people类 基于python语言实现opencv自带svm检测行人.zip
04-24
要定义一个名为`people`的类来处理行人检测，我们可以遵循以下步骤： 1. 导入所需的库： ```python import cv2 import numpy as np ``` 2. 定义`people`类： ```python class People: def __init__(self): ...
python vector初始化,vector 动态数组
weixin_42464967的博客
03-25 6093
1、说明vector是向量类型, 也称为动态数组，类似于python的列表定义或初始化vector前，需添加头文件 #include 2、vector初始化及定义// 1、定义一个具有整型类型的vector对象，无初值vector a;// 2、定义一个整型类型, 有10个元素的vector对象，无初值vector a(10);// 3、定义一个整型类型, 有10个元素，初值都为1的vector对...
Python Wordvector (二)
luoganttcc的博客
07-31 458
Python Wordvector (二) import jieba import pandas as pd txt = open("hlm.txt", "r", encoding="gb18030").read() from gensim.models.word2vec import Word2Vec ...
python vector 初始化_一文带你走进Python中的数据类
weixin_31884143的博客
02-01 381
全文共2607字，预计学习时长14分钟图源：unsplash数据类适用于Python3.7或更高版本，它不仅可以用作数据容器，还可以编写样板代码，简化创建类的过程。创建第一个数据类创建一个数据类，该数据类表示三维坐标系中的一个点。@dataclass装饰器用于创建数据类。x，y和z是数据类中的字段。注意要使用类型注释来指定字段的数据类型，但是类型注释不是静态类型声明，这意味着仍然可以为x，y或z字...
vector函数python_详解Python 函数参数的拆解
weixin_39688378的博客
12-15 1265
本文为阅读 《Python Tricks: The Book》一书的 3.5 Function Argument Unpacking 的笔记与扩充理解。函数参数拆解是定义可变参数(VarArgs) *args 和 **kwargs 的反向特性。*args 和 **kwars 是函数可定义一个形参来接收传入的不定数量的实参。而这里的函数参数拆解是形参定义多个，在调用时只传入一个集合类型对象(带上 *...
python vector变量_用Python实现因子分析
weixin_39845406的博客
01-29 605
因子分析(factor analysis)因子分析的一般步骤factor_analyzer模块进行因子分析使用Python实现因子分析初始化构建数据将原始数据标准化处理 X计算相关矩阵C计算相关矩阵C的特征值和特征向量确定公共因子个数k构造初始因子载荷矩阵A建立因子模型将因子表示成变量的线性组合.计算因子得分.因子分析(factor analysis)是指研究从变量群中提取共性...
python vector 初始化_从零开始搭建机器学习算法框架（python）--计算框架
weixin_33651906的博客
02-03 545
介绍今天开始一个新的系列，这个系列的目标是用python在不使用任何第三方库的情况下去实现各类机器学习或者深度学习的算法。之所以会有这种想法是因为每当我想提高编程技巧的时候，我总希望能够做一些简单又有趣的小项目练手。我一直对机器学习算法颇感兴趣，所以我想为什么不用python从零开始搭建一套迷你机器学习库呢。于是我尝试这么做了，这个系列就是记录我实现这一想法的过程。另外，由于这个项目很少用到第三方...
vector函数python_Smooth Support Vector Machine - Python实现
weixin_39633171的博客
12-15 154
1 #Smooth Support Vector Machine之实现23 importnumpy4 from matplotlib importpyplot as plt567 def spiral_point(val, center=(0, 0)):8 rn = 0.4 * (105 - val) / 1049 an = numpy.pi * (val - 1) / 25101...
（1）Python之向量（Vector）距离矩阵计算
热门推荐
王培晓Carpenter
12-17 2万+
文章目录1. 引言2. 矩阵自身（行）向量之间的距离矩阵计算2.1 第一种方法：简单使用两重循环2.2 第二种方法：矩阵內积双重循环2.3 第三种方法：避免循环内的点积运算2.4 第四种方法：避免循环2.5 第五种方法：利用`scipy`求距离矩阵（推荐用法）3.两个矩阵之间的距离矩阵计算3.1 第一种方法：使用`numpy`计算3.2 第二种方法：利用`scipy`求距离矩阵（推荐用法）4. 相...
vector函数python_python类中的函数问题
weixin_39768645的博客
12-15 641
各位大神好！我在学习的一个线代基础课中，需要用到Python来计算向量，其中有一段代码是这样的：from math import sqrt, acos, pi #导入sqrt, acos, pifrom decimal import Decimal, getcontextgetcontext().prec = 30class Vector():CANNOT_NORMALIZE_ZERO_VECTO...
vector的用法
ladliu的专栏
06-18 390
http://blog.csdn.net/zhiyuzhe/archive/2006/06/01/768170.aspx 
python 导数 vector_Python。Scipy数值导数
weixin_34305716的博客
01-28 863
不久前我发现了scipy.misc.derivative。在def derivative(func, x0, dx=1.0, n=1, args=(), order=3)令人难以置信的是它的速度和精确度。所以，我决定弄清楚它是怎么工作的。但是我不完全理解这个函数的代码，它在derivative中使用：^{pr2}$据我所知，这个函数在高阶导数的展开式中找到系数，但是它是如何做到的呢？在代码：def...
定义一个二维向量类Vector
06-01
好的，下面是一个基本的二维向量类Vector的定义，包含向量的x和y分量以及一些基本的向量运算方法： ```python import math class Vector: def __init__(self, x=0, y=0): self.x = x self.y = y def __str__(self): return "Vector({}, {})".format(self.x, self.y) def __add__(self, other): return Vector(self.x + other.x, self.y + other.y) def __sub__(self, other): return Vector(self.x - other.x, self.y - other.y) def __mul__(self, other): return Vector(self.x * other, self.y * other) def __rmul__(self, other): return Vector(self.x * other, self.y * other) def __truediv__(self, other): return Vector(self.x / other, self.y / other) def __neg__(self): return Vector(-self.x, -self.y) def __eq__(self, other): return self.x == other.x and self.y == other.y def __ne__(self, other): return not self.__eq__(other) def dot(self, other): return self.x * other.x + self.y * other.y def cross(self, other): return self.x * other.y - self.y * other.x def norm(self): return math.sqrt(self.dot(self)) def normalize(self): return self / self.norm() def angle(self, other): cos_theta = self.dot(other) / (self.norm() * other.norm()) return math.acos(cos_theta) def rotate(self, angle): x = self.x * math.cos(angle) - self.y * math.sin(angle) y = self.x * math.sin(angle) + self.y * math.cos(angle) return Vector(x, y) ``` 使用示例： ```python v1 = Vector(1, 2) v2 = Vector(3, 4) print(v1 + v2) print(v1 - v2) print(v1 * 2) print(2 * v1) print(v1 / 2) print(-v1) print(v1.dot(v2)) print(v1.cross(v2)) print(v1.norm()) print(v1.normalize()) print(v1.angle(v2)) print(v1.rotate(math.pi / 2)) ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值