符合python风格的对象

python自带的对象拥有很多有趣的行为，用户自己定义的类对象也可以实现跟python对象相同的行为。

对象的表示形式

python关于对象的表示提供了两种形式：

repr()

　　便于开发者理解的返回对象的字符串形式

str()

　　便于用户理解的返回对象的字符串形式

也正是对象的__repr__和__str__两个特殊方法为repr()和str()提供支持。另外还有两个方法，__bytes__和__format__。__bytes__方法跟__str__类似：bytes()函数调用它获取对象的字节序列表示形式；__format_-方法会被内置的format()函数和str.format()方法调用。

向量类

自己定义一个Vector2d类，我们期望他能有下面的表现形式。

>>> v1 = Vector2d(3, 4)
>>> print(v1.x, v1.y)
3.0 4.0
>>> x, y = v1
>>> x, y
(3.0, 4.0)
>>> v1
Vector2d(3.0, 4.0)
>>> v2 = eval(repr(v1))
>>> v1 == v2
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(Vector2d(0, 0))
(True, False)

实现代码如下：

import math
from array import array
class Vector2d:
    """
    自定义一个二维向量类
    """
    typecode = 'd'
    def __init__(self, x, y):
        self.x = x
        self.y = y

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

    def __repr__(self):
        return '{}({!r}, {!r})'.format(type(self).__name__, self.x, self.y)

    def __str__(self):
        return str(tuple(self)) #已经实现了__iter__方法，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 __bytes__(self):
        return bytes([ord(self.typecode)])+bytes(array(self.typecode, self))

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)
#Vector2d(3.0, 4.0)
print("repr(v1),", repr(v1))
v2 = eval(repr(v1))
print(v1 == v2)
#True
print(v1)
#(3.0, 4.0)
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), bool(Vector2d(0, 0)))
#(True, False)

备选构造方法

我们可以Vector2d实例转换成字节序列了，那么也应该提供一个方法转换回来。array.array中有个frombytes方法

class Vector2d:
    """
    自定义一个二维向量类
    """
    typecode = 'd'
    def __init__(self, x, y):
        self.x = x
        self.y = y

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

    def __repr__(self):
        return '{}({!r}, {!r})'.format(type(self).__name__, self.x, self.y)

    def __str__(self):
        return str(tuple(self)) #已经实现了__iter__方法，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 __bytes__(self):
        return bytes([ord(self.typecode)])+bytes(array(self.typecode, self))

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

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)
#Vector2d(3.0, 4.0)
print("repr(v1),", repr(v1))
v2 = eval(repr(v1))
print(v1 == v2)
#True
print(v1)
#(3.0, 4.0)
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), bool(Vector2d(0, 0)))
#(True, False)
v2 = Vector2d.frombytes(octets)
print(v2)

classmethod和staticmethod

classmethod定义了操作类的方法而不是实例。classmethod改变了调用方法的方式，第一个参数是类本身，而不是实例。classmethod最常见的用途就是定义备选函数构造方法，如上面的frombytes，按照约定，类方法的第一个参数名为cls。（实际上，怎么命名都可以）

staticmethod也会改变方法的调用方式，但是第一个蚕食不是特殊的值，事实上，静态方法就是普通的函数，只是碰巧在类的定义体中。

格式化显示

class Vector2d:
    typecode = 'd'
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __iter__(self):
        return (i for i in (self.x, self.y))
    def __repr__(self):
        return '{}({!r}, {!r})' %(type(self).__name__, self.x, self.y)
    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))
    @classmethod
    def frombytes(cls, octets):
        typecode = chr(octets[0])
        memv = memoryview(octets[1:]).cast(typecode)
        return cls(*memv)
    def __format__(self, fmt=""):
        if fmt.endswith('p'):
            polar = (abs(self), self.angle())
            s = polar
            outer_fmt = '<{}, {}>'
        else:
            s = self
            outer_fmt = '({}, {})'
        components = (format(c, fmt.rstrip('p')) for c in s)
        return outer_fmt.format(*components)
    def angle(self):
        return math.atan2(self.y, self.x)
v1 = Vector2d(3, 4)
print(format(v1, '.2f'))
print(format(v1, '.4e'))
print(format(v1, '.3ep'))

使用__slots__类属性节省空间

python在各个实例中的__dict__字典里存储实例属性，通过之前的学习，我们知道dict字典这种结构是典型的空间换时间，会消耗掉大量的内存，如果要处理数百万的实例，通过__slots__属性，就能节省大量内存，方法是让解释器在类似元组的结构中存储实例属性，而不是字典。(超类的__slots__属性，对子类没有效果)

class Vector2d:
    __slots__ = ('_x', '_y')
    ...

ps:如果要处理数百万个数值对象，应该使用numpy。

__slots__设计之初是为了节省内存，但是也带来了一个副作用，那就是不能再为实例添加__slots__之外的属性。

需要明确的是：使用__slots__的充分理由应该是为了节省内存，而不是限制实例属性，__slots__是用于优化的，而非约束程序员。