首先搞明白clssmethod原理，直接修改类的dict
框架如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class Class_Method:
def __init__(self,fn):
self.fn = fn
def __get__(self, instance, owner):
print(self,instance,owner)
return self.fn
class A:
@Class_Method
def bar(cls):
print(cls.__name__)
f = A.bar
print(f)
f() |
发现报错：
|
1
2
3
4
5
6
|
Traceback (most recent call last):<__main__.Class_Method object at 0x0000000000DE8390> None <class '__main__.A'>
File "E:/python_project/learing/20171106/class_test.py", line 32, in <module>
<function A.bar at 0x00000000010F0488>
f()
TypeError: bar() missing 1 required positional argument: 'cls'
|
get可以获取到，return的是bar函数
考虑A在哪里可以获取到，回到get方法中，获取owner属性，直接return owner
也就是说直接返回A
|
1
2
3
|
def __get__(self, instance, owner):
print(self,instance,owner)
return self.fn(owner)
|
测试：
f()
|
1
2
3
4
|
Traceback (most recent call last): File "E:/python_project/learing/20171106/class_test.py", line 33, in <module>
f()
TypeError: 'NoneType' object is not callable
|
是一个函数调用，但是没有return任何东西
1.首先return self.fn(owner) 直接指向A类，A类可以获取
2.但是函数返回值是None，因为是def bar中没有return其他，默认是None
解决：
固定返回参数
partial
return self.fn 和 class也就是A 返回为一个新的函数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
class Class_Method:
def __init__(self,fn):
print('init,self.fn : ', fn)
self.fn = fn
def __get__(self, instance,cls):
print(self,instance,cls)
# return self.fn(owner)
return partial(self.fn,cls)
class A:
@Class_Method
def bar(cls):
print('bar:',cls.__name__)
f = A.bar
print(f)
f() |
返回如下：
|
1
2
3
4
|
init,self.fn : <function A.bar at 0x00000000010C1488>
<__main__.Class_Method object at 0x00000000008592E8> None <class '__main__.A'>
functools.partial(<function A.bar at 0x00000000010C1488>, <class '__main__.A'>)
bar: A |
因为返回的必须是函数，所以最好使用partial 返回一个新函数
再进行调用，发现模拟使用方法是差不多的，但是模仿终归模仿
对实例的数据进行校验
涉及：inspect 参数检查
使用描述器进行参数检查
当实例化的时候必须传递参数进去，必须实例化
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class Typed:
def __init__(self):
pass
def __get__(self, instance, owner):
print('get :',self, instance, owner )
def __set__(self, instance, value):
print('set : ',self, instance, value)
class Person:
name = Typed()
age = Typed()
def __init__(self,name:str,age:int):
self.name = name
self.age = age
|
调用返回如下：
|
1
2
|
set : <__main__.Typed object at 0x0000000000DD8470> <__main__.Person object at 0x0000000000DB6470> tom
set : <__main__.Typed object at 0x0000000000DB6400> <__main__.Person object at 0x0000000000DB6470> 1
|
返回了两个实例的value
判断类型：
首先需要声明并传递一个类型，
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class Typed:
def __init__(self,type):
self.type = type
def __get__(self, instance, owner):
print('get :',self, instance, owner )
def __set__(self, instance, value):
print('set : ',self, instance, value)
class Person:
name = Typed(str)
age = Typed(int)
def __init__(self,name:str,age:int):
self.name = name
self.age = age
p = Person('tom',1)
|
获取了value，接下来自己的类型也明确了，首先传递进来是被set拦截，那么需要在set中做判断
因为设置值的时候才触发set
改进：
通过inspect 进行参数检查
inspect.signature(Person) 检查参数
|
1
2
|
print(inspect.signature(Person))
(name:str, age:int)
|
返回的是初始化方法，参数注解
通过parameters 返回的是一个
|
1
2
|
print(inspect.signature(Person).parameters)
OrderedDict([('name', <Parameter "name:str">), ('age', <Parameter "age:int">)])
|
返回的是一个有序字典
使用annotation将其转为class类型
|
1
2
3
|
params = inspect.signature(Person).parameters
for name,param in params.items():
print(name,param.annotation)
|
返回如下：
|
1
2
|
name <class 'str'>
age <class 'int'>
|
通过类装饰器判断数据类型
新建一个类，做为装饰器判断
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class TypeAssert:
def __init__(self,cls):
self.cls = cls
def __call__(self,name,age):
params = inspect.signature(self.cls).parameters
for name,param in params.items():
print(name,param.annotation)
class Person:
name = Typed(str)
age = Typed(int)
def __init__(self,name:str,age:int):
self.name = name
self.age = age
|
将这两句话去掉，不在类中调用Typed的类，将其在TypeAssert中进行调用并判断
通过setattr 创建类的属性，直接写入到字典
name，age
|
1
2
3
4
5
6
7
8
9
|
class TypeAssert:
def __init__(self,cls):
self.cls = cls
def __call__(self,name,age):
params = inspect.signature(self.cls).parameters
for name,param in params.items():
print(name,param.annotation)
if param.annotation != param.empty: #判断值是否有注解，将不等于空则加入类属性
setattr(self.cls,name,Typed(param.annotation))
|
这样再添加属性则被__set__拦截并修改
完整如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
class Typed:
def __init__(self,type):
self.type = type
def __get__(self, instance, owner):
print('get :',self, instance, owner )
def __set__(self, instance, value):
print('set : ',self, instance, value)
if not isinstance(value,self.type):
raise ValueError(value)
class TypeAssert:
def __init__(self,cls):
self.cls = cls
def __call__(self,name,age):
params = inspect.signature(self.cls).parameters
print(params)
for name,param in params.items():
print(name,param.annotation)
if param.annotation != param.empty:
setattr(self.cls,name,Typed(param.annotation))
@TypeAssertclass Person:
name = Typed(str)
age = Typed(int)
def __init__(self,name:str,age:int):
self.name = name
self.age = age
p = Person('tom',11)
print(Person.__dict__)
print(type(p))
|
本文转自zuzhou 51CTO博客，原文链接:http://blog.51cto.com/yijiu/1984201