『流畅的Python』第10章笔记_序列类型

一、基础知识

“__”前缀：私有属性、方法，在__dict__中存储时被改写为“_类名__”前缀

“_”前缀：是约定俗成的保护属性、方法，不过编译器不会对之采取任何处理

二、class特殊方法介绍

在第9章的双元素基础上，我们扩展为任意元素长度的向量，并探讨了相关方法的使用：

__getattr__(self, name)：

result = obj.name 会调用builtin函数getattr(obj,'name')查找对应属性，如果没有name属性则调用obj.__getattr__('name')方法，再无则报错

__setattr__(self, name, value)：

obj.name = value 会调用builtin函数setattr(obj,'name',value)设置对应属性，如果设置了__setattr__('name',value)方法则优先调用此方法，而非直接将值存入__dict__并新建属性

自己改写时一般添加一些预先处理，最后还是要用到继承super().__setattr__(name, value)

__getitem__(self, item)：

在函数体内，会将self[index]的外部表达中的index转化为slice对象，方便处理

__setitem__(self, key, value)：

没有用到，用于设置可以self[key]形式查询的数据，即支持序列索引和散列表两种形式

实现程序如下：

import math
import reprlib
from array import array
import numbers  # 提供整数基类
import functools
import operator  # 亦或方法，虽然'^='功能一样
import itertools


class Vector:
    typecode = 'd'
    shortcut_names = 'xyzt'

    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 __abs__(self):
        return math.sqrt(sum(x*x for x in self))

    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)

    # ==========支持切片操作==========
    def __len__(self):
        return len(self._components)

    # def __getitem__(self, index):
    #     # 支持切片类似[1:2]
    #     # 但是Vector的切片是数组，而非Vector实例
    #     # 实际上在方法内部index被转化为了slice对象
    #     return self._components[index]

    # 和__setitem_对应（此处未实现）
    def __getitem__(self, index):  # 会将self[index]的index转化为slice对象
        cls = type(self)
        if isinstance(index, slice):
            return cls(self._components[index])
        elif isinstance(index, numbers.Integral):
            return self._components[index]
        else:
            raise TypeError('indices must be integers')

    # ==========动态存取属性==========
    # xyzt四个字母分别指代前四个分量，调用如'v.x'，
    # 设置属性时保证不能使用小写字母a-z为实例添加属性
    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]
        raise AttributeError('object has no attribute')

    def __setattr__(self, name, value):
        cls = type(self)
        if len(name) == 1:
            if name in cls.shortcut_names:
                error = 'readonly attribute {attr_name!r}'
            elif name.islower():
                error = "can't set attributes 'a' to 'z' in {cls_name!r}"
            else:
                error = ''  # bool('')=False
            if error:
                raise AttributeError(error.format(cls_name=cls.__name__,
                                                  attr_name=name))
        super().__setattr__(name, value)

    # ==========哈希方法==========
    def __hash__(self):
        # hashes = map(hash, self._components)
        hashes = (hash(x) for x in self._components)
        return functools.reduce(operator.xor, hashes, initial=0)
    # reduce的initial表示初始值，如果序列为空则返回初始值，否则
    # 初始值加到序列首，对亦或运算初始值应该为0

    def __eq__(self, other):
        # ----------version1----------
        # 原版（注释句）在向量很长时消耗内存过巨，需要构建两个元组
        # return tuple(self) == tuple(other)
        # ----------version2----------
        # if len(self) != len(other):
        #     return False
        # for a, b in zip(self, other):
        #     if a != b:
        #         return False
        # return True
        # ----------version3----------
        return len(self) == len(other) and 
               all(a == b for a, b in zip(self, other))

    # format规范化输出
    def angle(self, n):
        r = math.sqrt(sum(x * x for x in self._components))
        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):
        return (self.angle(n) for n in range(1, len(self)))

    def __format__(self, format_spec=''):
        if format_spec.endswith('h'):
            format_spec = format_spec[:-1]
            # r, angle1，angle2，……
            coords = itertools.chain([abs(self)], self.angles())
            out_fmt = '<{}>'
        else:
            coords = self
            out_fmt = '({})'
        components = (format(c, format_spec) for c in coords)
        return out_fmt.format(','.join(components))


if __name__ == "__main__":
    print(Vector(range(10)))
    v = Vector(range(7))
    print(v)
    print(v[3])
    print(v.x)