slots与迭代器

Posted 2020-09-14 高卓

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

 1 class Foo:
 2     __slots__=‘x‘
 3 
 4 
 5 f1=Foo()
 6 f1.x=1
 7 f1.y=2#报错
 8 print(f1.__slots__) #f1不再有__dict__
 9 
10 class Bar:
11     __slots__=[‘x‘,‘y‘]
12     
13 n=Bar()
14 n.x,n.y=1,2
15 n.z=3#报错

slots

5.__next__和__iter__实现迭代器协议:

 

 1 class Foo:
 2     def __init__(self,start,stop):
 3         self.num=start
 4         self.stop=stop
 5     def __iter__(self):
 6         return self
 7     def __next__(self):
 8         if self.num >= self.stop:
 9             raise StopIteration
10         n=self.num
11         self.num+=1
12         return n
13 
14 f=Foo(1,5)
15 from collections import Iterable,Iterator
16 print(isinstance(f,Iterator))
17 
18 for i in Foo(1,5):
19     print(i)

__next__和__iter__

 

 1 class Range:
 2     def __init__(self,start,end):
 3         self.start=start
 4         self.end=end
 5     def __iter__(self):
 6         return self
 7     def __next__(self):
 8         if self.start==self.end:
 9             raise StopIteration
10         n=self.start
11         self.start+=1
12         return n
13 
14 for i in Range(0,3):
15     print(i)

Range迭代器

6.__call__:

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

class Foo:

    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print(‘__call__‘)


obj = Foo() # 执行 __init__
obj()       # 执行 __call__

__call__