《Effective Python》笔记 第六章-元类与属性
阅读Effective Python（第二版）的一些笔记
第44条 用纯属性与修饰器取代旧式的setter与getter方法
有一些编程语法，会为每个属性定义对应的getter和setter，用来获取属性和设置属性值，但是在Python中，不用这么复杂，直接使用对象.属性名来访问即可;
如果在访问属性时需要做特殊的处理，那么可以使用@property实现，并且在使用@property时，不要引发奇怪的副作用，比如进行io操作或者其他耗时的操作。
# coding:utf-8
class Person(object):
def __init__(self):
self.name = None
self._age = None
@property
def age(self):
print("执行@property装饰的age()")
return self._age
@age.setter
def age(self, new_age):
print("执行@age.setter装饰的age(), new_age:%s" % new_age)
if new_age < 0:
raise Exception("age必须大于等0")
self._age = new_age
p = Person()
p.name = "abc"
p.age = 10 # 执行@age.setter装饰的age(), new_age:10
print(p.name) # abc
print(p.age)
# 执行@property装饰的age()
# 10
第45条 考虑用@property实现新的属性访问逻辑，不要急着重构原有的代码
如果一个类里面属性访问和设置的逻辑比较复杂，现在需要修改这些逻辑，建议不要重构已有的代码，而是使用@property来改已有的实例属性增加功能（将已有的逻辑迁移到@property中）；
另外如果类中的@property比较多了，这时候应该考虑这种重构这个类了，因为每个属性的访问和设置时，都有逻辑，那么这个类就特别复杂了。
第46条 用描述符来改写需要复用的@property方法
@property是很方便，但是还是有一些无法处理的问题，我们需要明确的为某个属性定义加上@property和@property.setter``，如果我们给A属性加了，但是没有给B属性加，那么B就不能像A那样使用`@property的便捷。
那么如何做，才能实现B不加@property也能使用@property的便捷呢？可以使用描述符；
什么是描述符，可以先看下面这个例子：
class Person(object):
def __init__(self):
self.name = None
person = Person()
当为person的name属性复制时，person.name = "abc"，翻译为Person.__dict__['name'].__set__(person, "abc");
当获取person的name属性值时，print(person.name)，翻译为print(Person.__dict__['name'].__get__(person, "abc"))；
也就是说，当访问对象的属性时，Python会转为在类的层面查找，查询Person类里面有没有这样一个属性。如果有，而且还是个实现了__get__与__set__方法的对象，那么系统就认定你想通过描述符协议定义这个属性的访问行为。
将上面的翻译拆分一下Person.__dict__['name'].__set__(person, "abc")，首先是Person.__dict__['name']，这个结果肯定是个对象，然后调用这个对象的__set__(person, "abc")和__get__(person, "abc"))；前面我们提到类中的属性不加@property就不能使用@property的便捷，那么这里看来，只要Person.__dict__['xxx']都支持__set__和__get__即可。
第47条 针对惰性属性使用__getattr__、getattribute__及__setattr
- 如果访问一个类中未定义的属性（注意不是实例属性），就会调用该类的
__getattr__方法 - 当要给对象的属性设置值时候，就会调用
__setattr__方法。 - 访问一下类中的属性，不论该属性是否存在，都会调用
__getattr__方法
一般情况下，对象可能会包含很多数据，这些数据可以在类加载的时候被初始化，这种情况可能不是最优的，也许加载的数据很久用不到，甚至运行过程不会用到，此时就可以使用懒加载，实现的时候，可以自己定义懒加载方法，另外一种方式是使用__getattr__，这种方式动态的加载数据并动态为类增加一个属性。
第48条 用__init_subclass__验证子类写得是否正确
当子类继承了父类后，父类的一些接口如果要子类保证数据的某些规则，这个时候父类怎么对子类进行限制呢？
一种方式就是父类中定义check方法，子类继承后，由子类主动调用check方法来校验参数是否符合条件，如下所示
#coding:utf-8
class BaseClass(object):
DATA = None
@classmethod
def check_data(cls):
if cls.DATA is None:
raise RuntimeError
elif not isinstance(cls.DATA, dict):
raise TypeError
class ChildClass(BaseClass):
# 设置属性值
DATA = dict()
child = ChildClass()
# 手动调用check
child.check_data()
还有一种方式，就是使用__init_subclass__，简单的示例如下
#coding:utf-8
class SuperClass(object):
def __init_subclass__(cls, **kwargs):
print("run SuperClass.__init_subclass__")
print("cls:%s" % cls)
print("**kwargs:%s" % kwargs)
# 类属性demo_value设置为abc-xyz
cls.demo_value = "abc-xyz"
# 定义子类
class SubClass(SuperClass):
# 子类也定义了demo_value
demo_value = "qaq"
sub = SubClass()
print(sub.demo_value)
# run SuperClass.__init_subclass__
# cls:<class '__main__.SubClass'>
# **kwargs:{}
# abc-xyz
# 定义另外一个子类
class SecondClass(SubClass):
demo_value = "second"
second = SecondClass()
print(second.demo_value)
# run SuperClass.__init_subclass__
# cls:<class '__main__.SecondClass'>
# **kwargs:{}
# abc-xyz
看了上面__init_subclass__的例子，就可以看出，父类是可以修改子类的数据；
现在需要的是父类中增加子类参数的校验，肯定是办不到的，因为父类始终覆盖了子类的数据，其实在继承的时候，还可以指定参数，传给__init_subclass_的kwargs。示例如下：
class SuperClass(object):
def __init_subclass__(cls, **kwargs):
print("run SuperClass.__init_subclass__")
print("cls:%s" % cls)
print("**kwargs:%s" % kwargs)
# 进行校验
if "demo_value" not in kwargs:
raise RuntimeError
if len(kwargs['demo_value']) < 0:
raise RuntimeError
cls.demo_value = kwargs['demo_value']
# 在继承的时候，还可以指定参数，传给`__init_subclass_`的kwargs
class ThirdClass(SuperClass, demo_value="abc", other_value="dfadfasf"):
pass
third = ThirdClass()
print(third.demo_value)
# run SuperClass.__init_subclass__
# cls:<class '__main__.ThirdClass'>
# **kwargs:{'demo_value': 'abc', 'other_value': 'dfadfasf'}
# abc
于是，这样就在父类中定义了子类数据的check。
第49条 用__init_subclass__记录现有的子类
如果定义了一个类后，怎么知道这个类有哪些子类呢？比较简单的大概有以下几种思路，首先肯定会有一个几个来保存有哪些子类，每当有新的子类时，就加入到该集合：
方式1：子类初始化方法中，手动将自己加入到集合中
#coding:utf-8
class SuperClass(object):
# 保存继承该类的子类，key为名称，value为type
SUB_CLASS_DICT = {}
class OneClass(SuperClass):
def __init__(self):
SuperClass.SUB_CLASS_DICT.setdefault(self.__class__.__name__, self.__class__)
class TwoClass(SuperClass):
def __init__(self):
SuperClass.SUB_CLASS_DICT.setdefault(self.__class__.__name__, self.__class__)
one = OneClass()
two = TwoClass()
print(SuperClass.SUB_CLASS_DICT)
# {'OneClass': <class '__main__.OneClass'>, 'TwoClass': <class '__main__.TwoClass'>}
方式2：父类扩展__new__方法，那么子类就不需要手动将自己加入到集合中；
class SuperClassV2(object):
# key为名称，value为type
SUB_CLASS_DICT = {}
def __new__(cls, *args, **kwargs):
cls.SUB_CLASS_DICT.setdefault(cls.__name__, cls)
class OneClassV2(SuperClassV2):
pass
class TwoClassV2(SuperClassV2):
pass
one = OneClassV2()
two = TwoClassV2()
print(SuperClassV2.SUB_CLASS_DICT)
# {'OneClassV2': <class '__main__.OneClassV2'>, 'TwoClassV2': <class '__main__.TwoClassV2'>}
方式3：使用__init_subclass__来实现，功能就是创建对象后会回调该方法，该方法定义在父类中，这样的话，子类也不需要手动将自己加入到集合中；
class SuperClassV3(object):
# key为名称，value为type
SUB_CLASS_DICT = {}
def __init_subclass__(cls, **kwargs):
cls.SUB_CLASS_DICT.setdefault(cls.__name__, cls)
class OneClassV3(SuperClassV3):
pass
class TwoClassV3(SuperClassV3):
pass
one = OneClassV3()
two = TwoClassV3()
print(SuperClassV3.SUB_CLASS_DICT)
# {'OneClassV3': <class '__main__.OneClassV3'>, 'TwoClassV3': <class '__main__.TwoClassV3'>}
第50条 用__set_name__给类属性加注解
todo
第51条 优先考虑通过类修饰器来提供可组合的扩充功能，不要使用元类
假设有一个装饰器，可以记录方法执行的入参和返回值，比如下面这样：
# coding:utf-8
import time
def log(func):
def wraper(*args, **kwargs):
print("func_name:%s, args:%s, kwargs:%s" % (func.__name__, args, kwargs))
result = func(*args, **kwargs)
print("func_name:%s, result:%s" % (func.__name__, result))
return result
return wraper
@log
def do_repeat(msg, repeat_times):
time.sleep(1)
return msg * repeat_times
do_repeat("abc", 10)
# func_name:do_repeat, args:('abc', 10), kwargs:{}
# func_name:do_repeat, result:abcabcabcabcabcabcabcabcabcabc
如果一个类中有10个方法，每个方法都需要有这个功能，怎么做呢？只需要给每个方法都加上@log装饰器即，如果有20个呢？30个呢？
这个时候如果还手动添加，就不太好了，怎么做可以只加一次呢？
方式1：可以使用元类，在__new__中统一为所有方法添加该装饰器（相当于装饰后覆盖）
# 类中需要装饰的类型
handle_types = (
types.MethodType,
types.FunctionType,
types.BuiltinMethodType,
types.BuiltinFunctionType,
types.MethodDescriptorType,
types.ClassMethodDescriptorType
)
class SuperClass(object):
def __new__(cls, *args, **kwargs):
clazz = super().__new__(cls, *args, **kwargs)
# 遍历类的方法，
for key in dir(clazz):
value = getattr(clazz, key)
# 如果是function上面的哪几种类型，就装饰后进行覆盖
if isinstance(value, handle_types):
wraped_func = log(value)
setattr(clazz, key, wraped_func)
# 返回方法被装饰后的类
return clazz
class SubClass(SuperClass):
def say(self, msg):
return "say msg----------" + msg
def show(self, msg):
return "show msg________" + msg
sub = SubClass()
sub.say("hello")
# func_name:say, args:('hello',), kwargs:{}
# func_name:say, result:say msg----------hello
sub.show("yes")
# func_name:show, args:('yes',), kwargs:{}
# func_name:show, result:show msg________yes
方式2：使用类装饰器，前面都是介绍的函数装饰器，其实也有类装饰器，是对类进行增强，返回一个新的类，这样的话，就可以将上面__new__中的逻辑提到类装饰器中，示例如下：
def log_class(clazz):
# 遍历类的方法
for key in dir(clazz):
value = getattr(clazz, key)
# 如果是function上面的哪几种类型，就装饰后进行覆盖
if isinstance(value, handle_types):
wraped_func = log(value)
setattr(clazz, key, wraped_func)
return clazz
@log_class
class TwoClass(object):
def say(self, msg):
return "say msg----------" + msg
def show(self, msg):
return "show msg________" + msg
two = TwoClass()
# func_name:__new__, args:(<class '__main__.TwoClass'>,), kwargs:{}
# func_name:__new__, result:<__main__.TwoClass object at 0x108962a00>
two.say("dadfd")
# func_name:say, args:(<__main__.TwoClass object at 0x108962a00>, 'dadfd'), kwargs:{}
# func_name:say, result:say msg----------dadfd
two.show("erwer")
# func_name:show, args:(<__main__.TwoClass object at 0x108962a00>, 'erwer'), kwargs:{}
# func_name:show, result:show msg________erwer
推荐使用类装饰器，这样并不会修改需要使用该装饰器的代码；因为前两种方式，要么需要修改类中的每个方法，也不需要修改类的继承，对类的侵入性比较小。
