一个 lambda 表达式引发的思考

时间 2019-12-08

原文原文链接

一个 lambda表达式引发的思考

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

全文都是抄来的html

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

一个语法

在Python中，lambda的语法是惟一的。其形式以下：web

 
 
 
 
 
  
  
  
  
   
    
  
  
  
  
  
   
    
     
      
       
        
         
        
        
        
        
         
          
          
          lambda argument_list: expression

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

这里的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函数。api

三个特性

lambda函数有以下特性：闭包

 
 
 
 
 
  
  
  
  
   
    
  
  
  
  
  
   
    
     
      
       
        
         
        
        
        
        
         
          
          
         lambda函数是匿名的：所谓匿名函数，通俗地说就是没有名字的函数。lambda函数没有名字。 
         
         
         
         lambda函数有输入和输出：输入是传入到参数列表argument_list的值，输出是根据表达式expression计算获得的值。 
         
         
        lambda函数通常功能简单：单行expression决定了lambda函数不可能完成复杂的逻辑，只能完成很是简单的功能。因为其实现的功能一目了然，甚至不须要专门的名字来讲明。

下面是一些lambda函数示例：app

 
 
 
 
 
  
  
  
  
   
    
  
  
  
  
  
   
    
     
      
       
        
         
        
        
        
        
         
          
          
         - 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. 解决问题原文连接

1、问题描述

 
 
 
 
 
  
  
  
  
   
    
  
  
  
  
  
   
    
     
      
       
        
        
        
        
         
          
          
         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

2、上面看不懂就看这儿

函数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的异常。

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

一个 lambda 表达式引发的思考