标签：tar 风格 循环 属性 不必要 变量 失败 ini diamond
接原vector类定义的新Vector类，原向量类是二维，现定义多维向量类：
from array import array import reprlib import math 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 __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)
1.协议是非正式的接口，没有强制力；协议只在文档中定义，在代码中不定义。
2.python有很多协议，如可调用对象协议，哈希协议，序列类协议，容器类协议等等等等。
3.如果知道类的具体使用场景，通常只需要实现协议的一个部分，例如为了支持迭代，只需要实现__getitem__方法，而不必要提供__len__方法。
4.需要成为相对应的鸭子类型，那就实现相关的协议，即相关的__method__。例如实现序列协议(__len__和__getitem__），这个类就表现得像序列。
1.(DuckTyping)鸭子类型在动态语言中用的较多,是动态类型语言设计的一种风格。在这种风格中,一个对象有效的语义,不是由继承自特定的类或实现特定的接口决定,而是由当前方法和属性的集合决定。通俗来说就是并不关心对象是什么类型,只关心行为。
2.当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子；即它的行为是鸭子的行为，那么可以认为它是鸭子。
3.在Python文档中，如果看到“文件类对象“（表现得像文件的对象），通常说的就是协议，这个对象就是鸭子类型。这是一种简短的说法，意思是：“行为基本与文件一致，实现了部分文件接口，满足上下文相关需求的东西。”
FrenchDeck实现了序列协议，即实现了__len__和__getitem__，那么它就可以看作是序列：
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._cars) def __getitem__(self, position): return self._cards[position]
class Myseq: def __getitem__(self, index): return index #返回索引 s = Myseq() print(s[1]) print(s[1:4]) print(s[1:4:2]) print(s[1:4:2, 7]) print(s[1:4:2, 7:9]) #结果 1 #单个索引 slice(1, 4, None) #返回slice对象， slice(1, 4, 2) (slice(1, 4, 2), 7) (slice(1, 4, 2), slice(7, 9, None)) #返回slice对象元组
审查slice对象：
print(slice) print(dir(slice)) <class ‘slice‘> [‘__class__‘, ‘__delattr__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__le__‘, ‘__lt__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘indices‘, ‘start‘, ‘step‘, ‘stop‘]
slice是内置类型，它有‘indices‘方法, ‘start‘, ‘step‘, ‘stop‘数据属性
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.
给定长度为len的序列，计算S表示的扩展切片的起始和结尾索引，以及步幅。超出边界的索引会被截掉，这与常规切片处理方式一样。
假如给定一个序列长度为5：
print(slice(None, 10, 2).indices(5)) print(slice(-3, None, None).indices(5)) (0, 5, 2) #切片[None, 10, 2]将转换为[0, 5, 2],因为序列长度最多为5 (2, 5, 1) #切片[-3, None, None]将转换为[2, 5, 1],-3位置即序列的2位置，长度为5，跨度默认为1
为了让Vector类能正确处理切片，更改__getitem__方法。
def __getitem__(self, item): cls = type(self) if isinstance(item, slice): return cls(self._components[item]) #参数是slice对象，返回 elif isinstance(item, numbers.Integral): return self._components[item] #参数单个元素，返回单个元素 else: msg = ‘{cls.__name__} indices must be integers‘ raise TypeError(msg.format(cls=cls)) #抛出异常
属性查找失败时解释器会调用__getattr__方法。即：对于obj.x表达式，python会检查obj实例有没有名为x的属性；如果没有，到类（obj.class）中查找，如果还没有，顺着继承树继续查找，如果依旧找不到，调用obj所属类中定义的__getattr__方法，传入self和属性名称的字符串形式（如‘x’）
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)) if __name__ == ‘__main__‘: V7 = Vector(range(7)) print(V7) print(V7.y) V7.y = 10.0 print(V7.y) print(V7)
测试结果：
(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0) 1.0 10.0 #第二项为10 (0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0) #第二项为1，矛盾
造成这种结果的原因是__getattr__的运作方式：仅当对象没有指定名称的属性时，python才会调用那个方法，这是一种后备机制。可是运行过V7.y = 10之后V7就有y属性了，因此使用V7.y属性值时不会调用__getattr__方法，解释器直接返回绑定值，即10。另一方面，__getattr__方法的实现没有考虑到self._components之外的实例属性，而是从这个属性中获取shortcut_names中所列的虚拟属性。
修改在Vector类中设置属性的逻辑以应对前后矛盾：
def __setattr__(self, name, value): cls = type(self) if len(name) == 1: if name in cls.shortcut_names: error = ‘readonly attribute {attr_name!r}‘ #xyzt只读 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) #委托给超类的方法
多数时候，如果实现了__getattr__方法，那么也要实现__setattr__方法，以防出现示例那样对象行为不一致。如果想允许修改分量，可以使用__setitem__方法或实现__setattr__方法。
def __hash__(self): #法一，for循环迭代 hashes = (hash(x) for x in self._components) n = 0 for i in hashes: n ^= i return n def __hash__(self): #法二lambda表达式 hashes = (hash(x) for x in self._components) return functools.reduce(lambda a, b: a ^ b, hashes, 0) def __hash__(self): #库函数，推荐 hashes = (hash(x) for x in self._components) return functools.reduce(operator.xor, hashes, 0)
reduce()函数第三个参数是初始值，防止序列为空的异常。一般 +，|，^来说用0；而*和&用1。
或者使用隐射规约计算：
def __hash__(self): hashes = map(hash, self._components) return functools.reduce(operator.xor, hashes, 0)
对于有上千万个分量的Vector实例来说，相等性的比较效率十分低下，因为要复制两个操作数创建两个元组。可修改为：
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 __eq__(self, other): return len(self) == len(other) and all(a == b for a, b in zip(self, other))
zip函数生成一个由元组构成的生成器，元组中各个元素来自参数传入的各个可迭代对象。它返回的元组可以拆包成变量，分别对应于各个并行输入中的一个元素。示例：
from itertools import zip_longest list1 = list(zip(range(3), ‘ABC‘)) print(list1) list2 = list(zip(range(3), ‘ABC‘, [0.1, 1.2, 2.3, 3.4])) print(list2) list3 = list(zip_longest(range(3), ‘ABC‘, [0.1, 1.2, 2.3, 3.4], fillvalue=-1)) print(list3) #结果 [(0, ‘A‘), (1, ‘B‘), (2, ‘C‘)] [(0, ‘A‘, 0.1), (1, ‘B‘, 1.2), (2, ‘C‘, 2.3)] [(0, ‘A‘, 0.1), (1, ‘B‘, 1.2), (2, ‘C‘, 2.3), (-1, -1, 3.4)]
1.当一个可迭代对象耗尽后，它不发出警告就停止
2.zip_longest有所不同，fillvalue作为填充(默认是None)，直到最长的可迭代对象耗尽
以上来自《流畅的python》
标签：tar 风格 循环 属性 不必要 变量 失败 ini diamond
原文地址：https://www.cnblogs.com/lht-record/p/10296548.html
