流畅的python——10 序列的修改、散列和切片

十、序列的修改、散列和切片

不要检查它是不是鸭子、它的叫声像不像鸭子、它的走路姿势像不像鸭子，等等。具体检查什么取决于你想使用语言的哪些行为。（comp.lang.python，2000 年 7月 26 日） ——Alex Martelli

多维向量

In [20]: from array import array

In [21]: import reprlib

In [22]: import math

In [29]: 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)
    ...:     def __len__(self):
    ...:         return len(self._components)
    ...:     def __getitem__(self, index):  # 支持 [] 和 切片
    ...:         return self._components[index]

我使用 reprlib.repr 的方式需要做些说明。这个函数用于生成大型结构或递归结构的安全表示形式，它会限制输出字符串的长度，用 '...' 表示截断的部分。我希望 Vector实例的表示形式是 Vector([3.0, 4.0, 5.0]) 这样，而不是 Vector(array('d',[3.0, 4.0, 5.0]))，因为 Vector 实例中的数组是实现细节。

编写 __repr__ 方法时，本可以使用这个表达式生成简化的 components 显示形式：reprlib.repr(list(self._components))。然而，这么做有点浪费，因为要把self._components 中的每个元素复制到一个列表中，然后使用列表的表示形式。而是直接把 self._components 传给 reprlib.repr 函数，然后去掉 [] 外面的字符。

调用 repr() 函数的目的是调试，因此绝对不能抛出异常。如果 __repr__ 方法的实现有问题，那么必须处理，尽量输出有用的内容，让用户能够识别目标对象。

协议和鸭子类型

在面向对象编程中，协议是非正式的接口，只有在文档中定义，在代码中不定义。任何类只要使用标准的签名和语义实现了协议的方法，就能用在任何期待实现协议功能的地方。其是不是哪个类的子类无关紧要，只要提供了所需的方法即可。

比如：序列协议：只要实现 __len__ 和 __getitem__ 两个方法。

我们说它是序列，因为它的行为像序列，这才是重点。

协议是非正式的，没有强制力，因此如果你知道类的具体使用场景，通常只需要实现一个协议的部分。例如，为了支持迭代，只需要实现 __getitem__ 方法，没必要实现 __len__ 方法。

支持切片

如果得到的 Vector 对象的切片是一个列表，会丢失很多功能，如果得到是还是一个 vector 对象，就很好了。

切片原理

In [1]: class Y:
   ...:     def __getitem__(self,index):
   ...:         return index
   ...:

In [2]: y = Y()

In [3]: y[1]
Out[3]: 1

In [4]: y[1:2]
Out[4]: slice(1, 2, None)

In [5]: y[1:2:2,9]  # 逗号隔开，index 是元组
Out[5]: (slice(1, 2, 2), 9)

In [6]: y[1:2,2:3]  # 支持多个切片
Out[6]: (slice(1, 2, None), slice(2, 3, None))

indices 方法

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

In [11]: slice(None,11,2).indices(5)
Out[11]: (0, 5, 2)

In [12]: slice(None,None,None).indices(10)
Out[12]: (0, 10, 1)

dir() 和 help()，发现 slice.indices() 方法。这也表明交互式控制台是个有价值的工具，能发现新事物。

In [10]: help(slice.indices)
Help on method_descriptor:

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.

__getitem__ 处理切片

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

__getattr__ : obj.x

前四个位置的元素分别为：x, y, z, t

shortcut_names = 'xyzt'
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]
    msg = '{.__name__!r} object has no attribute {!r}'
    raise AttributeError(msg.format(cls, name))

测试：

>>> v = Vector(range(5))
>>> v
Vector([0.0, 1.0, 2.0, 3.0, 4.0])
>>> v.x
0.0
>>> v.x = 10  # 赋值给 v 新的 x 属性
>>> v.x  # 优先读取 x 属性，而不是直接调用 __getattr__
10
>>> v
Vector([0.0, 1.0, 2.0, 3.0, 4.0])

仅当对象没有指定名称的属性时，Python 才会调用那个方法，这是一种后备机制。可是，像 v.x = 10 这样赋值之后，v 对象有 x 属性了，因此使用 v.x 获取 x 属性的值时不会调用 __getattr__ 方法了，解释器直接返回绑定到 v.x 上的值，即 10。另一方面，__getattr__ 方法的实现没有考虑到 self._components 之外的实例属性，而是从这个属性中获取 shortcut_names 中所列的“虚拟属性”。

实现 __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():  # 如果 name 是小写字母，为所有小写字母设置一个错误消息。
            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)  # 默认情况：在超类上调用 __setattr__ 方法，提供标准行为。

为了给 AttributeError 选择错误消息，查看了内置的 complex 类型的行为，因为 complex 对象是不可变的

注意，我们没有禁止为全部属性赋值，只是禁止为单个小写字母属性赋值，以防与只读属性 x、y、z 和 t 混淆。

多数时候，如果实现了 __getattr__ 方法，那么也要定义 __setattr__ 方法，以防对象的行为不一致。

__setitem__ 方法，支持 v[0] = 1.1

可散列对象

累积计算

operator 模块以函数的形式提供了 Python 的全部中缀运算符，从而减少使用 lambda 表达式。

>>> n = 0
>>> for i in range(1, 6):
...     n ^= i
>>> import functools
>>> functools.reduce(lambda a, b: a^b, range(6))
>>> import operator
>>> functools.reduce(operator.xor, range(6))

使用 reduce 函数时最好提供第三个参数，reduce(function, iterable, initializer)，这样能避免这个异常：TypeError: reduce() of empty sequence with no initial value（这个错误消息很棒，说明了问题，还提供了解决方法）。如果序列为空，initializer 是返回的结果；否则，在归约中使用它作为第一个参数，因此应该使用恒等值。比如，对 +、| 和 ^ 来说， initializer 应该是 0；而对 * 和 & 来说，应该是 1。

from array import array
import reprlib
import math
import functools 
import operator
class Vector:
    typecode = 'd'
    def __eq__(self, other):
        return tuple(self) == tuple(other)
    def __hash__(self):
        hashes = (hash(x) for x in self._components)
        return functools.reduce(operator.xor, hashes, 0)

映射过程计算各个分量的散列值，归约过程则使用 xor 运算符聚合所有散列值。把生成器表达式替换成 map 方法，映射过程更明显：

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

在 Python 2 中使用 map 函数效率低些，因为 map 函数要使用结果构建一个列表。但是在 Python 3 中，map 函数是惰性的，它会创建一个生成器，按需产出结果，因此能节省内存——这与示例 10-12 中使用生成器表达式定义 __hash__ 方法的原理一样。

改进 __eq__ 方法

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

前面比较长度的测试是有必要的，因为一旦有一个输入耗尽，zip 函数会立即停止生成值，而且不发出警告。

改进：上个改进效率很好，不过用于计算聚合值的整个 for 循环可以替换成一行 all 函数调用：如果所有分量对的比较结果都是 True，那么结果就是 True。只要有一次比较的结果是 False，all 函数就返回 False。zip 也是返回生成器。

def __eq__(self, other):
    return len(self) == len(other) and all(a == b for a, b in zip(self, other))

出色的 zip 函数

使用 for 循环迭代元素不用处理索引变量，还能避免很多缺陷，但是需要一些特殊的实用函数协助。其中一个是内置的 zip 函数。使用 zip 函数能轻松地并行迭代两个或更多可迭代对象，它返回的元组可以拆包成变量，分别对应各个并行输入中的一个元素。

>>> from itertools import zip_longest  # 这个模块可以填充缺失值
>>> list(zip_longest(range(3), 'ABC', [0.0, 1.1, 2.2, 3.3], fillvalue=-1))
[(0, 'A', 0.0), (1, 'B', 1.1), (2, 'C', 2.2), (-1, -1, 3.3)]

输出格式化：__format__

def angle(self, n):  # 计算某个角坐标
    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):  # 计算全部角坐标
    return (self.angle(n) for n in range(1, len(self)))
def __format__(self, fmt_spec=''):
    if fmt_spec.endswith('h'): # 超球面坐标
        fmt_spec = fmt_spec[:-1]
        # 使用 itertools.chain 函数生成生成器表达式，无缝迭代向量的模和各个角坐标。
        coords = itertools.chain([abs(self)],self.angles())
        outer_fmt = '<{}>'
    else:
        coords = self
        outer_fmt = '({})'
    components = (format(c, fmt_spec) for c in coords)
    return outer_fmt.format(', '.join(components))

协议，是鸭子类型语言使用的非正式接口。

我们经常分析 Python 标准对象的行为，然后进行模仿，让 Vector 的行为符合 Python 风格。

模仿内置类型实现类时，记住一点：模仿的程度对建模的对象来说合理即可。例如，有些序列可能只需要获取单个元素，而不必提取切片。 ——Python 语言参考手册中“Data Model”一章

不要为了满足过度设计的接口契约和让编译器开心，而去实现不需要的方法，我们要遵守 KISS 原则（http://en.wikipedia.org/wiki/KISS_principle）。

“地道”并不是指使用最鲜为人知 的语言特性。

python 风格的求和方式

我喜欢 Evan Simpson 的代码，不过也喜欢 David Eppstein 对此给出的评论：

如果你想计算列表中各个元素的和，写出的代码应该看起来像是在“计算元素之和”，而不是“迭代元素，维护一个变量 t，再执行一系列求和操作”。如果不能站在一定高度上表明意图，让语言去关注低层操作，那么要高级语言干嘛？

随后，Alex 建议提供并实现了 sum() 函数。这次讨论之后三个月，Python 2.3 就内置了这个函数。因此，Alex 喜欢的句法变成了标准：

>>> sum([sub[1] for sub in my_list])
60

下一年年末（2004 年 11 月），Python 2.4 发布了，这一版引入了生成器表达式。因此，在我看来，Guy Middleton 那个问题目前最符合 Python 风格的答案是：

>>> sum(sub[1] for sub in my_list)
60