《流畅的Python》第九章学习笔记

# -*- coding: utf-8 -*-
from array import array
import math


class Vector2d:
    typecode = 'd'  # 类属性

    def __init__(self, x, y):
        """
        将x与y转换为浮点数，尽早捕获错误
        :param x:
        :param y:
        """
        self.__x = float(x)
        self.__y = float(y)

    @property  # 把读值方法标记为特性
    def x(self):
        return self.__x

    @property
    def y(self):
        return self.__y

    def __iter__(self):
        return (i for i in (self.x, self.y))

    def __repr__(self):
        class_name = type(self).__name__
        return '{}({!r}, {!r})'.format(class_name, *self)

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

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

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

    def __abs__(self):
        return math.hypot(self.x, self.y)

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

    def __format__(self, format_spec=''):
        if format_spec.endswith('p'):
            format_spec = format_spec[:-1]
            coords = (abs(self), self.angle())
            outer_fmt = '<{}, {}>'
        else:
            coords = self
            outer_fmt = '({}, {})'
        components = (format(c, format_spec) for c in coords)
        return outer_fmt.format(*components)

    def __hash__(self):
        return hash(self.x) ^ hash(self.y)

    def angle(self):
        """
        计算函数角度
        :return:
        """
        return math.atan2(self.y, self.x)

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


if __name__ == '__main__':
    v1 = Vector2d(3, 4)
    print(v1.x, v1.y)  # 3.0 4.0
    x, y = v1
    print(x, y)  # 3.0 4.0
    print(v1)  # (3.0, 4.0)
    v1_clone = eval(repr(v1))
    print(v1 == v1_clone)  # True
    octets = bytes(v1)
    print(octets)  # b'd\x00\x00\x00\x00\x00\x00\x08@\x00\x00\x00\x00\x00\x00\x10@'
    print(abs(v1))  # 5.0
    print(bool(v1))  # True
    print(bool(Vector2d(0, 0)))  # False

    v1_clone = Vector2d.frombytes(bytes(v1))
    print(v1_clone)  # (3.0, 4.0)
    print(v1 == v1_clone)  # True

    print(format(v1))  # (3.0, 4.0)
    print(format(v1, '.2f'))  # (3.00, 4.00)
    print(format(v1, '.3e'))  # (3.000e+00, 4.000e+00)

    print(Vector2d(0, 0).angle())  # 0.0
    print(Vector2d(1, 0).angle())  # 0.0
    epsilon = 10 ** -8
    print(abs(Vector2d(0, 1).angle() - math.pi / 2) < epsilon)  # True
    print(abs(Vector2d(1, 1).angle() - math.pi / 4) < epsilon)  # True

    print(format(Vector2d(1, 1), 'p'))  # <1.4142135623730951, 0.7853981633974483>
    print(format(Vector2d(1, 1), '.3ep'))  # <1.414e+00, 7.854e-01>
    print(format(Vector2d(1, 1), '0.5fp'))  # <1.41421, 0.78540>

    v1 = Vector2d(3, 4)
    v2 = Vector2d(3.1, 4.2)
    print(hash(v1))  # 7
    print(hash(v2))  # 384307168202284039
    print(len(set([v1, v2])))  # 2

class A():
    def __init__(self, x, y):
        self.__x = x
        self.__y = y


if __name__ == '__main__':
    a = A(1,2)
    print(a.__dict__) # {'_A__x': 1, '_A__y': 2}