python闭包

声明 :初学python,此文主要作为笔记,知识面浅,若理解有误请多担待,指出错误更是感激不尽!

闭包 :当函数存在嵌套,并且子函数引用了父函数中的变量,可以访问这些变量的作用域就形成闭包。如果子函数没有访问父函数中的变量,就不存在闭包,闭包每次运行是能够记住引用的外部作用域的变量的值。形象点说就是有一个大盒子,里面有个小盒子,小盒子里面用到的一些东西是来自外部的大盒子的,那么这些来自大盒子的东西,就是闭包。

接下来全部使用例子来解释闭包!

例子 一

#这里定义的是一个求和函数

def lazy_sum(*args):
    def sum(): #我就是闭包!因为我引用了外部函数lazy_sum的局部变量args
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum #注意这里返回的是一个函数,返回函数(闭包)的特点看下面的例子
f = lazy_sum(1,2,3)
print(f())

#输出 6

可能应该略微知道闭包是个啥东西了,但是小心!返回的函数是没有马上执行的!直到被调用了才执行,所以这里有坑!什么坑呢?看例子!如果理解了下面的例子,那么你对闭包的理解和使用就更进一步了!

例子 二

#下面代码输出并非1、4、9而是9、9、9

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i #先把局部变量i存起来,但是并没有马上执行
        fs.append(f)
    return fs
f1, f2, f3 = count() #等到执行的时候局部变量已经是3,所以说
                             #打印出来的结果不是1、4、9而是9、9、9!
print(f1())
print(f2())
print(f3())

#因此返回闭包时牢记的一点就是:返回函数不要引用任何循环变量,或者后续会发生变化的变量。

#那硬是要使用循环变量怎么办?既然i属于外部函数,那么我们只要定义一个内部函数暂存下外部函数的值即可,代码如下

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

接下里再通过一个例子看看返回闭包的又一特点

例子 三

#猜猜下面代码会输出什么?复制代码在你的IDE上印证以下吧!

def fun():
    x = 5
    def inner(): #没错!俺是闭包!
        nonlocal x
        x += 1
        return x
    return inner #还是将闭包返回出去
small_box = fun()
for i in range(1, 4):
    print(small_box())

#不知你猜对没有,这里就是返回闭包的一个强大功能了,因为返回的是
#闭包,所以相当于每一次都把inner()执行一遍,而非重新执行fun(),
#相当于将大盒子里面的小盒子取出来,然后不断执行小盒子里面的操作,
#而小盒子里面拥有的大盒子的东西会一直改变,所以输出并非三个6!

最后咱们结合第二和第三个例子构造第四个例子作为练习猜猜输出

例子 四

#猜猜下面这两段代码输出啥?
def foo():
    ret = []
    x = 5
    for i in range(1, 4):
        def inner():
            nonlocal x
            return x
        x += 1
        ret.append(inner)
    return ret
L = foo()
for fun in L:
    print(fun())

#----------华丽分割--------------

def foo():
    ret = []
    x = 5
    for i in range(1, 4):
        def inner():
            nonlocal x
            x += 1
            return x
        ret.append(inner)
    return ret
L = foo()
for fun in L:
    print(fun())

#试着自己解释下原因

欢迎指出错误的地方,以后学到相关的还会继续补充!

时间: 2024-08-08 21:30:07

python闭包的相关文章

Python闭包与函数对象

1. Python闭包是什么 在python中有函数闭包的概念,这个概念是什么意思呢,查看Wikipedia的说明如下: “ In programming languages, closures (also lexical closures or function closures) are a technique for implementing lexically scoped name binding in languages with first-class functions. Ope

python闭包和装饰器(转)

一.python闭包 1.内嵌函数 >>> def func1(): ... print ('func1 running...') ... def func2(): ... print ('func2 running...') ... func2() ... >>> func1() func1 running... func2 running... 内部函数func2作用域都在外部函数func1作用域之内 如果试图在外部函数的外部调用内部函数将会报错 >>&

Python闭包的学习

Python闭包的学习 什么是闭包? 借用维基上解释:在计算机科学中,闭包(Closure)是词法闭包(Lexical Closure)的简称,是引用了自由变量的函数.这个被引用的自由变量将和这个函数一同存在,即使已经离开了创造它的环境也不例外.所以,有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体.闭包在运行时可以有多个实例,不同的引用环境和相同的函数组合可以产生不同的实例. 好吧,看了这段定义的确不是还不能立即理解闭包到底是什么.不过,闭包并不是很难理解,往下看几个小例子就能明

Python闭包举例

Python闭包的条件: 1.函数嵌套.在外部函数内,定义内部函数. 2.参数传递.外部函数的局部变量,作为内部函数参数. 3.返回函数.外部函数的返回值,为内部函数. 举例如下: def line_conf(a, b): def y_point(x): return a*x+b return y_point line1 = line_conf(1, 0) line2 = line_conf(2, 1) list1 = [line1(x) for x in range(10)] list2 =

【Rollo的Python之路】Python 闭包:Colsure

Python 闭包:Closure. 定义: python中的闭包从表现形式上定义(解释)为:如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是闭包(closure). 闭包是由函数及其相关的引用环境组合而成的实体. 函 数是一等公民(First class value:第一类对象,我们不需要像命令式语言中那样借助函数指针,委托操作函数),函数可以作为另一个函数的参数或返回值,可以赋给一个变量.函数可 以嵌套定义,即在一个函数内部可以定义另一个函数,

Python 闭包函数

一.定义: 1. 定义在函数内部的函数 2. 包含对外部作用域名字的引用,而不是对全局作用域名字的引用那么该内部函数就称为闭包函数 x=1 def f1(): x=11111111111 def f2(): print(x) return f2 func=f1() 二.闭包函数的应用:惰性计算 def index(url): # url='https://www.python.org' def get(): # return requests.get(url).text print(reques

Python闭包的高级应用-装饰器的实现

我们先看一个闭包的例子: from time import ctime def before_call(f): def wrapped(*args, **kargs): print 'before calling, now is %s' % ctime() return f(*args, **kargs) return wrapped def test(name): print 'hello, %s' % (name) if __name__ == '__main__': before_call

python 闭包中引用的变量值变更问题

python的闭包的特点是返回的函数还引用了外层函数的局部变量,所以,要正确使用闭包,就要确保引用的局部变量在函数返回后不能变. 如下: def count():     fs = []     for i in range(1, 4):         def lazy_count(j):             def cou():                 return j*j             return cou         r = lazy_count(i)     

[python]闭包到底是什么鬼?

这些东西是我在慕课网,廖雪峰大神的python课中学到的.自己写成笔记的形式分享给大家. 先来看一段代码: 1 def f1(x): 2 return x*x 3 4 def new_fn(f): 5 def fn(j): 6 print 'print'+f.__name__ 7 return f(j) 8 return fn 9 10 g1 = new_fn(f1) 11 print g1(5) 运行结果: printf1 25 1.为什么会用到闭包? 在不修改f1函数的前提下,输出f1函数的