一个 lambda 表达式引起的思考

一个 lambda表达式引起的思考















fun = [lambda x: x*i for i in range(4)]


for item in fun:


    print(item(1))

全文都是抄来的

1. 列表生成式

1.1 range 函数:















Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。


函数语法:
range(stop)
range(start, stop[, step])



参数说明：


start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

1.2 列表生成式:















list 生成式的创建

首先，lsit 生成式的语法为：

[expr for iter_var in iterable] 
[expr for iter_var in iterable if cond_expr]
第一种语法：首先迭代 iterable 里所有内容，每一次迭代，都把 iterable 里相应内容放到iter_var 中，再在表达式中应用该 iter_var 的内容，最后用表达式的计算值生成一个列表。

第二种语法：加入了判断语句，只有满足条件的内容才把 iterable 里相应内容放到 iter_var 中，再在表达式中应用该 iter_var 的内容，最后用表达式的计算值生成一个列表。

其实不难理解的，因为是 list 生成式，因此肯定是用 [] 括起来的，然后里面的语句是把要生成的元素放在前面，后面加 for 循环语句或者 for 循环语句和判断语句。

例子：

# -*- coding: UTF-8 -*-
lsit1=[x * x for x in range(1, 11)]
print(lsit1)
输出的结果：

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
可以看到，就是把要生成的元素 x * x 放到前面，后面跟 for 循环，就可以把 list 创建出来。那么 for 循环后面有 if 的形式呢？又该如何理解：

# -*- coding: UTF-8 -*-
lsit1= [x * x for x in range(1, 11) if x % 2 == 0]
print(lsit1)
输出的结果：

[4, 16, 36, 64, 100]
这个例子是为了求 1 到 10 中偶数的平方根，上面也说到， x * x 是要生成的元素，后面那部分其实就是在 for 循环中嵌套了一个 if 判断语句。

那么有了这个知识点，我们也可以猜想出，for 循环里面也嵌套 for 循环。具体示例：

# -*- coding: UTF-8 -*-
lsit1= [(x+1,y+1) for x in range(3) for y in range(5)] 
print(lsit1)
输出的结果：

[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5)]
其实知道了 list 生成式是怎样组合的，就不难理解这个东西了。因为 list 生成式只是把之前学习的知识点进行了组合，换成了一种更简洁的写法而已。

2. 匿名函数: 原文链接

Python中的lambda的“一个语法，三个特性，四个用法，一个争论”。

一个语法

在Python中，lambda的语法是唯一的。其形式如下：

















 lambda argument_list: expression

其中，lambda是Python预留的关键字，argument_list和expression由用户自定义。具体介绍如下。

这里的argument_list是参数列表。它的结构与Python中函数(function)的参数列表是一样的。具体来说，argument_list可以有非常多的形式。例如：

a, b
a=1, b=2
*args
**kwargs
a, b=1, *args
空
......

这里的expression是一个关于参数的表达式。表达式中出现的参数需要在argument_list中有定义，并且表达式只能是单行的。以下都是合法的表达式：

1
None
a + b
sum(a)
1 if a >10 else 0
......

这里的 lambda argument_list: expression 表示的是一个函数。这个函数叫做lambda函数。

三个特性

lambda函数有如下特性：

















lambda函数是匿名的：所谓匿名函数，通俗地说就是没有名字的函数。lambda函数没有名字。



lambda函数有输入和输出：输入是传入到参数列表argument_list的值，输出是根据表达式expression计算得到的值。


lambda函数一般功能简单：单行expression决定了lambda函数不可能完成复杂的逻辑，只能完成非常简单的功能。由于其实现的功能一目了然，甚至不需要专门的名字来说明。

下面是一些lambda函数示例：

















- lambda x, y: x*y；             函数输入是x和y，输出是它们的积x*y

- lambda:None；                  函数没有输入参数，输出是None

- lambda *args: sum(args);       输入是任意个数的参数，输出是它们的和(隐性要求是输入参数必须能够进行加法运算)

- lambda **kwargs: 1；           输入是任意键值对参数，输出是1

四个用法

由于lambda语法是固定的，其本质上只有一种用法，那就是定义一个lambda函数。在实际中，根据这个lambda函数应用场景的不同，可以将lambda函数的用法扩展为以下几种：

将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数。

















例如，执行语句add=lambda x, y: x+y，定义了加法函数lambda x, y: x+y，并将其赋值给变量add，这样变量add便成为具有加法功能的函数。例如，执行add(1,2)，输出为3。

将lambda函数赋值给其他函数，从而将其他函数用该lambda函数替换。

















例如，为了把标准库time中的函数sleep的功能屏蔽(Mock)，我们可以在程序初始化时调用：time.sleep=lambda x:None。这样，在后续代码中调用time库的sleep函数将不会执行原有的功能。例如，执行time.sleep(3)时，程序不会休眠3秒钟，而是什么都不做。

将lambda函数作为其他函数的返回值，返回给调用者。

















函数的返回值也可以是函数。例如return lambda x, y: x+y返回一个加法函数。这时，lambda函数实际上是定义在某个函数内部的函数，称之为嵌套函数，或者内部函数。对应的，将包含嵌套函数的函数称之为外部函数。内部函数能够访问外部函数的局部变量，这个特性是闭包(Closure)编程的基础，在这里我们不展开。

将lambda函数作为参数传递给其他函数。

















部分Python内置函数接收函数作为参数。典型的此类内置函数有这些。


- filter函数。
    此时lambda函数用于指定过滤列表元素的条件。例如filter(lambda x: x % 3 == 0, [1, 2, 3])指定将列表[1,2,3]中能够被3整除的元素过滤出来，其结果是[3]。

- sorted函数。
    此时lambda函数用于指定对列表中所有元素进行排序的准则。例如sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5-x))将列表[1, 2, 3, 4, 5, 6, 7, 8, 9]按照元素与5距离从小到大进行排序，其结果是[5, 4, 6, 3, 7, 2, 8, 1, 9]。

- map函数。
    此时lambda函数用于指定对列表中每一个元素的共同操作。例如map(lambda x: x+1, [1, 2,3])将列表[1, 2, 3]中的元素分别加1，其结果[2, 3, 4]。

- reduce函数。
    此时lambda函数用于指定列表中两两相邻元素的结合条件。例如reduce(lambda a, b: '{}, {}'.format(a, b), [1, 2, 3, 4, 5, 6, 7, 8, 9])将列表 [1, 2, 3, 4, 5, 6, 7, 8, 9]中的元素从左往右两两以逗号分隔的字符的形式依次结合起来，其结果是'1, 2, 3, 4, 5, 6, 7, 8, 9'。

另外，部分Python库函数也接收函数作为参数，例如 gevent 的 spawn 函数。此时，lambda 函数也能够作为参数传入。

3. 闭包原文链接

1.什么是闭包，闭包必须满足以下3个条件：

必须是一个嵌套的函数。
闭包必须返回嵌套函数。
嵌套函数必须引用一个外部的非全局的局部自由变量。

举个栗子















# 嵌套函数但不是闭包

def nested():
    def nst():
        print('i am nested func %s' % nested.__name__)
    nst()


# 闭包函数

def closure():
    var = 'hello world' # 非全局局部变量



    def cloe():
        print(var) # 引用var

    return cloe # 返回内部函数


cl = closure()

cl()

2.闭包优点

避免使用全局变量
可以提供部分数据的隐藏
可以提供更优雅的面向对象实现

优点1,2 就不说了，很容易理解，关于第三个，例如当在一个类中实现的方法很少时，或者仅有一个方法时，就可以选择使用闭包。

举个栗子

















# 用类实现一个加法的类是这样

class _Add(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def add(self):
        return self.a + self.b

# 用闭包实现
def _Add(a):
    def add(b):

        return a + b



    return add  


ad = _Add(1) # 是不是很像类的实例化

print(ad(1)) # out:2

print(ad(2)) # out:3

print(ad(3)) # out:4

闭包的概念差不多就是这样了。

4. 延迟绑定:

















def _Add(a):

    def add(b):
        return a + b
    # 1. 这是一个闭包

    # 2. 当 python 解释器走到 add 函数时, 发现这是一个函数, 定义下 参数 a 然后跳过该函数 接着往下执行

    # 3. 当执行 add 函数的时候, 因为 add 函数定义的时候, 并没有定义 b对象, 所以按照 LEGB 规则 需要向外找

    # 4. 这就是 延迟绑定





    return add

5. 解决问题原文链接

一、问题描述















fun = [lambda x: x*i for i in range(4)]


for item in fun:


    print(item(1))

上述式子的输出结果：预计结果为：0, 2, 4, 6 实际输出为：3, 3, 3, 3

原理：i 在外层作用域 lambda x: x*i 为内层（嵌）函数，他的命名空间中只有 {'x': 1} 没有 i ，所以运行时会向外层函数（这儿是列表解析式函数 [ ]）的命名空间中请求 i 而当列表解析式运行时，列表解析式命名空间中的 i 经过循环依次变化为 0-->1-->2-->3 最后固定为 3 ，所以当 lambda x: x*i 内层函数运行时，去外层函数取 i 每次都只能取到 3
解决办法：变闭包作用域为局部作用域。给内层函数 lambda x: x*i 增加参数，命名空间中有了用来存储每次的 i , 即改成 [lambda x, i=i: x*i for i in range(4)] 这样每一次，内部循环生成一个lambda 函数时，都会把 --i--作为默认参数传入lambda的命名空间循环4次实际lambda表达式为：第一次：lambda x, i=0 第二次：lambda x, i=1 第三次：lambda x, i=2 第四次：lambda x, i=3

















fun = [lambda x, i=i: x*i for i in range(4)]


for item in fun:


    print(item(1))





#输出结果为：


0


1


2


3

二、上面看不懂就看这儿

函数fun = [lambda x: x*i for i in range(4)]等价于：如下函数















def func():

    fun_lambda_list = []

    for i in range(4):
        def lambda_(x):
            return x*i
        fun_lambda_list.append(lambda_)

        

    return fun_lambda_list

查看该函数命名空间及 I 值变化：















def func():

    fun_lambda_list = []
    for i in range(4):

        def lambda_(x):
            print('Lambda函数中 i {} 命名空间为：{}:'.format(i, locals()))
            return x*i
        fun_lambda_list.append(lambda_)
        print('外层函数 I 为：{} 命名空间为:{}'.format(i, locals()))

    return fun_lambda_list

fl = func()
fl[0](1)
fl[1](1)

fl[2](1)

fl[3](1)

#运行结果为：为了排版美观，我已将输出lambda_函数地址改名为：lam函数1 2 3















外层函数I为：0 命名空间为:{'i': 0, 'lambda_': lam函数1 'fun_lambda_list': [lam函数1]}

外层函数I为：1 命名空间为:{'i': 1, 'lambda_': lam函数2, 'fun_lambda_list': [lam函数1, lam函数2]}
外层函数I为：2 命名空间为:{'i': 2, 'lambda_': lam函数3, 'fun_lambda_list': [lam函数1, lam函数2, lam函数3]}

外层函数I为：3 命名空间为:{'i': 3, 'lambda_': lam函数4, 'fun_lambda_list': [lam函数1, lam函数2, lam函数3, lam函数4]}

Lambda函数中 i 3 命名空间为：{'i': 3, 'x': 1}:
Lambda函数中 i 3 命名空间为：{'i': 3, 'x': 1}:
Lambda函数中 i 3 命名空间为：{'i': 3, 'x': 1}:
Lambda函数中 i 3 命名空间为：{'i': 3, 'x': 1}:

可以看见：就像上面所说的：四次循环中外层函数命名空间中的 i 从 0-->1-->2-->3 最后固定为3，而在此过程中内嵌函数-Lambda函数中因为没有定义 i 所以只有Lambda 函数动态运行时，在自己命名空间中找不到 i 才去外层函数复制 i = 3 过来，结果就是所有lambda函数的 i 都为 3，导致得不到预计输出结果：0，1，2，3 只能得到 3, 3, 3, 3

解决办法：变闭包作用域为局部作用域。















def func():

    fun_lambda_list = []
    for i in range(4):
        def lambda_(x, i= i):
            print('Lambda函数中 i {} 命名空间为：{}:'.format(i, locals()))
            return x*i
        fun_lambda_list.append(lambda_)
    return fun_lambda_list

fl = func()
res = []

res.append(fl[0](1))
res.append(fl[1](1))
res.append(fl[2](1))
res.append(fl[3](1))

print(res)

#输出结果为：

Lambda函数中 i 0 命名空间为：{'x': 1, 'i': 0}:

Lambda函数中 i 1 命名空间为：{'x': 1, 'i': 1}:

Lambda函数中 i 2 命名空间为：{'x': 1, 'i': 2}:

Lambda函数中 i 3 命名空间为：{'x': 1, 'i': 3}:
[0, 1, 2, 3]

给内层函数 lambda增加默认参数，命名空间中有了用来存储每次的 i , 即改成 `def lambda(x, i=i) :` 这样每一次，内部循环生成一个lambda 函数时，都会把 i 作为默认参数传入lambda的命名空间循环4次实际lambda表达式为：第一次：lambda( x, i=0) 第二次：lambda(x, i=1) 第三次：lambda(x, i=2) 第四次：lambda(x, i=3)

这样我们就能得到预计的结果：0, 1, 2, 3

5. LEGB

只有函数、类、模块会产生作用域，代码块不会产生作用域。作用域按照变量的定义位置可以划分为4类：















Local(函数内部)局部作用域


Enclosing（嵌套函数的外层函数内部）嵌套作用域（闭包）

Global（模块全局）全局作用域



Built-in（内建）内建作用域

python解释器查找变量时，会按照顺序依次查找局部作用域--->嵌套作用域--->全局作用域--->内建作用域，在任意一个作用域中找到变量则停止查找，所有作用域查找完成没有找到对应的变量，则抛出 NameError: name 'xxxx' is not defined的异常。

人生还有意义。那一定是还在找存在的理由