0%

python教程（三）·函数进阶（下）

发表于 分类于
本文字数： 4.3k 阅读时长 ≈ 4 分钟

下半部分果然很快到来，这次介绍函数的更高级用法，装饰器！

函数嵌套

先来说说函数嵌套，python中的函数是可以嵌套的，也就是说可以将一个函数放在另一个函数里面，比如：

1
2
3
4
5
6
7
8
9
10
11
12
>>> def outer(name):
...     def inner():
...             print(name)
...     return inner
... 
>>> func1 = outer('feather')
>>> func2 = outer('Lee')
>>> func1()
feather
>>> func2()
Lee
>>>

你没看错，我们在函数里面定义了另一个函数，并把这个函数返回了？

返回出来的函数是带着它的所在的作用域的，这就是为什么返回出来的函数仍能访问外层函数的变量name，而且可以看到func1()和func2()结果不一样，这表明每次调用外层函数都会重新定义内层函数，事实也是如此。

装饰器

再来看看下面这个函数，<(￣︶￣)↗：

1
2
3
def func():
    for i in range(100000):
        pass  # pass的意思是什么都不做

这段函数只是空转100000次没什么意义，只是做个例子，假如我们想要运使用这个函数并输出运行了多长时间，我们可以这么做：

1
2
3
4
5
6
7
8
9
10
11
12
import time

def func():
    for i in range(100000):
        pass  # pass的意思是什么都不做

# 获取当前时间戳，时间戳就是当前到1970年所经过的秒数
start = time.time()  
func()
end = time.time()

print(end-start)

我们可以在函数前后分别获取时间，两个时间的差就是函数的运行时间，这很简单。可是，如果我们有很多个函数都需要统计时间怎么办？每个函数调用前都加上同样的代码吗？

当然不是，受函数嵌套的启发，我们可以像下面这样定义一个函数：

1
2
3
4
5
6
7
8
def count(func):
    def inner():
        start = time.time()
        result = func()
        end = time.time()
        print(end-start)
        return result
    return inner()

然后把要计算运行时间的函数作为参数传给count函数，就是把count函数当一个代理人，替我们调用函数。

但是这样的话，调用func函数不能写func()，要写count(func)，有点别扭，再改进下：

1
2
3
4
5
6
7
8
def count(func):
    def inner():
        start = time.time()
        result = func()
        end = time.time()
        print(end-start)
        return result
    return inner    # 返回这个内层函数，而不是调用

如果再执行了这样的代码：

1
func = count(func)

这个什么意思？

其实就是把func这个变量（函数也可理解成一种变量）重新绑定成count里面定义的inner()函数。这个时候我们再执行func()就可以达到效果了，完整代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import time

def func():
    for i in range(100000):
        pass  # pass的意思是什么都不做

def count(func):
    def inner():
        # 获取当前时间戳，时间戳就是当前到1970年所经过的秒数
        start = time.time()  
        result = func()
        end = time.time()
        print(end-start)
        return result
    return inner

func = count(func)
func()

装饰器的雏形出来了！装饰器就是像count这样的函数，用来给其它函数增加额外的功能，count函数在里面定义了一个inner函数用来包裹（装饰）被装饰的函数func。

不过这仅仅是雏形，并不是真正的装饰器，现在该让真正的装饰器登场了！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import time

def count(func):
    def inner():
        # 获取当前时间戳，时间戳就是当前到1970年所经过的秒数
        start = time.time()  
        result = func()
        end = time.time()
        print(end-start)
        return result
    return inner
    
@count
def func():
    for i in range(100000):
        pass  # pass的意思是什么都不做
        
func()

在函数func()的上面多了样东西：@count，这个东西就是装饰器，它的本质等同于func = count(func)。这样以后，每当我们需要为哪个函数的增加输出运行时间的功能，就在这个函数的定义前加上@count。

万能的*和**

如果func函数的参数数量不确定，我们可以使用参数收集和分配参数的技巧，代码如下：

1
2
3
4
5
6
7
8
9
def count(func):
    # “百搭”的参数定义
    def inner(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)  # 展开参数
        end = time.time()
        print(end-start)
        return result
    return inner

这样的count装饰器对于参数数量任意的函数都可以匹配了。

带参数的装饰器

装饰器也可以有参数！

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
import time

def count(switch):
    # switch为True则计时，否则关闭计时功能
    def wrapper(func):
        def inner(*args, **kwargs):
            if switch:
                start = time.time()  
                result = func()
                end = time.time()
                print(end-start)
                return result
            else:
                return func()
        return inner
    return wrapper

switch = bool(input('是否计时？(y/n)') == 'y')

@count(switch)
def func():
    for i in range(100000):
        pass  # pass的意思是什么都不做

func()

看完以后是不是有点晕？(＠_＠;)

我来说说这个运行的过程：首先，程序等待输入，假定输入y，这是switch变量赋值为True，然后遇到@count(switch)，这一行相当于调用了count函数，这个函数返回了一个装饰器，就是里面的wrapper，然后对func函数使用这个装饰器。

(°ー°〃)

嗯？我应该说清楚了吧。。。

对！还有一个问题 (°ー°〃)

函数签名

每个函数都有一个属性，叫做函数签名，就是函数的名字，比如print函数的函数签名可以这样获得：

1
2
3
>>> print.__name__
'print'
>>>

一个函数使用了装饰器，表面上还是使用这个函数的名字，实际上真的是这样吗？看下面代码：

1
2
3
4
5
6
7
8
9
10
11
12
>>> def outer(func):
...     def inner():
...             pass
...     return inner
... 
>>> @outer
... def func():
...     pass
... 
>>> func.__name__
'inner'
>>>

函数的签名已经改变了！

可是…

这个能有什么问题？

(￣︶￣)↗ 有些时候我们是需要使用这个函数签名的的，比如：根据输入的函数名字使用对应的函数（根据字符串获取函数的方法在后面的小实例有用到），有些模块也可能使用到了函数签名，如果不注意到这个细节，出错了也找不出什么问题来！

那么怎么解决？

解决这个问题的方法很简单，我们只需使用一个内置模块的装饰器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> import functools
>>> def outer(func):
...     @functools.wraps(func)
...     def inner():
...             pass
...     return inner
... 
>>> @outer
... def func():
...     pass
... 
>>> func.__name__
'func'
>>>

代码简洁明了，至于原理，我们奉行 “拿来主义”，只需要知道在用于包裹的函数上方加上@functools.wraps()即可，不必纠结functools.wraps的内部实现

多个装饰器

装饰器可以使用多个，多个装饰器的执行顺序是从下往上的，看下面这个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
>>> def wrapper_1(func):
...     def inner():
...             pass
...     print('wrapper_1')
...     return inner
... 
>>> def wrapper_2(func):
...     def inner():
...             pass
...     print('wrapper_2')
...     return inner
... 
>>> @wrapper_1
... @wrapper_2
... def func(): 
...     pass
... 
wrapper_2
wrapper_1
>>>

这很好理解，我们在包装东西的时候，都是先从最里面的一层开始，一层一层包裹，直到最外层（就像“俄罗斯套娃“），所以先执行@wrapper_2再执行外面的@wrapper_1

与此同时，这个例子中并没有调用func函数，但是却有执行的print语句，这更进一步证明了，@wrapper这样的语句相当于执行了func=wrapper(func)，这是在函数定义的时候马上就执行的，而不是调用的时候才执行的，要注意了

到目前，我们对函数的讲解就此结束，内容很多，读者们有得是时间消化了，也为我准备后面小实例提供了准备时间，读者们期待吧！（提示一下，我们将使用微信控制电脑！）

ヾ(￣▽￣)Bye~Bye~