Python—高级函数

Python函数是支持嵌套的。如果在一个内部函数中对外部函数作用域（非全局作用域）的变量进行引用，那么内部函数就会被称为闭包。闭包需要满足如下3个条件：

存在于两个嵌套关系的函数中，并且闭包是内部函数；

内部函数引用了外部函数的变量；

外部函数会返回内部函数的函数名。

举例：

#演示内置函数

def a():#1定义外部函数

b=1#3 外部函数代码

def c():#4定义内部函数

print(b)#6 执行内部函数代码

c()#5调用内部函数

a() #2调用外部函数

#演示把内部函数返回（闭包的必要条件），外部可以用接收返回值的方式来访问内部函数

def a():

def b():

return 1 #定义了内部函数的返回值为1

return b #定义了外部函数的返回值为内部函数

rst=a() #接收了外部函数的返回值，也就是内部函数

print(rst)#rst就是内部函数

print(a()())#a()()=rst()

print(rst())#rst（）是调用内部函数

#使用一个函数作为另一个函数的参数

def a(func_a):#可以传任意函数

print("你好，我是小a！")

func_a() #可以对已定义的函数做额外的操作，不需要修改原来的函数

print("gudeibai")

def b():

print("你好，我是小b！")

a(b)

def outer(start=0):

count=[start]

def inner():

count[0]+=1

return count[0]

return inner

out=outer(5)

print(out())

#使用闭包实现案例

#有银行卡才能执行汇款的操作

#外部函数为创建银行卡

#内部函数为汇款的操作

def bank(isVIP,action):

if isVIP:

print("客户你好，欢迎光临")

else:

print("您好，给你办一张新卡")

if action=="huikuan":

def remit():

print("进行汇款操作")

return remit

if action=="cun":

def cunkuan():

print("进行存款")

return cunkuan

card=bank(False,"cun")

card()

假设我们已经定义了一个函数，后续可能会增加临时的需求，例如插入日志，我们可以增加一个包裹函数，由它来负责这些额外的需求，这个包裹函数就是装饰器 。

装饰器主要用于下列场景：

引入日志；

函数执行时间统计；

执行函数前预备处理；

执行函数后清理功能；

权限校验；

缓存。

装饰器是一个函数，它需要接收一个参数，该参数表示被修饰的函数。例如，有如下一个装饰器函数：

def wrap(func):

print(‘正在装饰’)

def inner():

print(‘正在验证权限’)

func()

return inner()

装饰器是个嵌套函数

内部函数是一个闭包。

外部函数接收的是被修饰的函数（func）

通过在函数定义的前面添加@符号和装饰器名，实现装饰器对函数的包装。给test函数加上装饰器，示例如下：

@wrap

def test():

print(’test')

此时，程序会自动编译生成调用装饰器函数的代码，等价于：

test = wrap(test)

举例：

1.#演示装饰器

from functools import wraps, reduce

def a(func_a):

print("装饰器开始工作")

@wraps(func_a)

def b():

print("闭包开始工作")

func_a()

print("装饰器工作结束")

return b

def decorator_c():

print("感觉很虚空，需要被装饰")

rst=a(decorator_c()) #b

rst()

@a

def abc():

print("想要被装饰")

abc()

print(abc.__name__)

2.

def func(function_name):

print("这是一个有返回值的闭包")

def func_in():

return function_name()

return func_in

@func #装饰器的名称

def test():

return 'hello world'

a=test()

print(a)

3.

def out(args):

def fun(function_name):

print('闭包')

def fun_in():

print(args)

return function_name()

return fun_in

return fun

fun=out('hello')

@fun

def test():

return 'hello world'

a=test()

print(a)

• map函数

map函数会根据提供的函数对指定的序列做映射。

map函数的定义如下：

map(function, iterable,…)

参数function表示函数的名称，参数iterable可以是序列、支持迭代的容器或者迭代器。

map函数的作用是以iterable中的每个元素调用function函数，把每次调用后返回的结果保存为迭代器对象。

func = lambda x:x+2

result = map(func, [1,2,3,4,5])

print(list(result))

举例：

#演示map函数

func=lambda x:x+2

rst=map(func,(1,2,3,4,5))

for x in rst:

print(x)

• filter函数

filter函数会对指定序列执行过滤操作。

filter函数的定义如下：

filter(function，iterable）

function参数可以是函数的名称或None； iterable参数可以是序列、支持迭代的容器或迭代器。

func = lambda x:x%2

result = filter(func, [1, 2, 3, 4, 5])

print(list(result))

举例：

#演示filter函数

func=lambda x:x>5#返回为true通过，false不通过

rst=filter(func,[1,2,3,4,5,6,7,8])

print(list(rst))

• reduce函数

reduce函数会对参数序列中的元素进行累积。

reduce函数的定义如下：

reduce(function, iterable[, initializer])

function是一个带有两个参数的函数；

iterable是一个迭代器对象；

initializer表示固定的初始值。

代码演示：

from functools import reduce

func = lambda x, y:x + y

result = reduce(func, [1, 2, 3, 4, 5])

print(result)

举例：

#演示reduce函数

func=lambda x,y:x+y#前一个值和后一个值相加

rst=reduce(func,[1,2,3,4,5,6,7,8,9,10])

print(rst)

注意：function参数不能为None。

在Python 3中，reduce函数已经被从全局名字空间里面移除了，它现在被放置在fucntools模块中，使用时需要先引入，格式如下：

from functools import reduce

总结：

闭包:

1、一个函数包含另一个函数

2、外部函数return了内部函数名

3、内部函数调用了外部函数的变量

--这个内部函数叫做闭包

特点:闭包不能直接被调用，而是需要调用外部函数获得返回值;使用该返回值()，来调用内部函数

二、装饰器

1、在外部函数的参数部分接收函数名

2、在内都函数的函数体中调用参数对应的函数

3.外部函数返回了内部函数

4.调用外部函数获取返回值（闭包)

5.通过闭包调用，实现对参数对应的函数调用

6.可以通过@装饰器名，来替代传参的过程

特点：

装饰器的调用相对安全可靠，并且不会改变原函数的逻辑