Python Python 高级特性-函数和装饰器

flystar · 2019年06月18日 · 最后由 flystar 回复于 2019年06月19日 · 2267 次阅读

函数是一等对象

编程语言中的函数就是对一段代码逻辑的封装,它是面向过程编程的基本单元。Python 是面向对象的语言,但是也对函数式编程提供了部分支持,并且,函数是 Python 里面的一等对象,即:函数在运行时被创建;能作为变量赋值;能作为参数传递;能作为结果返回。
基于函数是一等对象,如果一个函数接受另外的函数作为参数,或者把另外的函数作为结果返回,那么该函数便是高阶函数。在函数式编程范式中,最为人熟知便是mapfilterreduce,不过在 Python 中,它们都有更好的替代方案,即列表推导式和生成器表达式,使用后者,代码逻辑更加清晰,性能更好。
Python 内置库里也有 operator 和 functools 这样的函数式包,operator 主要为多个算术运算符提供了对应的函数,functools 提供了一系列高阶函数,如 reduce、partial 等。partial 用于生产偏函数,偏函数是指基于一个函数创建一个新的可调用对象,把原函数的某些参数固定,像 flask 的 request 等对象就是用 partial 生成的。

函数的创建

1.def关键字
2.匿名函数lambda
3.动态创建,即使用字符串形式的函数表达式,通过编译等步骤最终生成函数对象,适合写框架等场景

def gen_function(function_express):
    module_code = compile(function_express, '', 'exec')
    function_code = [c for c in module_code.co_consts if isinstance(c, types.CodeType)][0]
    return types.FunctionType(function_code, builtins.__dict__)

4.还有一种广义上的可调用对象,只需要实现__call__特殊方法,任何 Python 对象都可以表现得像函数

函数参数

我非常喜欢的 Python 特性之一是它极为灵活的参数处理机制,Python 里面共有位置参数、默认参数、可变参数、关键字参数、命名关键字参数,使用者可以灵活组合,而且可以配合拆包使用。
1.位置参数,def test(a),a 就是位置参数
2.默认参数,def test(a=1),a 就是默认参数
3.可变参数,def test(*a),此时传入的参数个位是可变的,并且会在函数内部组装成一个元祖,配合元祖拆包的话又可以很方便的还原成单个参数
4.关键字参数,def test(**a),和可变参数不同的是可以传入带参数名的参数,并且会组装成一个 dict
5.命名关键字参数,def test(a, *, b),此时,b 作为命名关键字参数,调用 test 函数的时候,只接受参数名为 b 的关键字参数,也就是把关键字参数参数名定死了
其实对于任何函数,都可以根据func(*args, **kw)的形式去调用,简洁优雅

函数内省

众所周知,Python 里面一切皆对象,函数也不例外,它是function对象的实例。
函数对象有很多属性,可以使用dir函数探知,其中很多都是 Python 对象共有的,但函数对象肯定会有自己的专业属性,下面这个表格简单记录了一下。
| 名称 | 类型 | 说明 |
|:-:|:-:|:-:|
aannotations|dict| 参数和返回值的注解
call|method-wrapper| 实现可调用对象协议,即 () 运算符
closure|tuple| 函数闭包,即自由变量的绑定
code|code| 编译成字节码的函数元数据和函数定义体
defaults|tuple| 形式参数的默认值
get|method-wrapper| 实现只读描述符协议
globals|dict| 函数所在模块中的全局变量
kwdefaults|dict| 仅限关键字形式参数的默认值
name|str| 函数名称
qulname|str| 函数的限定名称
要说明一点,虽然对象信息很全,但是里面信息组织的方式并不是便利的,比如函数对象的defaults属性保存着位置参数和关键字参数的默认值,然而,参数名称却在code属性中。这里我们可以借助inspect模块。
Python3 提供了一种新的句法,用于为函数的参数和返回值附加元数据,信息便保存在__annotations__属性里,例如def test(a:str,b:'int>0'=4) -> str:。注解只是让代码逻辑更清晰,元数据可以提供给 IDE、框架等工具去使用,但是对解释器没有任何意义。

闭包

闭包是指延伸了自己作用域的函数,如果一个函数可以访问定义体之外定义的非全局变量,那么它就是闭包。
Python 的变量作用域遵循 LEGB 原则。L 指local,局部作用域;E 指enclosing,嵌套作用域;G 指glocal,全局作用域;B 指bulitin,内置作用域。有如下一个函数体:

def test():
    l = 0

    def inner(a):
        l += 1
        return a * l

    return inner

此时,l叫做自由变量,它没有在inner的作用域内,而inner访问了l,所以inner就是一个闭包,那么 Python 中是怎么实现这样的机制的呢?
函数对象有一个__code__属性,__code__.co_freevars就保存着自由变量的名称,它是一个元祖;还有一个__closure__属性,里面保存着若干cell对象,它也是一个元祖,这两个元祖中的元素一一对应,类似于键值对,而cell对象的cell_contents属性便保存着自由变量的值。这样在调用inner的时候就能使用这些自由变量了。
但前面的test定义其实是有问题的,问题在哪儿呢?其实在函数体内,一旦给变量赋值,那么解释器便认为该变量是局部变量innerl+=1等于l=l+1,而且l是不可变类型,未赋值先引用,所以会报错UnboundLocalError
Python3 引入了nonlocal来解决这个问题,它的作用是把变量标记为自由变量,如果自由变量更新新值,闭包中的绑定也会随之更新。那么 Python2 要怎么解决呢?把l变成 dict、list 等可变对象就可以了。

装饰器及实现

装饰器就是一种特殊的闭包,他只接受函数作为参数,严格来说,装饰器只是一种语法糖,它把被装饰的函数替换成其他函数,简洁地扩展函数功能。以下两种写法是等价的。

@decorate
def target(): 
    pass

def target():
    pass
target = decorate(target)

还有,遇到嵌套的装饰器不要慌,只要遵循着由下往上看,把下当成一个整体,下是上的参数,装饰器的结构便能理清楚了。例如如下的结构,就等价于target=decorator1(decorator2(a)(decorator3(target)))

@decorator1
@decorator2(a)
@decorator3
def target():
    pass

装饰器是在导入时运行的,被装饰的函数在被调用时才运行,这点要尤为注意,否则在使用装饰器时会出现难以察觉的 bug。
装饰器的实现需要注意的是,被装饰的函数其实是装饰器返回的一个闭包,被装饰的函数对象原先的信息都没了,为了后续的调试等,一定要使用functools.wraps来加一个装饰,装饰装装饰。

  • 不带参数的装饰器 def decorator(func): @functools.wraps(func) def wrapper(*args, **kw): print('我被装饰了,好开心') return func(*args, **kw) return wrapper
  • 带参数的装饰器 def decorator(parameter): def inner(func): @functools.wraps(func) def wrapper(*args, **kw): print('我被装饰了,好开心') return func(*args, **kw) return wrapper return inner
  • 用可调用对象的思路去实现装饰器效果会更好,并且可以优雅兼容有参无参的情况

    class Decorator(object):
    
    def __init__(self, *args, **kwargs):
        self.func = None
        # 如果装饰器类初始化参数只有1个函数对象,那么就认为该装饰器自身是无参的
        # 否则,装饰器类自身有参数,那么会先自身初始化
        if len(args) == 1 and isinstance(args[0], types.FunctionType):
            self.func = args[0]
    
        # 各种初始化,省略
    
    def __call__(self, *args, **kwargs):
        if self.func:
            return self.func(*args, **kwargs)
        # 如果self.func没有初始化,那么到这一步时,装饰过程才会启动
        self.func = args[0]
    
        def wrapper(*args, **kwargs):
            return self.func(*args, **kwargs)
        return wrapper
    
  • 类装饰器

    def class_decorator(cls):
    print('我被装饰了,好开心')
    return cls
    
  • 类方法装饰器,Python 内置的像@property@classmethod类似,背后是描述符协议,留待之后再说

    def method_decorator(func):
    @functools.wraps(func)
    def wrapper(self, *args, **kw):
        print('我被装饰了,好开心')
        return func(self, *args, **kw)
    return wrapper
    
共收到 2 条回复 时间 点赞

👍
嵌套装饰器在使用的时候调用顺序很容易混乱,很少会使用到

Karaser 回复

嵌套装饰器在普通使用下是用的不多,做开发时还是很便利的

需要 登录 后方可回复, 如果你还没有账号请点击这里 注册