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

def __len__(self):

return len(self._components)

def __getitem__(self, index):

# return self._components[index] # 最简单地支持切片，但返回array，不理想。

cls = type(self) # <1>

if isinstance(index, slice): # <2> 如果index是一个切片(slice对象)，即含有冒号

return cls(self._components[index]) # <3>

elif isinstance(index, numbers.Integral): # <4> 如果index是一个数字，即没有含有冒号

return self._components[index] # <5>

else:

msg = '{cls.__name__} indices must be integers'

raise TypeError(msg.format(cls=cls)) # <6>

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

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>

def __eq__(self, other):

# return tuple(self) == tuple(other) # multi vector, 效率低下

# return len(self)==len(other) and all(a==b for a,b in zip(self, other)) # 效果同下

if len(self) != len(other):

return False

for a,b in zip(self, other): # zip()函数生成一个由双元素的元组构成的一个惰性生成器

if a!=b:

return False

return True

def __hash__(self):

# hashes = map(hash, self._components) # 效果同下

hashes = ( hash(x) for x in self._components ) # 创建genexp，惰性计算

return functools.reduce(operator.xor, hashes, 0) # 0为+, |, ^操作的初始值；1为*，&操作的初始值

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>