锐客网

  1. 首页 > 生活百科 > it技术 > >

Python闭包高级函数 python闭包函数的应用场景

IT技术函数

Python基础之闭包一.闭包的定义：
在一个函数的内部 ， 再定义一个函数(内部函数) 。这个内部函数引用了外部函数的变量，并且外部函数返回这个内部函数，我们把这个使用外部函数变量的内部函数称为闭包。
简而言之 ， 闭包就是能够读取外部函数内的变量的函数 。
例如：
形成闭包的两个条件:
二.闭包的用途
①可以读取函数内部的变量
②将一些变量的值始终保存到内存中
1.读取函数内部的变量
在一般情况下，在函数外部我们是不能访问到函数内部的变量的 。但是， 有时想要在函数外部能够访问到函数内部的变量，那么就可以使用闭包 。
例如:
上面的代码可以看出，print(a)会抛异常NameError: name 'a' is not defined 。在函数f1的外面无法访问它的变量的 。
在函数f1里面定义一个闭包函数就可以访问到了
例如：
2.将一些变量的值始终保存到内存中
运行结果:
通过上面的输出结果可以看出闭包保存了外部函数内的变量n1的值1，每次执行闭包都是在n1 = 1 基础上进行计算的 。
三.闭包的缺点
1. 由于闭包会使得函数中的变量都被保存在内存中，会增加内存消耗，所以不能滥用闭包 ， 否则会造成程序的性能问题，可能导致内存泄露
2. 闭包无法改变外部函数局部变量指向的内存地址
3. 返回闭包时，返回函数不要引用任何循环变量，或者后续会发生变化的变量
四.判断一个函数是否是闭包
判断一个函数是不是闭包，可以查看它的closure属性 。如果该函数是闭包，查看该属性将会返回一个cell对象组成的tuple 。如果我们分别对每个cell对象查看其cell_contents属性，返回的内容就是闭包引用的自由变量的值 。
运行结果:
闭包的__closure__方法，可以展示出闭包储存了外部函数的两个变量，cell的内存地址是什么，在cell里面储存的对象类型是int，这个int储存的内存地址是什么 。
闭包的__closure__方法，可以查看每个cell对象的内容
运行结果:
cell_contents解释了局部变量在脱离函数后仍然可以在函数之外被访问的原因，因为变量被存储在cell_contents中了 。
python函数的闭包怎么理解1. 闭包的概念
首先还得从基本概念说起，什么是闭包呢？来看下维基上的解释:
复制代码代码如下:
在计算机科学中 ， 闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数 。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外 。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体 。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例 。
....
上面提到了两个关键的地方： 自由变量 和 函数, 这两个关键稍后再说 。还是得在赘述下“闭包”的意思，望文知意，可以形象的把它理解为一个封闭的包裹 ， 这个包裹就是一个函数，当然还有函数内部对应的逻辑，包裹里面的东西就是自由变量，自由变量可以在随着包裹到处游荡 。当然还得有个前提 ， 这个包裹是被创建出来的 。
在通过Python的语言介绍一下，一个闭包就是你调用了一个函数A，这个函数A返回了一个函数B给你 。这个返回的函数B就叫做闭包 。你在调用函数A的时候传递的参数就是自由变量 。
举个例子：
复制代码代码如下:
def func(name):
def inner_func(age):
print 'name:', name, 'age:', age
return inner_func
bb = func('the5fire')
【Python闭包高级函数 python闭包函数的应用场景】bb(26)#name: the5fire age: 26
这里面调用func的时候就产生了一个闭包——inner_func,并且该闭包持有自由变量——name，因此这也意味着 ， 当函数func的生命周期结束之后，name这个变量依然存在，因为它被闭包引用了，所以不会被回收 。
另外再说一点 ， 闭包并不是Python中特有的概念，所有把函数做为一等公民的语言均有闭包的概念 。不过像Java这样以class为一等公民的语言中也可以使用闭包，只是它得用类或接口来实现 。
更多概念上的东西可以参考最后的参考链接 。
2. 为什么使用闭包
基于上面的介绍，不知道读者有没有感觉这个东西和类有点相似，相似点在于他们都提供了对数据的封装 。不同的是闭包本身就是个方法 。和类一样，我们在编程时经常会把通用的东西抽象成类，（当然，还有对现实世界——业务的建模） ， 以复用通用的功能 。闭包也是一样，当我们需要函数粒度的抽象时 ， 闭包就是一个很好的选择 。
在这点上闭包可以被理解为一个只读的对象，你可以给他传递一个属性 ， 但它只能提供给你一个执行的接口 。因此在程序中我们经常需要这样的一个函数对象——闭包 ， 来帮我们完成一个通用的功能，比如后面会提到的——装饰器 。
3. 使用闭包
第一种场景 ， 在python中很重要也很常见的一个使用场景就是装饰器，Python为装饰器提供了一个很友好的“语法糖”——@，让我们可以很方便的使用装饰器，装饰的原理不做过多阐述 ， 简言之你在一个函数func上加上@decorator_func, 就相当于decorator_func(func):
复制代码代码如下:
def decorator_func(func):
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
@decorator_func
def func(name):
print 'my name is', name
# 等价于
decorator_func(func)
在装饰器的这个例子中，闭包（wrapper）持有了外部的func这个参数，并且能够接受外部传过来的参数 ， 接受过来的参数在原封不动的传给func，并返回执行结果 。
这是个简单的例子，稍微复杂点可以有多个闭包，比如经常使用的那个LRUCache的装饰器，装饰器上可以接受参数@lru_cache(expire=500)这样 。实现起来就是两个闭包的嵌套:
复制代码代码如下:
def lru_cache(expire=5):
# 默认5s超时
def func_wrapper(func):
def inner(*args, **kwargs):
# cache 处理 bala bala bala
return func(*args, **kwargs)
return inner
return func_wrapper
@lru_cache(expire=10*60)
def get(request, pk)
# 省略具体代码
return response()
不太懂闭包的同学一定得能够理解上述代码，这是我们之前面试经常会问到的面试题 。
第二个场景 ，就是基于闭包的一个特性——“惰性求值” 。这个应用比较常见的是在数据库访问的时候，比如说：
复制代码代码如下:
# 伪代码示意
class QuerySet(object):
def __init__(self, sql):
self.sql = sql
self.db = Mysql.connect().corsor()# 伪代码
def __call__(self):
return db.execute(self.sql)
def query(sql):
return QuerySet(sql)
result = query("select name from user_app")
if timenow:
print result# 这时才执行数据库访问
上面这个不太恰当的例子展示了通过闭包完成惰性求值的功能 ， 但是上面query返回的结果并不是函数，而是具有函数功能的类 。有兴趣的可以去看看Django的queryset的实现，原理类似 。
第三种场景 ，需要对某个函数的参数提前赋值的情况，当然在Python中已经有了很好的解决访问 functools.parial,但是用闭包也能实现 。
复制代码代码如下:
def partial(**outer_kwargs):
def wrapper(func):
def inner(*args, **kwargs):
for k, v in outer_kwargs.items():
kwargs[k] = v
return func(*args, **kwargs)
return inner
return wrapper
@partial(age=15)
def say(name=None, age=None):
print name, age
say(name="the5fire")
# 当然用functools比这个简单多了
# 只需要： functools.partial(say, age=15)(name='the5fire')
看起来这又是一个牵强的例子，不过也算是实践了闭包的应用 。
一文读懂Python 高阶函数将函数作为参数传入，这样Python闭包高级函数的函数称为高阶函数 。函数式编程就是指这种高度抽象的编程范式 。
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数 ， 这种函数就称之为高阶函数 。如下所示：
map(fun, lst)，将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表返回 。
定义一个匿名函数并调用，定义格式如--lambda arg1,arg2…:表达式
reduce把一个函数作用在一个序列[x1, x2, x3, …]上 ， 这个函数必须接收两个参数 ， reduce把结果继续和序列的下一个元素做累积计算 。
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表 。
闭包的定义？闭包本质上就是一个函数
如何创建闭包？
如何使用闭包？典型的使用场景是装饰器的使用 。
global与nonlocal的区别：
简单的使用如下：
偏函数主要辅助原函数 ， 作用其实和原函数差不多 ， 不同的是 ， Python闭包高级函数我们要多次调用原函数的时候 ， 有些参数，我们需要多次手动的去提供值 。
而偏函数便可简化这些操作 ， 减少函数调用，主要是将一个或多个参数预先赋值，以便函数能用更少的参数进行调用 。
我们再来看一下偏函数的定义：
类func = functools.partial(func, *args, **keywords)
我们可以看到，partial 一定接受三个参数，从之前的例子，我们也能大概知道这三个参数的作用 。简单介绍下：
总结
本文是对Python 高阶函数相关知识的分享，主题内容总结如下：
求帮助 ， Python闭包和返回函数问题（1）unpack tuple和list, 可以让函数返回多个值
def count():
return (1, 2, 3) # 或者 return [1, 2, 3]
# 把列表解包 ， 把1 2 3 分别赋值给 a b c
a, b, c = count()
print a, b, c
# 输出 1, 2, 3
（2）假设你知道Python的dict类型 。Python中，在函数中定义一个变量的时候，会在一个隐藏的叫locals的dict里面插入key-value，其中key是变量名，value是变量值 。而引用一个变量的时候，则首先会在这个叫locals的dict里面，根据变量名作为key，去查对应的值 。
var = 1# 你可以认为这里进行了 locals['var'] = 1 的操作
print var# 在对var变量进行求值的时候，就在locals['var']里面找var变量对应的值
（3）for循环中，每次循环只是给 `i` 重新绑定值
for i in (1, 2, 3):
print i
print i
# 一次输入 1 2 3 3
每次`for i in (1, 2, 3)`相当于在`print i`之前，进行了
`locals['i'] = 1`
`locals['i'] = 2`
`locals['i'] = 3`
的操作
所以最后的`print i`再去locals字典里面找`i`的时候，就变成 3 了 。
（4）闭包是 一个函数加上这个函数引用的外部变量
var = 1
def f():
print var
# 这里的闭包是函数 f 和 f 引用的外部变量 var
def count():
var2 = 2
def f():
print var2
# 这里的闭包是函数 f 和 f 引用的外部变量 var2
return f
拿第一个函数 f 来说 。在 f 运行的时候，解释器拿着'var'这个字符串去locals字典里面找 ， 发现找不到，于是在closure字典里面找，最后closure字典里面找，你可以认为就是找closure['var']，然后发现找到对应的值 。count里面的 f 函数同理 。
（为了容易理解，我这里说谎了 。实际上 f 压根没有closure ， count里面的 f 才有 。其实closure压根不是像locals那样的字典）
（5）函数定义时，函数只是记录变量的名字 。
要区分什么是名字，什么是值 。
`i = 1`这里 i 只是名字 ， 只是一个字符串 'i'。这句话运行完 ， locals['i'] = 1，就说 i 对应的值是1
def count():
fs = []
for i in range(1, 4):
# 定义一个函数，等价于运行了 locals['f'] = 真正生成的函数
# 每次循环，这里都会重新生成一个函数 ， 然后把重新生成的函数赋值给 locals['f']
def f():
return i * i# 引用了'i'这个名字，但并不是引用了'i'对应的值
# 等价于 locals['fs'].append(locals['f'])
# f 不是函数，它只是一个名字'f' 。f 引用的东西，也就是locals['f']才是真正的函数
fs.append(f)
# 于是这个for循环生成了三个函数，这三个函数是没有名字的，这个函数运行完后 ， 它们跟'f'这个名字就毛关系都没有了(是的我说慌了 ， 但可以先不管)
# 把整个列表返回，这个列表包含了三个函数
return fs
# count()返回三个函数的列表，unpack 列表的语法把列表中的三个函数抽出来，重新给他们命名为 f1, f2, f3
# 也就是说，
# locals['f1'] = 列表中的第1个函数
# locals['f2'] = 列表中的第2个函数
# locals['f3'] = 列表中的第3个函数
# 这三个函数跟'f'这个名字现在毛关系都没有 。（其实是有的，但为了说明需要简化，现在你可以完全不管括号里面说的话）
f1, f2, f3 = count()
print f1(), f2(), f3()
# 好了我们运行它们 ， 输入都是 9
# def f():
#return i * i
这是因为 f1 现在对应的函数，里面引用了 'i' 这个字符串 ， 我们根据 'i '这个字符串去找它对应的值，先找到 f 当前的locals字典，发现没有，因为函数定义的时候没有定义 i 变量 。然后再去closure['i']里面找 ， 因为Python是通过closure字典实现闭包的（就当它是对的好不好），所以我们可以在closure['i']找到值，这个值就是我们上一次运行的时候count函数里面残留的locals['i']，而由于for循环三遍之后，locals['i'] == 3，所以找到 i 的值就是3 。所以最后输出都是9
Python嵌套函数和闭包在Python语言中，可以在函数中定义函数 。这种在函数中嵌套定义的函数也叫内部函数 。我们来看下面的代码：
上述代码中，定义了函数greet，在函数greet内部又定义了一个函数inner_func, 并调用该函数打印了一串字符 。
我们可以看到 ， 内部函数inner_func的定义和使用与普通函数基本相同 。需要注意的是变量的作用域，在上述代码中 ， 函数参数name对于全局函数greet是局部变量，对内部函数inner_func来说则是非局部变量 。内部函数对于非局部变量的访问规则类似于标准的外部函数访问全局变量 。
从这个例子我们还可以看到内部函数的一个作用 ， 就是通过定义内部函数的方式将一些功能隐藏起来，防止外部直接调用 。常见的场景是，在一个复杂逻辑的函数中，将一些小的任务定义成内部函数，然后由这个外层函数使用，这样可以使代码更为清晰，易于维护 。这些内部函数只会在这个外层函数中使用，不能被其他函数或模块使用 。
在Python语言中, 函数也是对象，它可以被创建、赋值给变量 ， 或者作为函数的返回值 。我们来看下面这个例子 。
在上述代码中，在函数gen_greet内部定义了inner_func函数，并返回了一个inner_func函数对象 。外部函数gen_greet返回了一个函数对象 ， 所以像gen_greet这样的函数也叫工厂函数 。
在内部函数inner_func中，使用了外部函数的传参greet_words（非局部变量），以及函数的参数name（局部变量） ， 来打印一个字符串 。
接下来 ， 调用gen_greet("Hello")创建一个函数对象say_hello，紧接着调用say_hello("Mr. Zhang")，输出的结果为：Hello, Mr. Zhang！
同样的，调用gen_greet("Hi")创建一个函数对象say_hi，调用say_hello("Mr. Zhang")，输出的结果为：Hi，Tony！
我们可以发现，gen_greet返回的函数对象具有记忆功能 ， 它能够把所需使用的非局部变量保存下来，用于后续被调用的时候使用 。这种保存了非局部变量的函数对象被称作闭包（closure） 。
那么闭包是如何实现的呢？其实并不复杂，函数对象中有一个属性__closure__，它就是在创建函数对象时用来保存这些非局部变量的 。
__closure__属性是一个元组或者None类型 。在上述代码中，我们可以通过下面方式查看：
函数的嵌套所实现的功能大都可以通过定义类的方式来实现，而且类是更加面向对象的代码编写方式 。
嵌套函数的一个主要用途是实现函数的装饰器 。我们看下面的代码：
在上述代码中，logger函数返回函数with_logging，with_logging则是打印了函数func的名称及传入的参数，然后调用func, 并将参数传递给func 。其中的@wraps(func)语句用于复制函数func的名称、注释文档、参数列表等等 ， 使得with_logging函数具有被装饰的函数func相同的属性 。
代码中接下来用@logger对函数power_func进行修饰，它的作用等同于下面的代码:
可见，装饰器@符其实就是上述代码的精简写法 。
通过了解了嵌套函数和闭包的工作原理 ， 我们在使用过程中就能够更加得心应手了 。
关于Python闭包高级函数和python闭包函数的应用场景的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站 。

    推荐阅读


    上一篇：mongodb意向锁，mongodb ensureindex

    下一篇：二手直播设备杭州市场，二手主播设备吧