Python进阶__高阶函数、闭包、装饰器

　　在讲高阶函数之前，我们首先来看一个例子。

abs
f=abs
print(abs,f)
'输出为'
<built-in function abs> <built-in function abs>

print(f(-1))
#输出
‘1’

结论：函数体本身也可以赋值给变量，即：变量可以指向函数。

函数名其实就是指向函数的变量！对于abs()这个函数，完全可以把函数名abs看成变量，它指向一个可以计算绝对值的函数

高阶函数

既然变量可以指向函数，函数的参数能接收变量，那么一个函数可以接收另一个函数作为参数，这种函数就称之为高阶函数。

调用函数
例子1.

def add(x,y,f):
    return f(x)+f(y)

print(add(5,-7,abs))
#输出
12

 例子2

#map()函数
'''
map()函数接受两个参数，一个是函数，一个是Iterable，map
将传入的函数依次作用到序列的每个元素，并将结果作为新的
Iterator返回
'''
a=list(map(str,[1,2,3,4,5,56]))

例子3

#reduce()
'''
reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接
收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
'''
def add(x,y):
    return 10*x+y
from functools import reduce
a=reduce(add,[1,2,3,4,5,4,5])

例子4

#filter()筛选
print(list(filter(lambda x:x%2==0,[1,2,3,4,5,6,7,8,9])))

一个小插曲

'''
S.strip()
函数原型
声明：s为字符串，rm为要删除的字符序列
s.strip(rm)      删除s字符串中开头、结尾处，位于 rm删除序列的字符
s.lstrip(rm)     删除s字符串中开头处，位于 rm删除序列的字符
s.rstrip(rm)     删除s字符串中结尾处，位于 rm删除序列的字符
注意：
1. 当rm为空时，默认删除空白符（包括'\n', '\r',  '\t',  ' ')
'''

返回函数

例子1

 

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
f = lazy_sum(1, 3, 5, 7, 9)  #lazy_sum()时，返回的并不是求和结果，而是求和函数。可以理解为

'''
在这个例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数
lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数
中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。

请再注意一点，当我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数
'''

 

'''
>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False

f1()和f2()的调用结果互不影响
'''

闭包

'''
注意到返回的函数在其定义内部引用了局部变量args，所以，当一个函数返回了一个函数后，
其内部的局部变量还被新函数引用，所以，闭包用起来简单，实现起来可不容易。

另一个需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了f()才执行。

'''

一个例子

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs
f1,f2,f3=count()
print(f1(),f2(),f3())

分析

'''
#返回结果为 9 9 9
每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了

全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函
数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9

返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
'''

装饰器

　　‘装饰器就是在不改变函数的时候，对函数添加功能。也就是装饰函数’

一个小插曲

def now():
    print('方方，你好')

#f=now
#f()
#函数对象有一个__name__属性，可以拿到函数的名字
# print(now.__name__)
# print(f.__name__)

'''
现在，假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希
望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）
本质上，decorator就是一个返回函数的高阶函数
'''

一个例子

def log(func):
    def wrapper(*args,**kw):
        print('call {}'.format(func.__name__))
        #return func(*args,**kw)
        func(*args,**kw)
    return wrapper

@log
def now():
    print('方方，你好')

@log
def now1():
    print('方方2号，你好')

代码分析

'''
 把@log放到now()函数的定义处，相当于执行了语句  now=log(now)
 now() 相当于wrapper()
 装饰函数与被装饰函数通过 语法糖 @链接，没有必要放在一起。但是语
 法糖要放在被装饰函数的前面即语法糖要与被装饰的函数紧挨着
'''

一个更复杂的例子

def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

@log('execute')  #now = log('execute')(now)
def now():
    print('2015-3-25')

now()
print(now.__name__)

代码分析

'''
#@log('execute') 相当于 now=log('execute')(now)  先执行log('execute')
#返回decorator，在执行now=decorator(now),decorator接受的参数是被装饰参数now。

#运行之后返回值wrapper函数体赋值给变量now,此时now的函数名是wrapper
#now() 相当于调用wrapper()
'''

'''

小结

在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式需要通过继
承和组合来实现，而Python除了能支持OOP的decorator外，直接从语法层次支持decorator。
Python的decorator可以用函数实现，也可以用类实现。

decorator可以增强函数的功能，定义起来虽然有点复杂，但使用起来非常灵活和方便。
'''