python描述器descriptor_python描述器

python学习笔记之描述器

描述器

一个类实现了__get__、__set__、__delete__三个方法，这个类就叫描述器

直接来看一个描述器的实现，如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17class 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

7class Point:

x = Number('x')

y = Number('y')

def __init__(self,x,y):

self.x = x

self.y = y

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

1p1 = Point(2,8)

call __set__

call __set__

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

1.当python解释器解析到

1

2

3

4

5

6

7class 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

2self.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

6def __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__函数

1p1.x

call __get__

2

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

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

1

2

3def __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)的过程是一样的。

1p1.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)的过程是一样的

1p1.x

call __get__

10

再来给x一个不是int或float型的字符，如下：

1p1.x = 'zhaochj'

call __set__

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

TypeError Traceback (most recent call last)

in ()

----> 1 p1.x = 'zhaochj'

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来访问的，但执行时，如下：

1Point.x

call __get__

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

AttributeError Traceback (most recent call last)

in ()

----> 1 Point.x

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

19class 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

7class Point2:

x = NumberFix('x')

y = NumberFix('y')

def __init__(self,x,y):

self.x = x

self.y = y

1Point2.x

call __get__

1p2 = Point2(4,7)

call __set__

call __set__

1Point2.x

call __get__

1p2.x

call __get__

4

1p2.x = 30

call __set__

1p2.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

17class 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

7class Point3:

x = TypeCheck('x',(int,))

y = TypeCheck('y',(str,))

def __init__(self,x,y):

self.x = x

self.y = y

1p3 = Point3(10,'zhaochj')

1p3.x

10

1p3.y

'zhaochj'

1p3.x = 40

1p3.x

40

1p4 = Point3(10,30)

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

TypeError Traceback (most recent call last)

in ()

----> 1 p4 = Point3(10,30)

in __init__(self, x, y)

5 def __init__(self,x,y):

6 self.x = x

----> 7 self.y = y

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 (,)

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

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20from 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

1s = Spam(x='dfd',y=10,z=10,m=45)

1

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

1