函数闭包python 函数闭包 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语言中函数闭包python，可以在函数中定义函数。 这种在函数中嵌套定义函数闭包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内嵌函数与闭包里func是不是有位置参数return func（），没有位置参数return func

定义个函数，查看带括号和不带括号的type.

def func1():

pass

print(type(func1))

#执行结果：class 'function'

print(type(func1()))

#执行结果：class 'NoneType'

由此可见：

使用return func 时返回的是func 这个函数；

使用return func() 时返回的是func() 执行后的返回值，如果func()函数没有返回值则返回值为None，

func函数如果有其他打印语句也会一起执行。

python中使用闭包及修改外部函数的局部变量

在python中，函数可以被嵌套定义，也就是说，函数中可以定义函数。该函数还可以将其内部定义的函数作为返回值返回。

闭包的定义：一般来说，我们可以认为，如果一个函数可以读取其他函数中的局部变量，那么它们就构成了闭包。

注意 ：闭包的定义不是特别清晰，但大体上的意思是这样的。

我们知道，普通的函数是可以使用全局变量的

类似的，函数中定义的函数，也是可以使用外部函数的变量的。因此，满足了函数读取了其他函数局部变量的这一条件，他们因此构成了闭包。

在闭包的使用中，我们可以先给外部的函数赋予不同的局部变量，然后再调用其中内部的函数时，就可以读取到这些不同的局部变量了。

外部变量的使用 在普通函数中，虽然可以直接使用全局变量，但是不可以直接修改全局变量。从变量的作用域来说，一旦你尝试修改全局变量，那么就会尝试创建并使用一个同名的局部变量。因此，如果你需要在普通函数中修改全局变量，需要使用global

同样的，如果你希望通过定义在内部的函数去修改其外部函数的变量，那么必须使用nonlocal

请教大神一个关于python闭包的问题

在python3.0之前函数闭包python的版本中, 闭包只能够访问而不能修改外部变量(非全局), 所以, 通常为了方便修改, 我们就使用可变对象来通过修改对象内部函数闭包python的一些引用来达到间接修改的目的, 因此, 通常的数字类型, 字符串类型等不可变类型不可以作为用于修改的自由变量(闭包中引用的外部变量)

在python3.0及以后版本中, 通过nonlocal关键字解决了这个问题, 并增强了闭包. 在之前的版本中, 外部变量实际上是会放入内部函数(闭包)的local这个名称空间中的, 所以, 在之前版本中, 我们在闭包内试图修改一个外部变量的时候, 往往会得到一个"在引用之前没有赋值"的一个错误. 3.0之后, 给要在闭包内修改的变量加上(在闭包内修改之前)nonlocal的声明, 然后, 在下面的代码中修改就可以了....

这个用法和global关键字解决函数内修改全局变量有异曲同工之妙...

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和函数闭包 python的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。