九、符合 python 风格的对象
绝对不要使用两个前导下划线，这是很烦人的自私行为。
——Ian Bicking
pip、virtualenv 和 Paste 等项目的创建者
得益于 python 数据模型，自定义类型的行为可以像内置类型那样自然。实现如此自然的行为，靠的不是继承，而是鸭子类型：我们只需要按照预定行为实现对象所需的方法即可。
对象表示形式
repr()
以便于开发者理解的方式返回对象的字符串表示形式
str()
以便于用户理解的方式返回对象的字符串表示形式
bytes()
获取对象的字节序列表示形式
format , str.format __format__
使用特殊的格式代码显示对象的字符串表示形式
例子：向量类
In [1]: from array import array
In [2]: import math
In [3]: class Vector2d:
...: typecode = 'd'
...: def __init__(self,x,y):
...: self.x = float(x) # 尽早捕获异常，防止传入参数不当
...: self.y = float(y)
...: def __iter__(self): # 可迭代，可拆包，生成器
...: return (i for i in (self.x,self.y))
...: def __repr__(self):
...: class_name = type(self).__name__
# 感叹号后面跟的是conversion，而conversion有两个值.
# 分别是s对应str()函数, r对应repr()函数。
...: return '{}({!r},{!r})'.format(class_name, *self) # 可迭代，*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(self)
...: def __abs__(self):
...: return math.hypot(self.x,self.y)
...: def __bool__(self):
...: return bool(abs(self))
...: @classmethod
...: def frombytes(cls, b):
...: typecode = chr(b[0])
...: memv = memoryview(b[1:]).cast(typecode) # 将共享内存数据转为 'd' 类型
...: return cls(*memv)
...: def __format__(self,fmt_spec = ''): # 以 p 结尾的 格式说明符，返回向量形式
...: # compnents = (format(c,fmt_spec) for c in self)
...: #return '({}, {})'.format(*compnents)
...: if fmt_spec.endswith('p'):
...: fmt_spec = fmt_spec[:-1]
...: coords = (abs(self), self.angle())
...: outer_fmt = '<{}, {}>'
...: else:
...: coords = self
...: outer_fmt = '({}, {})'
...: components = (format(c, fmt_spec) for c in coords)
...: return outer_fmt.format(*components)
...:
...: def angle(self):
...: return math.atan2(self.y,self.x)
classmethod
classmethod 最常见的用途是定义备选构造方法。
staticmethod
静态方法就是定义在类中的普通函数。
格式化显示
__format__(format_spec)
format_spec 是格式说明符
1 format(my_obj, format_spec)
2 str.format() 方法的格式字符串，{} 里代换字段中冒号后面的部分
In [22]: format(brl, '0.4f') # 格式说明符是 0.4f
Out[22]: '0.4274'
IIn [23]: '1 BRL = {rate:0.2f} US'.format(rate=brl) # 格式说明符是 0.2f
# 代换字段中的 'rate' 子串是字段名称，与格式说明符无关，但是它决定把 .format() 的哪个参数传给代换字段。
Out[23]: '1 BRL = 0.43 US'
第 2 条标注指出了一个重要知识点：'{0.mass:5.3e}' 这样的格式字符串其实包含两部分，冒号左边的 '0.mass' 在代换字段句法中是字段名，冒号后面的 '5.3e' 是格式说明符。格式说明符使用的表示法叫格式规范微语言（“Format Specification Mini Language”，https://docs.python.org/3/library/string.html#formatspec）。
datetime 模块中的类，它们的 __format__·方法使用的格式代码与 strftime() 函数一样。
>>> from datetime import datetime
>>> now = datetime.now()
>>> format(now, '%H:%M:%S')
'18:49:05'
>>> "It's now {:%I:%M %p}".format(now)
"It's now 06:49 PM"
如果类没有定义 __format__ 方法，从 object 继承的方法，会返回 str(my_obj)
然而，如果传入格式说明符， obj.__format__ 会抛出异常。
In [24]: format(a)
Out[24]: '(1.0, 2.0)'
In [25]: format(a,'.3f')
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-25-75412ed59581> in <module>
----> 1 format(a,'.3f')
TypeError: unsupported format string passed to Vector2d.__format__
自定义 p 结尾，为向量形式
>>> format(Vector2d(1, 1), 'p')
'<1.4142135623730951, 0.7853981633974483>'
>>> format(Vector2d(1, 1), '.3ep')
'<1.414e+00, 7.854e-01>'
>>> format(Vector2d(1, 1), '0.5fp')
'<1.41421, 0.78540>'
可散列的 Vector2d
当前对象不可散列
In [40]: a
Out[40]: Vector2d(7.0,8.0)
In [41]: b = {a : 1}
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-41-12275979062c> in <module>
----> 1 b = {a : 1}
TypeError: unhashable type: 'Vector2d'
In [42]: hash(a)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-42-57b555d30865> in <module>
----> 1 hash(a)
TypeError: unhashable type: 'Vector2d'
什么是可散列的数据类型
如果一个对象是可散列的，那么在这个对象的生命周期中，它的散列值是不变的，而且这个对象需要实现 __hash__() 方法。另外可散列对象还要有 __qe__() 方法，这样才能跟其他键做比较。如果两个可散列对象是相等的，那么它们的散列值一定是一样的……
根据特殊方法 __hash__的文档（https://docs.python.org/3/reference/datamodel.html），最好使用位运算符异或（^）混合各分量的散列值——我们会这么做。
In [45]: class Vector2d:
...: typecode = 'd'
...: def __init__(self,x,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 __hash__(self):
...: return hash(self.x) ^ hash(self.y)
In [57]: a = Vector2d(7,8)
In [58]: a
Out[58]: <__main__.Vector2d at 0x274a4874cc0>
In [59]: hash(a)
Out[59]: 15
In [60]: b = Vector2d(1,1)
In [61]: hash(b)
Out[61]: 0
要想创建可散列的类型，不一定要实现特性，也不一定要保护实例属性。只需要正确实现 __hash__ 和 __eq__ 方法即可。但是，实例的散列值绝对不应该变化。
如果定义的类型有标量数值，可能还要实现 __init__ 和 __float__ 方法（分别 被 int 和 float 构造函数调用），以便在某些情况下用于强制转换类型。此外，还有用于支持内置的 complex() 构造函数的 __complex__ 方法。
Python 的私有属性和“受保护的”属性
私有属性：__mood 会存入实例的 __dict__ 属性中，变成 _Dog__mood ，且会在前面加上一个下划线和类名。这个语言特性叫 名称改写。
名称改写是一种安全措施，不能保证万无一失：它的目的是避免意外访问，不能防止故意做错事。
只要编写 v1._Vector__x = 7 这样的代码，就能轻松地为 Vector2d 实例的私有分量直接赋值。如果真在生产环境中这么做了，出问题时可别抱怨。
不过在模块中，顶层名称使用一个前导下划线的话，的确会有影响：对 from mymod import * 来说，mymod 中前缀为下划线的名称不会被导入。然而，依旧可以使用 from mymod import _privatefunc 将其导入。Python 教程的 6.1节“More on Modules”（https://docs.python.org/3/tutorial/modules.html#more-on-modules）说明了这一点。
Python 文档的某些角落把使用一个下划线前缀标记的属性称为“受保护的”属性。使用self._x 这种形式保护属性的做法很常见，但是很少有人把这种属性叫作“受保护的”属性。有些人甚至将其称为“私有”属性。
总之，Vector2d 的分量都是“私有的”，而且 Vector2d 实例都是“不可变的”。我用了两对引号，这是因为并不能真正实现私有和不可变。
使用 __slots__ 类属性节省空间
默认情况下，python 在各个实例中名为 __dict__ 的字典里存储实例属性。为了使用底层的散列表提升访问速度，字典会消耗大量内存。如果属性过多，用 __slots__ 存储属性，能节省大量内存，方法是让解释器在元组中存储实例属性，而不是用字典。
继承自超类的 __slots__ 属性没有效果。Python 只会使用各个类中定义的 __slots__ 属性。
定义 __slots__ 的方式是，创建一个类属性，使用 __slots__ 这个名字，并把它的值设为一个字符串构成的可迭代对象，其中各个元素表示各个实例属性。我喜欢使用元组，因为这样定义的 __slots__ 中所含的信息不会变化。
class Vector2d:
__slots__ = ('__x', '__y')
typecode = 'd'
在类中定义 __slots__ 属性的目的是告诉解释器：“这个类中的所有实例属性都在这儿了！”这样，Python 会在各个实例中使用类似元组的结构存储实例变量，从而避免使用消耗内存的 __dict__ 属性。如果有数百万个实例同时活动，这样做能节省大量内存。
如果要处理数百万个数值对象，应该使用 NumPy 数组。NumPy 数组能高效使用内存，而且提供了高度优化的数值处理函数，其中很多都一次操作整个数组。
在类中定义 __slots__ 属性之后，实例不能再有 __slots__ 中所列名称之外的其他属性。这只是一个副作用，不是 __slots__ 存在的真正原因。不要使用 __slots__ 属性禁止类的用户新增实例属性。__slots__ 是用于优化的，不是为了约束程序员。
然而，“节省的内存也可能被再次吃掉”：如果把 '__dict__' 这个名称添加到 __slots__ 中，实例会在元组中保存各个实例的属性，此外还支持动态创建属性，这些属性存储在常规的 __dict__ 中。当然，把 '__dict__' 添加到 __slots__ 中可能完全违背了初衷，这取决于各个实例的静态属性和动态属性的数量及其用法。粗心的优化甚至比提早优化还糟糕。
此外，还有一个实例属性可能需要注意，即 __weakref__ 属性，为了让对象支持弱引用（参见 8.6 节），必须有这个属性。用户定义的类中默认就有 __weakref__ 属性。可是，如果类中定义了 __slots__ 属性，而且想把实例作为弱引用的目标，那么要把 '__weakref__' 添加到__slots__ 中。
综上，__slots__ 属性有些需要注意的地方，而且不能滥用，不能使用它限制用户能赋值的属性。处理列表数据时 __slots__ 属性最有用，例如模式固定的数据库记录，以及特大型数据集。
__slots__ 的问题
1 每个子类都要定义 __slots__ 属性，因为解释器会忽略继承的 __slots__ 属性。
2 实例只能拥有 __slots__ 中列出的属性，除非把 '__dict__' 加入 __slots__ 中（这样做就失去了节省内存的功效）。
3 如果不把 '__weakref__' 加入 __slots__，实例就不能作为弱引用的目标。
如果你的程序不用处理数百万个实例，或许不值得费劲去创建不寻常的类，那就禁止它创建动态属性或者不支持弱引用。与其他优化措施一样，仅当权衡当下的需求并仔细搜集资料后证明确实有必要时，才应该使用 __slots__属性。
覆盖类属性
Python 有个很独特的特性：类属性可用于为实例属性提供默认值。但是，如果为不存在的实例属性赋值，会新建实例属性。假如我们为 typecode 实例属性赋值，那么同名类属性不受影响。然而，自此之后，实例读取的 self.typecode 是实例属性 typecode，也就是把同名类属性遮盖了。借助这一特性，可以为各个实例的 typecode 属性定制不同的值。
如果想修改类属性的值，应该直接 类.属性 而不是 self.属性，修改类属性，可以修改所有实例的类属性。
然而，有种修改方法更符合 Python 风格，而且效果持久，也更有针对性。类属性是公开的，因此会被子类继承，于是经常会创建一个子类，只用于定制类的数据属性。
这也说明了我在 Vecto2d.__repr__ 方法中为什么没有硬编码 class_name 的值，而是使用 type(self).__name__ 获取。如果硬编码 class_name 的值，那么 Vector2d 的子类（如 ShortVector2d）要覆盖__repr__ 方法，只是为了修改 class_name 的值。从实例的类型中读取类名，__repr__ 方法就可以放心继承。
__index__ 这个方法的作用是强制把对象转换成整数索引，在特定的序列切片场景中使用，以及满足 NumPy 的一个需求。
要构建符合 Python 风格的对象，就要观察真正的 Python 对象的行为。 ——古老的中国谚语
特性有助于减少前期投入
python 类和实例的所有属性都是公开的，当要避免意外修改了属性，可以实现特性，调用方式不受影响。
java 没有特性，只能实现读值方法和设值方法。然而，这些方法必须写，但不能保证有用。
维基的发明人和极限编程先驱 Ward Cunningham 建议问这个问题：“做这件事最简单的方法是什么？”意即，我们应该把焦点放在目标上。提前实现设值方法和读值方法偏离了目标。在 Python 中，我们可以先使用公开属性，然后等需要时再变成特性。
私有属性的安全性和保障性
Perl 不会强制你保护隐私。你应该待在客厅外，因为你没收到邀请，而不是因为里面有把枪。
——Larry Wall | Perl 之父
java 提供好的隐私保障，但是只有用 SecurityManager 部署时，才是绝对隐私的。但是，实际并不常用。
所以，java 的隐私属性也是一种防止意外的措施。通常也不是绝对安全的，也是可以修改的。
所以，隐私属性并非绝对隐私，而是一种防止意外的措施，是一种约定俗成的规范。
作者：我的观点是，Java 中的访问控制修饰符基本上也是安全措施，不能保证万无一失——至少实践中是如此。因此，安心享用 Python 提供的强大功能吧，放心去用吧！