__slots__，__doc__,__del__,__call__，__iter__,__next__迭代器协议（三十六）

1.__slots__是什么:是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性)
2.引子:使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的,而每个实例的是独立的)
3.为何使用__slots__:字典会占用大量内存,如果你有一个属性很少的类,但是有很多实例,为了节省内存可以使用__slots__取代实例的__dict__
当你定义__slots__后,__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建,而不是为每个实例定义一个
字典,这跟元组或列表很类似。在__slots__中列出的属性名在内部被映射到这个数组的指定小标上。使用__slots__一个不好的地方就是我们不能再给
实例添加新的属性了,只能使用在__slots__中定义的那些属性名。
4.注意事项:__slots__的很多特性都依赖于普通的基于字典的实现。另外,定义了__slots__后的类不再 支持一些普通类特性了,比如多继承。大多数情况下,你应该
只在那些经常被使用到 的用作数据结构的类上定义__slots__比如在程序中需要创建某个类的几百万个实例对象 。
关于__slots__的一个常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。尽管使用__slots__可以达到这样的目的,但是这个并不是它的初衷。
           更多的是用来作为一个内存优化工具。

 

class Foo:
    '描叙信息，不能被继承'
    __slots__ = {"name", "age"}

f1 = Foo()
#print(f1.__dict__) # AttributeError: 'Foo' object has no attribute '__dict__'
print(f1.__slots__) # {'age', 'name'}

f1.name = 'zhangsan'
f1.age = 18
#f1.sex = "male" # 报错，不可以添加新的属性 AttributeError: 'Foo' object has no attribute 'sex'

 

__doc__

class A:
    '描叙信息，不能被继承'
    pass
class B(A):
    pass

a = A()
b = B()
print(a.__doc__) # 描叙信息，不能被继承
print(b.__doc__) # None

 

　　__module__ 表示当前操作的对象在那个模块

　　__class__     表示当前操作的对象的类是什么

from lib.aa import Test
t = Test()
print(t.__module__) # lib.aa

from lib.aa import Test
t = Test()
print(t.__module__) # lib.aa
print(t.__class__) # <class 'lib.aa.Test'>

 

__del__

析构方法，当对象在内存中被释放时，自动触发执行。

注：如果产生的对象仅仅只是python程序级别的（用户级），那么无需定义__del__,如果产生的对象的同时还会向操作系统发起系统调用，

即一个对象有用户级与内核级两种资源，比如（打开一个文件，创建一个数据库链接），则必须在清除对象的同时回收系统资源，这就用到了__del__

class Foo:

    def __del__(self):
        print('执行我啦')

f1=Foo()
del f1
print('------->')

#输出结果
执行我啦
------->

简单示范

典型的应用场景：

创建数据库类，用该类实例化出数据库链接对象，对象本身是存放于用户空间内存中，而链接则是由操作系统管理的，存放于内核空间内存中

当程序结束时，python只会回收自己的内存空间，即用户态内存，而操作系统的资源则没有被回收，这就需要我们定制__del__，在对象被删除前向操作系统发起关闭数据库链接的系统调用，回收资源

这与文件处理是一个道理：

f=open('a.txt') #做了两件事，在用户空间拿到一个f变量，在操作系统内核空间打开一个文件
del f #只回收用户空间的f，操作系统的文件还处于打开状态

#所以我们应该在del f之前保证f.close()执行,即便是没有del，程序执行完毕也会自动del清理资源，于是文件操作的正确用法应该是
f=open('a.txt')
读写...
f.close()
很多情况下大家都容易忽略f.close,这就用到了with上下文管理

__call__

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo:
    def __call__(self, *args, **kwargs):
        print('running...')

f = Foo()
f() # running...

 

__iter__,__next__迭代器协议

class Foo:
    def __init__(self,n):
        self.n = n

    def __iter__(self):
        return self
    def __next__(self):
        if self.n == 10:
            raise StopIteration("终止了...")
        self.n += 1
        return self.n

f = Foo(7)
# print(f.__next__()) # 8
# print(f.__next__()) # 9
# print(next(f)) # 10
#next(f) # StopIteration: 终止了...


for i in f:
    print(i)
'''
8
9
10
'''

class Fibl:
    def __init__(self):
        self._a = 1
        self._b = 1

    def __iter__(self):
        return self
    def __next__(self):
        if self._a > 100:
            raise StopIteration("stop iter...")
        self._a, self._b = self._b, self._a + self._b
        return self._a
f = Fibl()
print(f.__next__())
print(f.__next__())
print(f.__next__())
print('====================')
for i in f:
    print(i)
    
'''
1
2
3
====================
5
8
13
21
34
55
89
144
'''