一個 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（內建）內建做用域