1、问题

有这么一个小面试题：

看下面代码请回答输出的结果是什么?为什么？

result = [lambda x: x + i for i in range(10)]
print(result[0](10))

2、解答

当你看到这篇文章的时候如果不知道这个知识点肯定会拿去直接运行，输出的结果是什么呢？

结果是：19

通过result[0~9](10)结果都是19就，懵逼了吧~~

想知道这个我们先看几个知识点

2.1、列表生成式

顾名思义，列表生成式就是一个用来生成列表的特定语法形式的表达式。

语法格式：

[expression for iterable_var in iterable]

工作过程：

• 迭代iterable的每个元素
• 把迭代的值赋值给iterable_var,然后通过expression的表达式进行计算得到一个新的值
• 最后把所有expression的值以新列表的形式返回

工作过程类似于：

L = []

for i in range(10):
    # 举例expression 表达式 iterable_var * 5 ,最后把这个结果加到列表中
    L.append(i * 5)  

点到为止，我们来看下我们的这个小面试题

result = [lambda x: x + i for i in range(10)]
# 后面的lambada x:x +i 为expression 这是一个普通的lambada表达式那他生成的结果是什么？ 一个一个的函数
# 看下面的例子就舒服多了
L = []

for i in range(10):
    L.append(lambda x: x + i)

那在我们执行result[0](10),其实就是在执行lambda 10: 10 + i ,但是为什么每个i都是9呢？

2.2、函数内部变量的后期绑定(last binding)

我们在写一个函数的时候，函数内不保存这个变量的值，而是在执行的时候去找这个值在哪里绑定上的。

举个例子来说我们在函数中定引用了一个变量,可以不需要提前定义我们只要在使用前定义就可以了,如下面代码

def func():
    print(foo)

foo = "hello tim"

func()

注：这里有个点稍微提醒下,调用函数时这个函数必须是提前定义好的，这个我们称之为“前向引用”，而函数内部变量可以后期再定义，我们称之为“后期绑定”

因为这个变量不是在lambda内定义的，而是在列表生成式内定义的，我先把列表生成式翻译一下：

def make_list():
    L =[]
    for i in range(10):
        def inner(arg):
            return i + arg
        L.append(inner)
    return L

result = make_list()
print(result[2](10))

看上面的代码最后返回的都是一个一个的函数，而这个i的值是在循环的时候赋值的，那我们知道这个i的值不是在，inner(lambda)函数中定义的，而是引用的上层函数的变量，当我们使用inner去调用的时候，这时这个for循环已经结束了，i的值也就变成固定了9

所以每当我们通过函数lambda x: x + i 的时候这个i永远是9

2.3、小作修改

那如果说我不想要这样的结果，我想要i是循环的值怎么办，不要直接引用上层变量，把变量传进来就可以了

result = [lambda x, i=i, : x + i for i in range(10)]
print(result[1](10))

翻译一下

def make_list():
    L =[]
    for i in range(10):
        def inner(arg, i=i):
            return i + arg
        L.append(inner)
    return L

result = make_list()
print(result[2](10))

2.4、闭包

简单解释下这个概念，在嵌套函数内，嵌套函数应用上层函数的变量（不是全局变量）称之为闭包，

def func():
    x = 1

    def inner():
        print(x)

当我们执行func的时候就会生成一个闭包，func执行完后里面的变量x不会被回收，因为嵌套函数inner还在使用它，常见的应用场景就是我们的装饰器