Python入门教程：嵌套函数与闭包（初学者必读）

1.创建闭包：三个必要条件

a.嵌套函数定义(外部函数，内部函数)，如果在一个函数内部定义了另一个函数，我们称外部的函数为外函数，内部的函数为内函数。

def out_func():
    def inner_func1():   # 在内部定义函数1
        print('我是第1个内部函数')
        return

    def inner_func2():   # 在内部定义函数2
        print('我是第2个内部函数')
        return

    inner_func1()   # 调用内部函数1
    inner_func2()   # 调用内部函数2

    return

out_func()      # 调用外部函数

输出结果：

我是第1个内部函数
我是第2个内部函数

b.内部函数使用外部函数中定义的变量

c.外部函数一定要有返回值，返回内部函数

2.闭包函数的例子

2.1写一个计数器： 在这个例子中，我们定义了一个名为counter的函数，它返回了一个名为inner的内部函数。inner函数会每次被调用时，将count值加1，并返回新的count值。由于inner函数引用了count变量，因此它形成了一个闭包。当我们调用counter()函数时，它会返回一个inner函数的实例，并将count变量的值初始化为0。每次我们调用返回的inner函数时，它就会增加count的值并返回新的值。因此，我们可以使c()来计数，并每次调用它来获取新的计数值。

def counter():
    count = 0
    def inner():
        nonlocal count
        count += 1
        return count
    return inner

c = counter()
print(c()) # 输出：1
print(c()) # 输出：2
print(c()) # 输出：3

2.2.完成两个数字的求和

def outer_function(x):
    def inner_function(y):
        return x + y

    return inner_function

result = outer_function(10)，
print(result(5))  # 输出15

2.3.使用闭包：求两个点之间的距离(x1-x2)^2 + (y1-y2)^2 的平方根，下面程序确实可以实现相同的功能，不过使用闭包，可以让程序变得更简洁易读。设想一下，比如需要计算很多点之间的距离，那么读者觉得写成下面哪一种形式更好呢？

import math

print('1.普通函数的计算'.center(40, '-'))
# 1.定义计算两点之间距离的函数
def get_distance(x1, y1, x2, y2):
    return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)

dis10 = get_distance(0, 0, 10, 10)
print('（10,10）距离原点的距离为:%g'%dis10)
dis20 = get_distance(0, 0, 20, 20)
print('（20,20）距离原点的距离为:%g'%dis20)

# 2.定义闭包函数
def closure(x1, y1):
    def calculate_distance(x2, y2):
        return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)

    return calculate_distance
print('2.闭包函数的计算'.center(40, '-'))
# 创建一个闭包对象
closure_obj = closure(0, 0)
# 使用闭包对象计算两点之间的距离
distance10 = closure_obj(10, 10)
print('（10,10）距离原点的距离为:%g'%distance10)
distance20 = closure_obj(20, 20)
print('（20,20）距离原点的距离为:%g'%distance20)

输出内容：显然第二种方式表达更为简洁，在每次调用函数时，都可以少输入一组参数。

---------------1.普通函数的计算----------------
（10,10）距离原点的距离为:14.1421
（20,20）距离原点的距离为:28.2843
---------------2.闭包函数的计算----------------
（10,10）距离原点的距离为:14.1421
（20,20）距离原点的距离为:28.2843

3.怎样验证一个函数是闭包函数，首先，闭包函数都有一个特有的属性：closure，由于在foo函数内部定义了4个变量，而且在bar函数内部引用了这4个变量，所以打印这个闭包函数的**__closure__方法**，返回的元组中就有4个元素。

现在可以分别打印返回的元组，中的这4个字符串对象的值

def foo():
    print("hello world in foo")
    name1 = "python1"
    name2 = "python2"
    name3 = "python3"
    name4 = "python4"

    def bar():
        print(name1)
        print(name2)
        print(name3)
        print(name4)
        print("hello world in bar")

    return bar

f1 = foo()
print('打印闭包函数的__closure__方法'.center(40, '-'))
print(f1.__closure__)
print('4个字符串对象的值'.center(40, '-'))
print(f1.__closure__[0].cell_contents)
print(f1.__closure__[1].cell_contents)
print(f1.__closure__[2].cell_contents)
print(f1.__closure__[3].cell_contents)

输出内容:

hello world in foo
----------打印闭包函数的__closure__方法----------
(<cell at 0x00000266129497B0: str object at 0x0000026612A2D0F0>, <cell at 0x00000266129499F0: str object at 0x0000026612DAF930>, <cell at 0x0000026612949690: str object at 0x0000026612DAF4B0>, <cell at 0x0000026612949720: str object at 0x0000026612DAF4F0>)
---------------4个字符串对象的值----------------
python1
python2
python3
python4

4.嵌套函数和闭包有哪些相同和不同？

相同之处：

1. 嵌套函数和闭包都与函数作用域有关。它们都允许一个函数访问另一个函数的变量，即使这个变量在外部函数的作用域之外。

2. 嵌套函数和闭包都可以用来封装代码，提高代码的可读性和可维护性。

不同之处：

1. 嵌套函数是在一个函数内部定义的另一个函数，它只能访问其外部函数的变量。而闭包是一个包含外部函数作用域的函数，它可以访问外部函数的变量，并且可以在其内部修改这些变量。

2. 嵌套函数没有返回值，而闭包可以返回一个值。

3. 嵌套函数不会保存外部函数的变量值，而闭包会保存外部函数的变量值，即使外部函数已经执行完毕。

4. 嵌套函数只能访问其外部函数的变量，而闭包可以访问其外部函数的变量和全局变量。

5. 嵌套函数不会影响其外部函数的变量，而闭包可以修改其外部函数的变量。

感兴趣的小伙伴，赠送全套Python学习资料，包含面试题、简历资料等具体看下方。

一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。

二、Python必备开发工具

工具都帮大家整理好了，安装就可直接上手！

三、最新Python学习笔记

当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。

四、Python视频合集

观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

五、实战案例

纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

六、面试宝典

简历模板

若有侵权，请联系删除