python 高阶函数

高阶函数定义

函数可以作为普通变量、参数、返回值等等
数学概念 y = g( f( x ) )
在数学和计算机科学中，高阶函数应当是最少满足下面一个条件的函数
- 接受一个或多个函数作为参数
- 输出一个函数

自定义sort函数

def sort(iterable, reverse=False, key=lambda x,y: x<y):
        ret = []
        for x in iterable:
                for i,y in enumerate(ret):
                        flag =  key(x,y) if not reverse else not key(x,y)
                        if flag:
                                ret.insert(i,x)
                                break
                else:
                        ret.append(x)
        return ret
print(sort([4,7,2,9,1,6]))

内建函数-高阶函数

filter(function, iterable)
- 过滤可迭代对象的元素，返回一个迭代器
- function 一个具有一个参数的函数，返回bool
- 例如：过滤出数列中被3整除的数字
  - list( filter( lambda x: x%3==0, [1,9,45,36,-3,86,47,96] ) )
map(function,
- 对多个可迭代对象的元素按照指定的函数进行映射，返回一个迭代器
  - list( map( lambda x: 2*x+1, range(5) ) )
  - dict( map( lambda x: (x%5,x), range(500) ) )
  - list( map( lambda x,y: x+y, [1,2,3,4,5], [2,3,4,5,6] ) )

柯里化Currying

柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。
- z = f(x, y) 转换成 z = f(x)(y)

# 将加法函数柯里化
def add(x,y):
    return x + y

# 转换如下
def add(x):
    def _add(y):
        return x + y
    return _add
add(5)(6)

函数注解 Function Annotaions

对函数的参数、返回值进行类型注解
只对函数参数做一个辅助的说明，并不对函数的参数进行类型检查
函数注解的信息，保存在annotaions 属性中
python3.6 引入 i:int = 3

    add.__annotations__
    {'x': <class 'int'>, 'y': <class 'str'>, 'return': <class 'str'>}

函数参数的检查，一定是在函数外
函数应该作为参数，传入到检查函数中
检查函数拿到函数传入的实际参数，与形参声明对比
annotaions 属性是一个字典，其中包括返回值类型的声明，假设要做位置参数的判断，无法和字典中的声明对比。使用inspect模块

inspet模块 -> 提供获取对象信息的函数，可以检查函数和类、类型检查
inspect(callable) 获取签名（函数签名包含了一个函数的信息，包含函数名、它的参数类型、它所在的类和名称空间及其他信息）

    import inspect
    
    def add(x:int, y:int, *args, **kwargs) -> int:
            return x + y
    
    sig = inspect.signature(add)
    
    print(sig, type(sig)) 
    >>> 函数签名 (x:int, y:int, *args, **kwargs) -> int <class 'inspect.Signature'>
    
    print('params:',sig.parameters) 
    >>> params: OrderedDict([('x', <Parameter "x:int">), ('y', <Parameter "y:int">), ('args', <Parameter "*args">), ('kwargs', <Parameter "**kwargs">)])
    
    print('return:',sig.return_annotation ) 
    >>> return: <class 'int'>
    
    print(sig.parameters['x'],type(sig.parameters['x']))  
    >>> x:int <class 'inspect.Parameter'>
    
    print(sig.parameters['y'].annotation)  
    >>> <class 'int'>
    
    print(sig.parameters['args'],type(sig.parameters['args']))  
    >>> *args <class 'inspect.Parameter'> 
    
    print(sig.parameters['args'].annotation) 
    >>> <class 'inspect._empty'>
    
    print(add.__annotations__)  
    >>> {'x': <class 'int'>, 'y': <class 'int'>, 'return': <class 'str'>}
    
    print(sig.parameters['kwargs'])  
    >>> **kwargs
    
    print(sig.parameters['kwargs'].annotation)  
    >>> <class 'inspect._empty'>

inspect.isfunction(add) # 是否是函数
inspect.ismethod(add) # 是否是类的方法
inspect.isgenerator(add) # 是否是生成器对象
inspect.isgeneratorfunction(add) # 是否是生成器函数
inspect.isclass(add) # 是否是类
inspect.ismodule(add) # 是否是模块
inspect.isbuiltin(add) # 是否是内建对象

Parameter 对象
- 保存在元组中，是只读的
- name，参数的名字
- annotation ，参数的注解，可能没有定义
- default，参数的缺省值，可能没有定义
- empty，特殊的类，用来标记default属性或者注释annotation属性的空值
- kind，实参如何绑定到形参，就是形参的类型
  - POSITIONAL_ONLY ，值必须是位置参数提供 (Python中没有)
  - POSITIONAL_OR_KEYWORD ，值可以作为关键字或者位置参数提供
  - VAR_POSITIONAL ，可变参数，对应*args
  - KEYWORD_ONLY ，kwword_only 参数，对应*或者args之后的出现的非可变参数关键字参数
  - VAR_KEYWORD ，可变关键字参数，对应**kwargs

    ### 检查用户输入是否符合参数注解的要求
    from functools import wraps
    import inspect
    
    def check(fn):
        @wraps(fn)
        def wrapper(*args,**kwargs):
            sig = inspect.signature(fn)
            params = sig.parameters # 有序字典
            # print(params)
            values = list(params.values())
            # flag = True
            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)
                    # flag = False
                    # break
            # if not flag:
            #   raise TypeError('都是你的错')
            for k,v in kwargs.items():
                if params[k].annotation is not inspect._empty and isinstance(v,params[k].annotation):
                    print(k,v,'!==',params[k].annotation)
            return fn(*args,**kwargs)
        return wrapper
    
    @check
    def add(x:int,y:int=6)->int:
        return x + y
    
    add(20,30)