PYTHON类型注解

函数定义的弊端

Python是动态语言，变量随时可以被赋值，且能赋值为不同的类型

Python不是静态编译型语言，变量类型是在运行器决定的

动态语言很灵活，但是这种特性也是弊端

def add(x, y):
return x + y
print(add(4, 5))
print(add(‘hello’, ‘world’))
#add(4, ‘hello’)

难发现：由于不做任何类型检查，直到运行期问题才显现出来，或者线上运行时才能暴露出问题

难使用：函数的使用者看到函数的时候，并不知道你的函数的设计，并不知道应该传入什么类型的数据

如何解决这种动态语言定义的弊端呢？ p

增加文档Documentation String p

这只是一个惯例，不是强制标准，不能要求程序员一定为函数提供说明文档 p 函数定义更新了，文档未必同步更新

def add(x, y):
”’
    :param x: int
    :param y: int
    :return: int
    ”’
    return x + y
print(help(add))

print(add(4,5))
print(add(‘mag’,’edu’))

函数注解 p Python 3.5引入

对函数的参数进行类型注解

对函数的返回值进行类型注解

只对函数参数做一个辅助的说明，并不对函数参数进行类型检查

提供给第三方工具，做代码分析，发现隐藏的bug

函数注解的信息，保存在__annotations__属性中

函数参数类型检查

思路

函数参数的检查，一定是在函数外

函数应该作为参数，传入到检查函数中

检查函数拿到函数传入的实际参数，与形参声明对比

__annotations__属性是一个字典，其中包括返回值类型的声明。假设要做位置参数的判断，无法和字典中的声明对应。使用inspect模块

inspet模块

提供获取对象信息的函数，可以检查函数和类、类型检查

Inspect模块

signature(callable)，获取签名（函数签名包含了一个函数的信息，包括函数名、它的参数类型、它所在的类和名称空间及其他信息）

import inspect
def add(x:int,y:int,*args,**kwargs)->int:
return x + y
sig = inspect.signature(add)
print(sig,type(sig)) #函数签名
print(‘params:’,sig.parameters)#有序字典
print(‘return : ‘,sig.return_annotation)
print(sig.parameters[‘x’],type(sig.parameters[‘y’]))
print(sig.parameters[‘x’].annotation)
print(sig.parameters[‘args’])
print(sig.parameters[‘args’].annotation)
print(sig.parameters[‘kwargs’])
print(sig.parameters[‘kwargs’].annotation)

inspect.isfunction(add)，是否是函数

inspect.ismethod(add))，是否是类的方法

inspect.isgenerator(add))，是否是生成器对象

inspect.isgeneratorfunction(add))，是否是生成器函数

inspect.isclass(add))，是否是类

inspect.ismodule(inspect))，是否是模块

inspect.isbuiltin(print))，是否是内建对象

还有很多is函数，需要的时候查阅inspect模块帮助

Parameter对象

保存在元组中，是只读的

name，参数的名字

annotation，参数的注解，可能没有定义

default，参数的缺省值，可能没有定义

empty，特殊的类，用来标记default属性或者注释annotation属性的空值

kind，实参如何绑定到形参，就是形参的类型

POSITIONAL_ONLY，值必须是位置参数提供

POSITIONAL_OR_KEYWORD，值可以作为关键字或者位置参数提供

VAR_POSITIONAL，可变位置参数，对应*args

KEYWORD_ONLY，keyword-only参数，对应*或者*args之后的出现的非可变关键字参数 VAR_KEYWORD，可变关键字参数，对应**kwargs

举例

import inspect
def add(x:int,y:int=7,*args,z,t=10,**kwargs)->int:
return x + y
sig = inspect.signature(add)
print(sig)
print(‘params:’,sig.parameters)
print(‘return:’,sig.return_annotation)
print(‘——————————————‘)
for i,item in enumerate(sig.parameters.items()):
name,param = item
print(i+1,name,param.annotation,param.kind,param.default)
print(param.default is param.empty,end=’\n\n’)

有函数如下

def add(x, y:int=7) -> int:

return x + y p

请检查用户输入是否符合参数注解的要求？

import inspect
def add(x, y:int=7) -> int:
return x + y
def check(fn):
def wrapper(*args, **kwargs):
sig = inspect.signature(fn)
params = sig.parameters
values = list(params.values())
for i,p in enumerate(args):
if isinstance(p, values[i].annotation): # 实参和形参声明一致
print(‘==’)
for k,v in kwargs.items():
if isinstance(v, params[k].annotation): # 实参和形参声明一致
print(‘===’)
return fn(*args, **kwargs)
return wrapper

import inspect
def check(fn):
def wrapper(*args, **kwargs):
sig = inspect.signature(fn)
params = sig.parameters
values = list(params.values())
for i,p in enumerate(args):
param = values[i]
if param.annotation is not param.empty and not isinstance(p, param.annotation):
print(p,’!==’,values[i].annotation)
for k,v in kwargs.items():
if params[k].annotation is not inspect._empty and not isinstance(v, params[k].annotation):
print(k,v,’!===’,params[k].annotation)
return fn(*args, **kwargs)
return wrapper
@check
def add(x, y:int=7) -> int:
return x + y

Functools模块

partial方法

偏函数，把函数部分的参数固定下来，相当于为部分的参数添加了一个固定的默认值，形成一个新的函数并返回 p

从partial生成的新函数，是对原函数的封装

import functools
def add(x,y) -> int:
return x + y
newadd = functools.partial(add,y=5)
print(newadd(7))
print(newadd(7,y=6))
print(newadd(y=8,x=9))

import inspect
print(inspect.signature(newadd))

举例

import functools
def add(x,y,*args)-> int:
print(args)
return x+y
newadd = functools.partial(add,1,2,3,4)
print(newadd(7))
print(newadd(7,10))
#print(newadd(9,10,y=20,x=26))
print(newadd())

import inspect
print(inspect.signature(newadd))

import functools
def partial(func, *args, **keywords):
def newfunc(*fargs, **fkeywords): # 包装函数
newkeywords = keywords.copy()
newkeywords.update(fkeywords)
return func(*(args + fargs), **newkeywords)
newfunc.func = func # 保留原函数
newfunc.args = args # 保留原函数的位置参数
newfunc.keywords = keywords # 保留原函数的关键字参数参数
return newfunc
def add(x,y):
return x+y
foo = partial(add,4)
foo(5)

@functools.lru_cache(maxsize=128, typed=False) p

Least-recently-used装饰器。lru，最近最少使用。cache缓存 p

如果maxsize设置为None，则禁用LRU功能，并且缓存可以无限制增长。当maxsize是二的幂时，LRU功能执行得最好 p

如果typed设置为True，则不同类型的函数参数将单独缓存。例如，f(3)和f(3.0)将被视为具有不同结果的不同调用

import functools
import time
@functools.lru_cache()
def add(x,y,z=3):
time.sleep(z)
return x + y
print(add(4,5))
print(add(4.0,5))
print(add(4, 6))
print(add(4, 6, 3))
print(add(6, 4))
print(add(4, y=6))
print(add(x=4, y=6))
ptint(add(y=6, x=4))

举例：打印斐波那契数列

import functools
@functools.lru_cache()
def add(n):
if n <3:
return 1
return add(n-1)+add(n-2)
print(add(35))

lru_cache装饰器应用

使用前提

同样的函数参数一定得到同样的结果

函数执行时间很长，且要多次执行

本质是函数调用的参数=>返回值

缺点

不支持缓存过期，key无法过期、失效 p

不支持清除操作

不支持分布式，是一个单机的缓存

适用场景，单机上需要空间换时间的地方，可以用缓存来将计算变成快速的查询