Fluent Python - Part10 序列的修改，散列和切片

本章以第9章定义的二维向量Vector2d类为基础，定义表示多维向量的Vector类。这个类的行为与Python中标准的不可变扁平序列一样。Vector 实例中的元素是浮点数，本章结束后 Vector 类将支持下述功能：

• 基本的序列协议 ----- __len__ 和 __getitem__
• 正确表述拥有很多元素的实例
• 适当的切片支持，用于生成新的 Vector 实例
• 综合各个元素的值计算散列值
• 自定义的格式语言扩展

此外，我们还将通过 __getattr__ 方法实现属性的动态存取，以此取代 Vector2d 使用的只读特性。

在大量代码之间，我们将穿插讨论一个概念：把协议当作正式接口。我们将说明协议和鸭子类型之间的关系，以及对自定义类型的实际影响。

Vector类第一版：与Vector2d类兼容

from array import array
import reprlib
import math

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

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

协议和鸭子类型

在 Python 中创建功能完善的序列类型无需使用继承，只需实现符合序列协议的方法。不过，这里说的协议是什么呢？

协议是非正式的接口，只在文档中定义，在代码中不定义。例如，Python 的序列协议只需要 __len__ 和 __getitem__ 两个方法。任何类(如Spam), 只需使用标准的签名和语义实现了这两个方法，就能用在任何期待序列的地方。

import collections

Card = collections.namedtuple('Card', ['rank', 'suit'])
class FrenchDeck:
    ranks = [str(n) for n in range(2, 11)] + list('JQKA')
    suits = 'spades diamonds clubs hearts'.split()

    def __init__(self):
        self._cards = [Card(rank, suit) for suit in self.suits
                                        for rank in self.ranks]
    
    def __len__(self):
        return len(self._cards)

    def __getitem__(self, position):
        return self._cards[position]

FrenchDeck 类能充分利用 Python 的很多功能，因为它实现了序列协议，不过代码中并没有声明这一点。我们说它是序列，因为它的行为像序列，这才是重点。

人们称其为鸭子类型(duck typing)。协议是非正式的，没有强制力。

下面，我们将在 Vector 类中实现序列协议。

Vector类第2版：可切片的序列

如 FrenchDeck 类所示，如果能委托给对象中的的序列属性(如 self._components 数组), 支持序列协议特别简单。

class Vector:
    typecode = 'd'

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

    def __getitem__(self, index):
        return self._components[index]
v = Vector([i for i in range(1, 30)])
print(len(v))
print(v[0])
print(v[1:3])

"""
output:
29
1.0
array('d', [2.0, 3.0])
"""

可以看到，现在连切片都支持了，但尚不完美。Vector 实例的切片类型是数组而非 Vecotor，这样对 Vector 来说，它的切片将会确实大量功能。

为了把 Vector 实例的切片也变成 Vector 实例，我们不能简单地委托给数组切片。我们要分析传给 __getitem__ 方法的参数，做适当的处理。

切片原理

一例胜千言，我们看看下面的示例：

>>> class MySeq:
...     def __getitem__(self, index):
...             return index
...
>>> s = MySeq()
>>> s[1]
1
>>> s[1:4]
slice(1, 4, None)
>>> s[1:4:2]
slice(1, 4, 2)
>>> s[1:4:2, 9]
(slice(1, 4, 2), 9)

现在，我们来看看 slice 本身：

>>> slice
<type 'slice'>
>>> dir(slice)
['__class__', '__cmp__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'indices', 'start', 'step', 'stop']

slice 是内置的类型, 发现它有 start, stop, 和 step 数据属性，以及 indices 方法。

indices 是一个很有用的方法，我们使用help(slice.indices) 来看看它的作用。

indices(...)
    S.indices(len) -> (start, stop, stride)

    Assuming a sequence of length len, calculate the start and stop
    indices, and the stride length of the extended slice described by
    S. Out of bounds indices are clipped in a manner consistent with the
    handling of normal slices.

换句话说， indices 方法开放了内置序列实现的棘手逻辑，用于优雅地处理缺失索引和负数索引，以及长度超过目标序列的切片。这个方法会整顿元祖，把 start, stop 和 stride 都变成非负数，而且都落在指定长度序列的边界内。

在 Vector 类中无需使用 slice.indices() 方法，因此受到切片参数时，我们会委托 _components 数组处理。但是，你如果没有底层序列类型作为依靠，那么使用这个方法能节省大量时间。

现在我们知道如何处理切片了，下面来看 Vector.__getitem__ 方法改进后的实现。

能处理切片的 __getitem__ 方法。

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

Vector类第3版：动态存取属性

Vector2d 变成 Vector 之后，就没办法通过名称访问向量的分量了(如 v.x 和 v.y).现在我们处理的向量可能有大量分量，不过，若能通过单个字母访问前几个分量的话会比较方便。比如，用x，y和z代替 v[0], v[1] 和 v[2]。

在 Vector2d 中， 我们使用 @property 装饰器把 x 和 y 标记为只读特性。我们可以在 Vector 中编写四个特性，但这样太麻烦。特殊方法 __getattr__ 提供了更好的方式。

属性查找失败后，解释器会调用 __getattr__ 方法。简单来说，对 my_obj.x 表达式， Python 会检查 my_obj 实例有没有名为 x 的属性：如果没有，到类(my_obj.__class__)中查找；如果还没有，顺着继承树继续查找。如果依旧找不到，调用 my_obj 所属类中定义的 __getattr__ 方法，传入 self 和属性名称的字符串形式(如'x')

下例我们将实现 Vector 类定义的 __getattr__ 方法，这个方法的作用很简单，它检查所查找的属性是不是 xyzt 中的某个字母，如果是，那么返回对应的分量。

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

这样带来了一个问题，如果Vector有x属性后，那么再来查找的话，这个逻辑就失效了。为了避免歧义，在 Vector 类中，如果为名称是单个小写字母的属性赋值，我们也想抛出那个异常。为此，我们要实现 __setattr__ 方法。

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 = ''
        if error:
            msg = error.format(cls_name=cls.__name__, attr_name=name)
            raise AttributeError(msg)
    super().__setattr__(name, value)

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

这个貌似没有什么好讲的，主要是内置的函数的使用。

def __eq__(self, other):
    if len(self) != len(other):
        return False
    for a, b in zip(self, other):
        if a != b:
            return False
    return True

def __hash__(self):
    hashes = map(hash, self._components)
    return functools.reduce(operator.xor, hashes)

格式化的内容就忽略啦，主要就是 __format__ 方法的实现。

接下来我们将介绍“接口：从协议到抽象基类”