内置函数补充及__getattribute__

isinstance(obj,cls)检查obj是否是类cls的实例,反映族谱关系(不仅父类可以,父类的父类也可以) 

issubclass(subcls,cls)检查subcls是否是cls的子类

SRE实战 互联网时代守护先锋,助力企业售后服务体系运筹帷幄!一键直达领取阿里云限量特价优惠。

 

__getattribute__属性存不存在都会触发它 ‘大哥’ 里面抛出Attribute Error时交给小弟处理

__getattr__属性不存在触发 ‘小弟

 

 item系列

item是字典方式触发的

__setitem__

__getitem__

__delitem__

 1 class Foo:
 2     def __getitem__(self, item):
 3         print('getitem',item)
 4         return self.__dict__[item]
 5 
 6     def __setitem__(self, key, value):
 7         print('setitem')
 8         self.__dict__[key]=value
 9 
10     def __delitem__(self, key):
11         print('delitem')
12         self.__dict__.pop(key)
13 
14 f1=Foo()
15 print(f1.__dict__)
16 # f1.name='egon'  #---->点触发attr系列方法
17 f1['name']='egon'  #--->中括号字典形式触发item系列方法
18 f1['age']=18
19 
20 print('===>',f1.__dict__)
21 
22 # del f1.name
23 # print(f1.__dict__)
24 25 # print(f1.age)
26 del f1['name']
27 print(f1.__dict__)
28 
29 print(f1['age'])

输出

{}
setitem
setitem
===> {'name': 'egon', 'age': 18}
delitem
{'age': 18}
getitem age
18

 

__str__和__repr__

 1 class Foo:
 2     def __init__(self,name,age):
 3         self.name=name
 4         self.age=age
 5     def __repr__(self):
 6         return 'this is repr'
 7     # def __str__(self):
 8     #     return 'this is str'
 9 f1=Foo('cy',23)
10 print(f1)   #str(f1)-->f1.__str__()

输出

this is repr

 

 

st函数或者print函数--->obj.__str__()

repr函数或者交互式解释器--->obj.__repr__()

如果__str__没被定义,那就使用__repr__来代替输出

str和repr返回的必须是字符串,否则抛出异常

 

自定制format

 1 format_dic={
 2     'ymd':'{0.year}{0.mon}{0.day}',
 3     'm-d-y':'{0.mon}-{0.day}-{0.year}',
 4     'y:m:d':'{0.year}:{0.mon}:{0.day}'
 5 }
 6 class Date:
 7     def __init__(self,year,mon,day):
 8         self.year=year
 9         self.mon=mon
10         self.day=day
11     def __format__(self, format_spec):
12         print('执行__format__方法')
13         print('--->',format_spec)
14         if not format_spec or format_spec not in format_dic:
15             format_spec='ymd'
16         fm=format_dic[format_spec]
17         return fm.format(self)
18 d1=Date(2016,12,26)
19 # format(d1) #d1.__format__()
20 print('没设置格式,采用默认格式==>',format(d1))
21 print(format(d1,'ymd'))
22 print(format(d1,'y:m:d'))
23 print(format(d1,'m-d-y'))
24 print('已设定格式但格式不存在,采用默认格式==>',format(d1,'m-d:y'))

输出

执行__format__方法
--->
没设置格式,采用默认格式==> 20161226
执行__format__方法
---> ymd
20161226
执行__format__方法
---> y:m:d
2016:12:26
执行__format__方法
---> m-d-y
12-26-2016
执行__format__方法
---> m-d:y
已设定格式但格式不存在,采用默认格式==> 20161226

 

__slots__

(慎用)是一个类变量,变量值可以是字符串、列表、元组或者可迭代对象(意味着所有实例只有一个数据属性)

  为何使用__slots__?优势在于省内存(字典会占用大量内存,如果有一个属性很少的类,但是有很多实例,为了节省内存可以使用__slots__取代实例的__dict__,设置了__slots__之后,__dict__就没了)

  使用点来访问属性本质就是在访问类或对象的__dict__属性字典(类的字典是共享的,而每个实例是独立的)

  特点:不允许设置其他数据属性。  

  

 1 class Foo:
 2     __slots__=['name','age']  #{'name':None,'age':None}
 3     # __slots__='name' #{'name':None,'age':None}
 4 
 5 f1=Foo()
 6 # f1.name='egon'
 7 # print(f1.name)
 8 
 9 # f1.age=18  #--->setattr----->f1.__dict__['age']=18
10 
11 # print(f1.__dict__)
12 print(Foo.__slots__)
13 print(f1.__slots__)
14 f1.name='egon'
15 f1.age=17
16 print(f1.name)
17 print(f1.age)
18 # f1.gender='male'
19 
20 
21 f2=Foo()
22 print(f2.__slots__)
23 f2.name='alex'
24 f2.age=18
25 print(f2.name)
26 print(f2.age)

输出

['name', 'age']
['name', 'age']
egon
17
['name', 'age']
alex
18

 

__doc__

定义于开头用来说明文档信息的一个字符串,且无法被继承。

写不写都有,不写默认是None。

 

__module__和__class__

查看实例来自哪个模块  对象.__module__

查看实例是什么类  对象.__class__

 

__del__ 析构方法

此方法一般无需定义,因为python是门高级语言,使用时无需关心内存的分配和释放,此工作交由python解释器执行,所以析构函数的调用是由解释器在进行垃圾回收时自动触发执行的,文件执行完毕之后触发该函数执行。

 1 class Foo:
 2     def __init__(self,name):
 3         self.name=name
 4     def __del__(self):
 5         print('我执行啦')
 6 
 7 f1=Foo('alex')
 8 
 9 # del f1    #删除实例会触发__del__
10 del f1.name #删除实例的属性不会触发__del__
11 print('--------------------->')
12 
13 #程序运行完毕会自动回收内存,触发__del__

输出

--------------------->
我执行啦

 

__call__

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

 

__next__和__iter__实现迭代器协议

 

 1 class Foo:
 2     def __init__(self,n):
 3         self.n=n
 4     def __iter__(self):
 5         return self
 6 
 7     def __next__(self):
 8         if self.n == 13:
 9             raise StopIteration('终止了')
10         self.n+=1
11         return self.n
12 
13 f1=Foo(10)
14 
15 for i in f1:  # obj=iter(f1)------------>f1.__iter__()
16      print(i)  #obj.__next__()

输出

11
12
13

 

  迭代器协议实现斐波那契数列

 

 1 class Fib:
 2     def __init__(self):
 3         self._a=1
 4         self._b=1
 5 
 6     def __iter__(self):
 7         return self
 8     def __next__(self):
 9         if self._a > 100:
10             raise StopIteration('终止了')
11         self._a,self._b=self._b,self._a + self._b
12         return self._a
13 
14 f1=Fib()
15 print(next(f1))
16 print(next(f1))
17 print(next(f1))
18 print(next(f1))
19 print(next(f1))
20 print('==================================')
21 for i in f1:
22     print(i)

输出

1
2
3
5
8
==================================
13
21
34
55
89
144

 

描述符理论

(开发大型框架时用到)

本质是一个新式类,至少实现了__get__()/__set__()/__delete__()中的一个,这也被成为描述符协议。

  __get__():调用一个属性时触发

  __set__():为一个属性赋值时触发

  __delete__():采用del删除属性时触发

描述符有什么用?描述符的作用是用来代理另外一个类的属性的

描述符分为两种:

  数据描述符:至少实现了__get__()和__set__()

  非数据描述符:没实现__set__()

注意事项:

  1.描述符本身应该定义成新式类,被代理的类也应该是新式类;

  2.必须把描述符定义成类属性,而不能定义到构造函数中;

  3.要严格遵循该优先级,从高到低:

    类属性---数据描述符---实例属性---非数据描述符---找不到的属性触发__getattr__()

 

例:

 1 class Foo:
 2     def __get__(self, instance, owner):
 3         print('===>get方法')
 4     def __set__(self, instance, value):
 5         print('===>set方法',instance,value)
 6         instance.__dict__['x']=value #对b1.__dict__进行修改
 7     def __delete__(self, instance):
 8         print('===>delete方法')
 9 
10 class Bar:
11     x=Foo() #描述符定义位置 在何地?   x用描述符来描述
12     def __init__(self,n):
13         self.x=n #b1.x=10 触发Foo的set方法
14 #触发在何时?
15 b1=Bar(10)  #在执行赋值操作
16 print(b1.__dict__)
17 b1.x=1  #在执行赋值操作
18 print(b1.__dict__)
19 
20 b1.y=2  #没有触发set,因为变量y并没用描述符描述
21 print(b1.__dict__)

输出

===>set方法 <__main__.Bar object at 0x000001CDBB0197B8> 10
{'x': 10}
===>set方法 <__main__.Bar object at 0x000001CDBB0197B8> 1
{'x': 1}
{'x': 1, 'y': 2}

 

优先级的体现

 1 class Foo:
 2     def __get__(self, instance, owner):
 3         print('===>get方法')
 4     def __set__(self, instance, value):
 5         print('===>set方法',instance,value)
 6         instance.__dict__['x']=value #b1.__dict__
 7     def __delete__(self, instance):
 8         print('===>delete方法')
 9 
10 class Bar:
11     x=Foo()
12 Bar.x=1    #覆盖类属性,改变了Bar的__dict__
13 print(Bar.__dict__)
14 print(Bar.x)

输出

{'__module__': '__main__', 'x': 1, '__dict__': <attribute '__dict__' of 'Bar' objects>, '__weakref__': <attribute '__weakref__' of 'Bar' objects>, '__doc__': None}
1

 

反序列化的时候要保证类还在内存中。

 

扫码关注我们
微信号:SRE实战
拒绝背锅 运筹帷幄