python描述器

python学习笔记之描述器

描述器

一个类实现了__get____set____delete__三个方法,这个类就叫描述器

直接来看一个描述器的实现,如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Number:
def __init__(self,name):
self.name = name

def __get__(self,instance,cls):
print('call __get__')
return instance.__dict__[self.name]

def __set__(self,instance,value):
print('call __set__')
if isinstance(value,(int,float)):
instance.__dict__[self.name] = value
else:
raise TypeError('execepted int or float')

def __delete__(self,instance):
del instance.__dict__[self.name]
1
2
3
4
5
6
7
class Point:
x = Number('x')
y = Number('y')

def __init__(self,x,y):
self.x = x
self.y = y

这样就定义了一个描述器Number类,这个类的作用是描述实例化Point类时xy变量的类型必须为整型或浮点型,如果不满足这两种类型中的一个,那抛出TypeError的异常。为了验证代码的调用关系,有意在Number类中加了一些print语句,在实例代码中应该把这语句去除。现在来实际实例化Point类试试:

1
p1 = Point(2,8)
call __set__
call __set__

当执行p1 = Point(2,8)时发生了什么呢?

1.当python解释器解析到

1
2
3
4
5
6
7
class Point:
x = Number('x')
y = Number('y')

def __init__(self,x,y):
self.x = x
self.y = y

代码块时,解释器会创建一个Point类对象,此对象中有x类变量,且此变量指向Number类的一个实例,有y类变量,且此变量指向Number类的另一个实例;解释器还会创建一个__init__函数,此函数接收两个参数。

2.当解释器执行到p1 = Point(2,8)时,Point类中的__init__构建函数被执行,执行以下两代码

1
2
self.x = x
self.y = y

解释器先执行self.x = x代码,这里的self.x是一个变量对象,等号后边的x是指向类变量x = Number('x')中的Number类实例,这时解释器会执行Number类中的__set__函数,把p1实例传递给instance这个形参,把2传递给value这个形参,执行此函数体的代码

1
2
3
4
5
6
def __set__(self,instance,value):
print('call __set__')
if isinstance(value,(int,float)):
instance.__dict__[self.name] = value
else:
raise TypeError('execepted int or float')

首先打印出call __set__,再执行if语句,为True时把p1实例中__dict__这个特殊方法中key为x的值指向2;如果if语句的判断结果为False,那抛出异常。

接着解释器往下执行代码,开始执行构建函数中的self.y = y语句,这个过程与执行self.x = x语句一样。这样就完成了p1 = Point(2,8)这个语句的执行,其实质就是会去执行Number类的__set__函数

1
p1.x
call __get__





2

当执行上边的p1.x时发生了什么?

执行p1.x是去调用Point类的实例变量x,从上边的分析可知,这个实例变量是指向Number('x')这个实例,这时解释器会执行Number类的__get__方法,会把p1这个实例名作为变量传递给instance这个形参,把p1的类名作为变量传递给cls,代码如下:

1
2
3
def __get__(self,instance,cls):
print('call __get__')
return instance.__dict__[self.name]

先打印出call __get__,然后取出p1实例中__dict__中key为x的值返回,这样就得到执行p1 = Point(2,8)语句时2这个数字。

总结起来,访问一个使用了描述器的类的实例属性时,其实质是访问了描述器的__get__函数

其实访问p1.x和访问Point.x.__get__(p1,Point)的过程是一样的。

1
p1.x = 10
call __set__

当执行上边的p1.x = 10语句时发生了什么呢?

执行p1.x = 10是想把Point类的p1实例的实例变量指向一个数字10,实例变量x是指向Number('x')这个实例,其实质是去调用Number类的__set__方法,上边已对调用__set__函数进行了详细了分析,不再赘述。

其实执行p1.x = 10和执行Point.x.__set__(p1.10)的过程是一样的

1
p1.x
call __get__





10

再来给x一个不是intfloat型的字符,如下:

1
p1.x = 'zhaochj'
call __set__



---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-8-47a1681546d4> in <module>()
----> 1 p1.x = 'zhaochj'


<ipython-input-2-087bfda6d4c9> in __set__(self, instance, value)
     12             instance.__dict__[self.name] = value
     13         else:
---> 14             raise TypeError('execepted int or float')
     15 
     16     def __delete__(self,instance):


TypeError: execepted int or float

在类型检查时没有通过,所以抛出我们自定义的异常信息。

Point类中,按理说类变量x是可以像Point.x来访问的,但执行时,如下:

1
Point.x
call __get__



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-9-7a7eae6dfbec> in <module>()
----> 1 Point.x


<ipython-input-2-087bfda6d4c9> in __get__(self, instance, cls)
      5     def __get__(self,instance,cls):
      6         print('call __get__')
----> 7         return instance.__dict__[self.name]
      8 
      9     def __set__(self,instance,value):


AttributeError: 'NoneType' object has no attribute '__dict__'

这是因为在调用__get__方法时instance参数接收到了一个None对象,这是因为类Point并没有被实例化,所以return时会报错。可以对__get__函数做如下修正,如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class NumberFix:
def __init__(self,name):
self.name = name

def __get__(self,instance,cls):
print('call __get__')
if instance is not None:
return instance.__dict__[self.name]
return self

def __set__(self,instance,value):
print('call __set__')
if isinstance(value,(int,float)):
instance.__dict__[self.name] = value
else:
raise TypeError('execepted int or float')

def __delete__(self,instance):
del instance.__dict__[self.name]
1
2
3
4
5
6
7
class Point2:
x = NumberFix('x')
y = NumberFix('y')

def __init__(self,x,y):
self.x = x
self.y = y
1
Point2.x
call __get__





<__main__.NumberFix at 0x7f8030321550>
1
p2 = Point2(4,7)
call __set__
call __set__
1
Point2.x
call __get__





<__main__.NumberFix at 0x7f8030321550>
1
p2.x
call __get__





4
1
p2.x = 30
call __set__
1
p2.x
call __get__





30

这样,NumberFix算是一个完整的描述器。

这样,NumberFix这个描述器就完成了对实例化类Point2时传入参数类型的限制,允许的类型在描述器NumberFix__set__函数中进行设置。

上边的例子中都是对各个参数进行同一类型的检查,如果我们要对每个参数都做不同的类型检查呢?比如要求x参数为int型,y参数为str型。对上边的描述器做如下改进:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class TypeCheck:
def __init__(self,name,expected_type):
self.name = name
self.expected_type = expected_type

def __get__(self,instance,cls):
if instance is not None:
return instance.__dict__[self.name]
return self

def __set__(self,instance,value):
if not isinstance(value,self.expected_type):
raise TypeError('expected type {0}'.format(self.expected_type))
instance.__dict__[self.name] = value

def __delete__(self,instance):
del instance.__dict__[self.name]
1
2
3
4
5
6
7
class Point3:
x = TypeCheck('x',(int,))
y = TypeCheck('y',(str,))

def __init__(self,x,y):
self.x = x
self.y = y
1
p3 = Point3(10,'zhaochj')
1
p3.x
10
1
p3.y
'zhaochj'
1
p3.x = 40
1
p3.x
40
1
p4 = Point3(10,30)
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-67-7765c7ef841b> in <module>()
----> 1 p4 = Point3(10,30)


<ipython-input-58-20cc1f0ef40f> in __init__(self, x, y)
      5     def __init__(self,x,y):
      6         self.x = x
----> 7         self.y = y


<ipython-input-51-d7bab526d123> in __set__(self, instance, value)
     11     def __set__(self,instance,value):
     12         if not isinstance(value,self.expected_type):
---> 13             raise TypeError('expected type {0}'.format(self.expected_type))
     14         instance.__dict__[self.name] = value
     15 


TypeError: expected type (<class 'str'>,)

这样就可以实现对不同的变量限制不同的类型,当对xy的类型有变更时只需要修改Point3类即可。

其实还可以使用装饰器来达到同样的效果,这是一个装饰类TypeCheck的装饰器,代码实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from functools import wraps

def typeinsert(**kwargs):
def inner(cls):
@wraps(cls)
def wrap(**kwargs):
for k,v in kwargs.items():
setattr(cls,k,TypeCheck(k,v))
return cls
return wrap
return inner


@typeinsert(x=int,y=float,z=str,m=str)
class Spam:
def __init__(self,x,y,z,m):
self.x = x
self.y = y
self.z = z
self.m = m
1
s = Spam(x='dfd',y=10,z=10,m=45)
1

好像没有达到预想的效果,没有想明白,相关视频在“09-面向对象-8”

1

文章目录
  1. 1. 描述器
|