类工厂函数
本书多次提到标准库中的一个类工厂函数
——collections.namedtuple。我们把一个类名和几个属性名传给这
个函数，它会创建一个 tuple 的子类，其中的元素通过名称获取，还
为调试提供了友好的字符串表示形式（__repr__）。
有时，我觉得应该有类似的工厂函数，用于创建可变对象。假设我在编
写一个宠物店应用程序，我想把狗的数据当作简单的记录处理。编写下
面的样板代码让人厌烦：
class Dog:
def __init__(self, name, weight, owner):
self.name = name
self.weight = weight
self.owner = owner
无趣……各个字段名称出现了三次。写了这么多样板代码，甚至字符串
表示形式都不友好：
>>> rex = Dog('Rex', 30, 'Bob')
>>> rex
<__main__.Dog object at 0x2865bac>
参考 collections.namedtuple，下面我们创建一个
record_factory 函数，即时创建简单的类（如 Dog）。这个函数的用
法如示例 21-1。
示例 21-1 测试 record_factory 函数，一个简单的类工厂函数
>>> Dog = record_factory('Dog', 'name weight owner') ➊
>>> rex = Dog('Rex', 30, 'Bob')
>>> rex ➋
Dog(name='Rex', weight=30, owner='Bob')
>>> name, weight, _ = rex ➌
>>> name, weight
('Rex', 30)
>>> "{2}'s dog weighs {1}kg".format(*rex) ➍
"Bob's dog weighs 30kg"
>>> rex.weight = 32 ➎
>>> rex
Dog(name='Rex', weight=32, owner='Bob')
>>> Dog.__mro__ ➏
(<class 'factories.Dog'>, <class 'object'>)
❶ 这个工厂函数的签名与 namedtuple 类似：先写类名，后面跟着写
在一个字符串里的多个属性名，使用空格或逗号分开。
❷ 友好的字符串表示形式。
❸ 实例是可迭代的对象，因此赋值时可以便利地拆包。
❹ 传给 format 等函数时也可以拆包。
❺ 记录实例是可变的对象。
❻ 新建的类继承自 object，与我们的工厂函数没有关系。
record_factory 函数的代码在示例 21-2 中。
示例 21-2 record_factory.py：一个简单的类工厂函数
def record_factory(cls_name, field_names):
try:
field_names = field_names.replace(',', ' ').split() ➊
except AttributeError: # 不能调用.replace或.split方法
pass # 假定field_names本就是标识符组成的序列
field_names = tuple(field_names) ➋
def __init__(self, *args, **kwargs): ➌
attrs = dict(zip(self.__slots__, args))
attrs.update(kwargs)
for name, value in attrs.items():
setattr(self, name, value)
def __iter__(self): ➍
for name in self.__slots__:
yield getattr(self, name)
def __repr__(self): ➎
values = ', '.join('{}={!r}'.format(*i) for i
in zip(self.__slots__, self))
return '{}({})'.format(self.__class__.__name__, values)
cls_attrs = dict(__slots__ = field_names, ➏
__init__ = __init__,
__iter__ = __iter__,
__repr__ = __repr__)
return type(cls_name, (object,), cls_attrs) ➐
❶ 这里体现了鸭子类型：尝试在逗号或空格处拆分 field_names；如
果失败，那么假定 field_names 本就是可迭代的对象，一个元素对应
一个属性名。
❷ 使用属性名构建元组，这将成为新建类的 __slots__ 属性；此外，
这么做还设定了拆包和字符串表示形式中各字段的顺序。
❸ 这个函数将成为新建类的 __init__ 方法。参数有位置参数和（或）
关键字参数。
❹ 实现 __iter__ 函数，把类的实例变成可迭代的对象；按照
__slots__ 设定的顺序产出字段值。
❺ 迭代 __slots__ 和 self，生成友好的字符串表示形式。
❻ 组建类属性字典。
❼ 调用 type 构造方法，构建新类，然后将其返回。
通常，我们把 type 视作函数，因为我们像函数那样使用它，例如，调
用 type(my_object) 获取对象所属的类——作用与
my_object.__class__ 相同。然而，type 是一个类。当成类使用时，
传入三个参数可以新建一个类：
MyClass = type('MyClass', (MySuperClass, MyMixin),
{'x': 42, 'x2': lambda self: self.x * 2})
type 的三个参数分别是 name、bases 和 dict。最后一个参数是一个
映射，指定新类的属性名和值。上述代码的作用与下述代码相同：
class MyClass(MySuperClass, MyMixin):
x = 42
def x2(self):
return self.x * 2
让人觉得新奇的是，type 的实例是类，例如这里的 MyClass 类或示例
21-1 中的 Dog 类。
总之，示例 21-2 中 record_factory 函数的最后一行会构建一个类，
类的名称是 cls_name 参数的值，唯一的直接超类是 object，有
__slots__、__init__、__iter__ 和 __repr__ 四个类属性，其中后
三个是实例方法。
我们本可以把 __slots__ 类属性的名称改成其他值，不过要是那样的
话，就要实现 __setattr__ 方法，为属性赋值时验证属性的名称，因
为对于记录这样的类，我们希望属性始终是固定的那几个，而且顺序相
同。然而 9.8 节说过，__slots__ 属性的主要特色是节省内存，能处理
数百万个实例，不过也有一些缺点。
把三个参数传给 type 是动态创建类的常用方式。如果查看
collections.namedtuple 函数的源码
（https://hg.python.org/cpython/file/3.4/Lib/collections/__init__.py#l236），
你会发现另一种方式：先声明一个 _class_template 变量，其值是字
符串形式的源码模板；然后在 namedtuple 函数中调用
_class_template.format(…) 方法，填充模板里的空白；最后，使
用内置的 exec 函数计算得到的源码字符串。
在 Python 中做元编程时，最好不用 exec 和 eval 函数。如
果接收的字符串（或片段）来自不可信的源，那么这两个函数会带
来严重的安全风险。Python 提供了充足的内省工具，大多数时候都不需要使用 exec 和 eval 函数。然而，Python 核心开发者实现
namedtuple 函数时选择了使用 exec 函数，这样做是为了让生成
的类代码能通过 ._source 属性
（https://docs.python.org/3/library/collections.html#collections.somenamedtuple._source
获取。
record_factory 函数创建的类，其实例有个局限——不能序列化，即
不能使用 pickle 模块里的 dump/load 函数处理。这个示例是为了说
明如何使用 type 类满足简单的需求，因此不会解决这个问题。如果想
了解完整的方案，请分析 collections.nameduple 函数的源码
（https://hg.python.org/cpython/file/3.4/Lib/collections/init.py#l236），
搜索“pickling”这个词。