1. slots的用法
1.1 基本用法
之前学习python的时候，知道使用slots能够节省内存，然而却没有在实际项目中使用过，而且也不清楚为什么能够节省内存？能够节省多少内存？记忆总是那么脆弱，那么干脆来个彻底的探索，并记录之。 首先，我们看看slots的基础用法：
class A(object):
__slots__ = ['name', 'attr']
def __init__(self, name, attr):
self.name = name
self.attr = attr在这里，我们定义了一个类A，它有两个属性name和attr，这样，在A的实例中我们就可以使用name和attr这两个属性了，但是使用一个没有包含在__slots__中的属性就会出错，例如：
那么，到底能省多少内存呢？我们用实例来测量下。
1.2 内存测量工具
要测量内存使用，就需要工具。ipython_memeory_usage是IPython下的实时监测每一行命令所使用的内存的工具，它可以帮助你了解每一个命令用的内存以及花费的时间。（github的readme说它不支持python 2.7，但经我实测一些简单功能还是支持的，更多的没有测试过，为保险起见，可以装python 3版本的，但是如果没有安装python 3，只是简单使用装Python 2版本应该也可以，暂时没有发现问题，如果电脑同时装有python2和3,在Windows下，可以使用 py -2命令和py -3命令分别进入python2和python3，同理，用pip install 和pip3 install分别安装python2和3的第三方库）。
在安装ipython_memory_usage之前，需要首先安装Memory Profiler。直接通过pip install安装会出错，需要到github上(https://github.com/pythonprofilers/memory_profiler)下载安装包，然后通过python setup.py install进行安装。它是一个监测进程中内存消耗的模块，使用方法如下：
from memory_profiler import profile
@profile
def my_func():
a = [1] * (10 ** 6)
b = [2] * (2 * 10 ** 7)
del b
return a假设将其保存为example.py，则运行python example.py，可以得到类似下面的结果：
Line # Mem usage Increment Line Contents
==============================================
3 @profile
4 5.97 MB 0.00 MB def my_func():
5 13.61 MB 7.64 MB a = [1] * (10 ** 6)
6 166.20 MB 152.59 MB b = [2] * (2 * 10 ** 7)
7 13.61 MB -152.59 MB del b
8 13.61 MB 0.00 MB return a每一行的Mem Usage表示当前一共用的内存，Increment标明了这一行使用的内存大小。
安装完Memeory Profiler，我们便可以到ipython_memory_usage的github(https://github.com/ianozsvald/ipython_memory_usage)上下载安装包并进行安装，安装完之后，便可以简单的使用它进行python命令的内存与时间的测量，如下图所示：
从图中我们可以看到，import numpy这个库消耗了14.4766M内存，而生成一个10000000维的数组消耗了76.6484M内存。
1.3 _slots__内存使用和存取速度实测
1.3.1 内存使用测试
最后，我们终于可以进行我们的slots内存测试实验了，如下图：
从实验结果可以看到，对于有两个属性的实例，生成1M个实例，使用slots消耗了49.6250M内存，而没有使用slots消耗了185.9219M内存，使用slots的内存消耗大概为不使用slots的26.69%，内存节省量还是很可观的。
1.3.2 存取速度测试
使用__slots__不但能够节省内存，也能提高存取属性的效率，下面用一个例子验证：
在本人电脑上(python 2.7+windows),测试速度有10%左右的提升。
2. __slots__使用注意事项
虽然使用slots能够节省内存和存取属性的时间，但是也有很多要注意的地方。
2.1 要使用slots，类必须继承自object,而且为了不生成dict，继承体系中的类必须定义slots
如下图所示，我们定义了三个类A、B、C，B和C继承自A，A定义了slots属性attr，B定义了一个空的slots，而C没有定义slots，ob和oc分别是B和C的实例。
接下来，我们分别我ob和oc赋予属性attr2，可以看到，为ob赋予属性时提示没有属性attr2，而为oc赋予属性成功了：
我们查看ob和oc的全部属性，发现oc中生成了dict:
查看oc的dict:
In [14]: oc.__dict__
Out [14]: {'attr2': 'cc'}所以即使父类定义了slots，子类要不生成dict，也要定义空的slots(如果不想引入新的属性的话)。 那么，如果没有继承自object会怎么样呢？我们定义一个具有slots的旧类D，然后对它进行实例化：
可以发现,__slots__并没有起限制作用.
2.2 使用slots的多继承问题
由于__slots__的实现不是简单的列表或者字典，多个父类的非空__slots__不能直接合并，所以使用时会报错（即使多个父类的非空__slots__是相同的）。
如果要使用多继承，那就要使用多个空__slots__的父类，这是关于使用__slots__多继承的唯一办法。
2.3 不要只在生成大量对象的实例时使用__slots__
collections模块的抽象基类虽然不能实例化，但是它们也声明了__slots__，为什么呢？因为如果用户希望继承自collections中的基类的类不要创建__dict__和__weakref，那么父类也必须没有这些属性，所以抽象基类要定义__slots__，以避免不必要的空间使用。
3. 一探究竟——__slots__为什么能够加快属性访问速度和减少内存消耗？
在1.3节我们经过实验验证，使用__slots__能够极大的节省内存，并且存取属性的速率也有所提升，这是为什么呢？《Learning Python》在第38章 Managed Attributes中的Descriptors中有讲到，python的property和slots都是用descriptor实现的，那么我们就从descriptor(描述符)讲起。
3.1 python descriptor(描述符)
在Python中，描述符协议使得我们能够截取特定属性的存取和删除，描述符是一个单独的类，它被赋值给一个类属性，这样就能够截取对这个类属性的获取、赋值和删除了。 一个描述符应该是这样的:
class Descriptor(object):
""docstring goes here"""
def __get__(self, instance, owner):...
def __set__(self, instance, value):...
def _delete__(self, instance):...一个有其中任意一个方法的类就被当做描述符。这里的self是描述符的实例，instarnce是描述符实例被赋予的那个类的实例，owner是描述符实例被赋予的那个类。
class Name(object):
"""name descriptor docs"""
def __get__(self, instance, owner):
print 'fetch...'
return instance._name
def __set__(self, instance, value):
print 'change...'
instance._name = value
def __delete__(self, instance):
print 'remove...'
del instance._name
class Person(object):
def __init__(self, name):
self._name = name
name = Name()
if __name__ == '__main__':
bob = Person("Bob Smith")
print bob.name
bob.name = 'Robert Smith'
print bob.name
del bob.name输出是这样的：
C:\Python27\python.exe D:/LearningPython/test.py
fetch...
Bob Smith
change...
fetch...
Robert Smith
remove...3.2 用纯python实现slots
现在，我们用纯python写一个简单的__slots__的实现。这里用到了元类(metaclass)，有关元类，stack overflow上有个很热的帖子What is a metaclass in Python?，或者有人翻译成了中文版深刻理解Python中的元类.
class Member(object):
# 定义描述器实现slots属性的查找
def __init__(self, i):
self.i = i
def __get__(self, instance, owner):
return instance._slotvalues[self.i]
def __set__(self, instance, value):
instance._slotvalues[self.i] = value
class Type(type):
# 使用元类实现slots
def __new__(cls, name, bases, attrs):
slots = attrs.get('_slots_')
if slots:
for i, slot in enumerate(slots):
attrs[slot] = Member(i)
attrs['_slotvalues'] = [None] * len(slots)
return type.__new__(cls, name, bases, attrs)
class Object(object):
__metaclass__ = Type
class A(Object):
_slots_ = 'x', 'y'
if __name__ == '__main__':
a = A()
print dir(A)
a.x = 10
print a.x在CPython中，当一个A类定义了__slots__=('x', 'y'),A.x就是一个有__get__和__set__方法的member_descriptor，并且在每个实例中可以通过直接访问内存（direct memory access）获得。所以访问A.dict和A.x的速度是相近的。
在上面的例子中，我们用纯python实现了一个等价的slots,当一个元类看到_slots_的定义，就创建相应的描述符属性，并为实例创建一个_slotvalues列表。
这个例子与CPython不同的是： 1. 例子中_slotvalues是一个存储在类对象外部的列表，而在Cpython中它与实例对象存储在一起，可以通过直接访问内存获得。相应地， member_descriptor也不是存在外部列表，而同样可以通过直接访问内存获得。 2. 默认情况下，new方法会为每个实例创建一个字典dict来存储实例的属性，但如果定义了__slots__，__new__方法就不会再创建这个字典，以及__weakref__,但我们的例子没有实现这个功能。
3.3 更快的属性访问
默认情况下，访问一个实例的熟悉是通过访问__dict__来实现的，例如访问a.x就相当于访问a.__dict__['x']，可以简单的理解为四步： 1. a.x 2. a.__dict__ 3. a.__dict__[x] 4. 结果 而定义了__slots__的类会为每个属性创建一个描述器，访问属性时就直接调用这个描述器，可以简单的理解为三步： 1. b.x 2. member descriptor 3. 结果 访问__dict__和访问描述器速度是相近的，所以通过__dict__访问相当于多了一步字典访问（哈希函数）的消耗。所以使用__slots__的类的属性访问速度会稍微快点，1.3.2的实验结果也验证了这点。
3.4 减少内存消耗
虽然使用__slots__能够稍微提高属性访问速度，但是节省内存才是它最大的用途。python 的字典本质上是个哈希表，它是一种以空间换时间的数据结果，而且为了解决冲突，python会在字典使用量超过2/3时，会进行2-4倍的扩容。而slots使用了描述符，只会为属性存储分配必要的内存，所以能够大幅减少内存的使用。
