python3中apply函数和lambda函数的使用详解

lambda函数

lambda是什么

大家好，今天给大家带来的是有关于Python里面的lambda表达式详细解析。lambda在Python里面的用处很广，但说实话，我个人认为有关于lambda的讨论不是如何使用的问题，而是该不该用的问题。接下来还是通过大量实例和大家分享我的学习体验，可能最后你也会得出和我一样的结论。

好啦，首先让我们先搞明白基础定义，lambda到底是什么？

Lambda表达了Python中用于创建匿名函数的特殊语法。我们将lambda语法本身称为lambda表达式，从这里得到的函数称之为lambda函数。

其实总结起来，lambda可以理解为一个小的匿名函数，lambda函数可以使用任意数量的参数，但只能有一个表达式。估计有JavaScript ES6经验的朋友们听上去会很亲切，具体函数表达式如下：

模板： lambda argument: manipulate(argument)
参数：argument就是这个匿名函数传入的参数，冒号后面是我们对这个参数的操作方法
让我们参考上面的定义模板和参数, 直接看一个最简单的例子:

1 2 3 4 5 6 7 8

add_one = lambda x:x+1       # 1个参数，执行操作为+1 add_nums = lambda x,y:x+y    # 2个参数，执行操作为相加 print(add_one(2))            # 调用add_one print(add_nums(3,7))         # 调用add_nums >>>   3       10

相比大家已经发现lambda匿名函数的特点了，就是对于较为简单的功能，无需自己def一个了，单行就可以写下，传参和执行方法一气呵成

ambda用法详解

接下来让我们看看lambda的实际应用，就我自己使用lambda的体验来说，从来没有单独用过，lambda一般情况下是和map，filter，reduce这些超棒的内置函数以及dict，list,tuple,set 等数据结构混用，这样才能发挥它的最大效果.

好了，闲话少说，下面让我们一个个来看

lambda + map

首先出场的是lambda+map的组合，先看下面这个例子：

1 2 3 4 5 6 7 8

numbers = [1,2,3,4,5] add_one = list(map(lambda n:n+1,numbers))  #map(fun,sequence) print(list(add_one)) print(tuple(add_one)) Out: [2, 3, 4, 5, 6]      (2, 3, 4, 5, 6)

这个是我们上一期的例子，实现一个数组（元组）每个元素+1，让我们回忆一下map的用法map(fun,sequence)，fun是传递的方法，sequence是一个可迭代的序列，这里我们的fun就是匿名函数
lambda n:n+1，这里非常完美的解释了lambda的设计初衷，因为如果没有lambda，我们的解决方案是这样:

1 2 3 4 5 6 7

def add(num):     return num+1 numbers = [1,2,3,4,5] add_one = list(map(add,numbers)) print(add_one) print(tuple(add_one))

显然易见，这里的add方法有点多余，所以用lambda代替是个好的选择。让我们再看下一个例子,这是我自己备份日志时写的一小段代码,命名不是很规范：

1 2 3 4 5 6 7

from datetime import datetime as dt logs = ['serverLog','appLog','paymentLog'] format ='_{}.py'.format(dt.now().strftime('%d-%m-%y')) result =list(map(lambda x:x+format,logs))   # 利用map+lambda 实现字符串拼接 print(result) Out:['serverLog_11-02-19.py', 'appLog_11-02-19.py', 'paymentLog_11-02-19.py']

这里和刚才的加1例子差不多，但是换成了字符串的拼接，然而我这里用lambda并不是很好的解决方案，最后我们会说，现在大家应该对map + lambda 有一些感觉了，让我们再来个和dict字典互动的例子：

1 2 3 4 5 6 7 8 9

person =[{'name':'Lilei',           'city':'beijing'},          {'name':'HanMeiMei',           'city':'shanghai'}] names=list(map(lambda x:x['name'],person)) print(names) Out：['Lilei', 'HanMeiMei']

好了，看到这里对于map+lambda的用法大家已经很清楚了应该~

lambda + filter

lambda和filter的组合也很常见，用于特定筛选条件下，现在让我们来看上篇文章filter的例子，就应该很好理解了：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

numbers = [0, 1, 2, -3, 5, -8, 13] # 提取奇数 result = filter(lambda x: x % 2, numbers) print("Odd Numbers are :",list(result)) # 提取偶数 result = filter(lambda x: x % 2 == 0, numbers) print("Even Numbers are :",list(result)) #提取正数 result = filter(lambda x: x>0, numbers) print("Positive Numbers are :",list(result)) Out：Odd Numbers are : [1, -3, 5, 13]      Even Numbers are : [0, 2, -8]      Positive Numbers are : [1, 2, 5, 13]

这里无非就是我们把filter(fun,sequence)里面的fun换成了我们的lambda，只是lambda的函数部分（x%2,x%2==0,x>0）都是可以返回True或者False来判断的，符合fiter的要求，用刚才李雷和韩梅梅的例子也是一个道理：

1 2 3 4 5 6 7 8 9

person =[{'name':'Lilei',           'city':'beijing'},          {'name':'HanMeiMei',           'city':'shanghai'}] names=list(filter(lambda x:x['name']=='Lilei',person)) # 提取李雷的信息 print(names) Out：[{'name': 'Lilei', 'city': 'beijing'}]

lambda + reduce

还是让我们看一下上篇文章的例子：

1 2 3 4 5 6 7 8 9 10

from functools import reduce          # Only Python 3 numbers = [1,2,3,4] result_multiply = reduce((lambda x, y: x * y), numbers) result_add = reduce((lambda x,y: x+y), numbers) print(result_multiply) print(result_add) Out：24      10

这个例子用lambda和reduce的配合实现了list求累积和和累积乘法。
有意思的是这个例子具有两面性，一方面展示了lambda和reduce如何一起使用，另一方面也引出了接下来我想说的重点：lambda真的值得用吗？到底应该怎么用？

避免过度使用lambda

通过上面的例子大家已经看到了lambda的实际应用场景，但是这里我想和大家分享一下我的看法:我认为lambda的缺点略多于优点，应该避免过度使用lambda.

首先，这仅仅是我的个人看法哈，希望大家理解，我为什么这么说呢，首先让我们拿lambda方法和常规def做个对比，我发现lambda和def的主要不同点如下：

• 可以立即传递（无需变量）
• 只需一行代码，简洁（未必高效）
• 可以会自动返回，无需return
• lambda函数没有函数名称

有关优点大家都可以看到，我主要想说一下它的缺点，首先，从真正需求出发，我们在大多数时候是不需要lambda的，因为总可以找到更好的替代方法，现在我们一起看一下刚才lambda+reduce 的例子，我们用lambada实现的结果如下：

1 2 3 4

from functools import reduce          # Only Python 3 numbers = [1,2,3,4] result_multiply = reduce((lambda x, y: x * y), numbers) result_add = reduce((lambda x,y: x+y), numbers)

这里用lambda并没有实现简单高效的目的，因为我们有现成的sum和mul方法可以用：

1 2 3 4 5 6 7 8 9 10 11 12

from functools import reduce from operator import mul numbers = [1,2,3,4] result_add = sum(numbers) result_multiply =reduce(mul,numbers) print(result_add) print(result_multiply) Out: 10      24

结果是一样的，但是显然用sum和mul的方案更加高效。再举个常见的例子说明，假如我们有一个list存储了各种颜色，现在要求把每个颜色首字母大写，如果用lambda写出是这样：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

colors = ['red','purple','green','blue'] result = map(lambda c:c.capitalize(),colors) print(list(result)) Out：['Red', 'Purple', 'Green', 'Blue'] 看着似乎不错，挺简洁的，但是我们有更好的方法： colors = ['red','purple','green','blue'] result = [c.capitalize() for c in colors] print(result) Out：['Red', 'Purple', 'Green', 'Blue'] 用sorted还能处理首字母不规范的情况，连排序都省了： colors = ['Red','purple','Green','blue'] print(sorted(colors,key=str.capitalize)) Out:['blue', 'Green', 'purple', 'Red']

还有一个主要原因就是: lambda函数没有函数名称。所以在代码交接，项目移植的场景中会给团队带来很多困难，多写个函数add_one()没什么坏处，因为大家都很容易理解，知道它是执行+1的功能，但是如果团队里你在自己负责的模块使用了很多lambda，会给其他人理解带来很多麻烦

apply函数

Python中apply函数的格式为：apply(func,*args,**kwargs)

当然，func可以是匿名函数。

用途：当一个函数的参数存在于一个元组或者一个字典中时，用来间接的调用这个函数，并将元组或者字典中的参数按照顺序传递给参数

解析：args是一个包含按照函数所需参数传递的位置参数的一个元组，简单来说，假如A函数的函数位置为 A(a=1,b=2),那么这个元组中就必须严格按照这个参数的位置顺序进行传递(a=3,b=4)，而不能是(b=4,a=3)这样的顺序。kwargs是一个包含关键字参数的字典，而其中args如果不传递，kwargs需要传递，则必须在args的位置留空。

apply的返回值就是函数func函数的返回值。

⭐举例

1 2 3 4 5 6 7

def function(a,b):      print(a,b)  apply(function,('good','better'))  apply(function,(2,3+6))  apply(function,('cai','quan'))  apply(function,('cai',),{'b':'caiquan'})  apply(function,(),{'a':'caiquan','b':'Tom'})

输出结果：

('good', 'better')
(2, 9)
('cai', 'quan')
('cai', 'caiquan')
('caiquan', 'Tom')

对数据进行预处理时，大家使用比较多的是apply函数，apply函数是pandas库中的函数，非常好用的一个函数相当于循环遍历，起到对每一条数据进行处理的效果,函数的参数可能是DataFrame中的行或者列。

说到apply又不得不说lambda函数了，这两个结合来用简直爽的不行。

lambda关键字可以用来创建一个小的匿名函数

示例：

1 2	DataFrame.apply(func, axis=0, broadcast=False, raw=False,                  reduce=None, args=(), *kwds)

第一个参数func是一个函数，需要自己实现，可以使用lambda匿名函数，axis默认值为0，axis为0时，会把一列的数据进行遍历。

1	data[‘cut_review'].apply(lambda x: [i for i in x s if i not in stopwords])

⭐下面的例子是DataFrame中apply的用法

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

#函数应用和映射 import numpy as np import pandas as pd df=pd.DataFrame(np.random.randn(4,3),columns=list('bde'),index=['utah','ohio','texas','oregon']) print(df) """                b         d         e utah   -0.667969  1.974801  0.738890 ohio   -0.896774 -0.790914  0.474183 texas   0.043476  0.890176 -0.662676 oregon  0.701109 -2.238288 -0.154442 """ #将函数应用到由各列或行形成的一维数组上。DataFrame的apply方法可以实现此功能 f=lambda x:x.max()-x.min() #默认情况下会以列为单位，分别对列应用函数 t1=df.apply(f) print(t1) t2=df.apply(f,axis=1) print(t2) """ b    1.597883 d    4.213089 e    1.401566 dtype: float64 utah      2.642770 ohio      1.370957 texas     1.552852 oregon    2.939397 dtype: float64 """ #除标量外，传递给apply的函数还可以返回由多个值组成的Series def f(x):     return pd.Series([x.min(),x.max()],index=['min','max']) t3=df.apply(f) #从运行的结果可以看出，按列调用的顺序，调用函数运行的结果在右边依次追加 print(t3) """             b         d         e min -0.896774 -2.238288 -0.662676 max  0.701109  1.974801  0.738890 """ #元素级的python函数，将函数应用到每一个元素 #将DataFrame中的各个浮点值保留两位小数 f=lambda x: '%.2f'%x t3=df.applymap(f) print(t3) """             b      d      e utah    -0.67   1.97   0.74 ohio    -0.90  -0.79   0.47 texas    0.04   0.89  -0.66 oregon   0.70  -2.24  -0.15 """ #注意，之所以这里用map,是因为Series有一个元素级函数的map方法。而dataframe只有applymap。 t4=df['e'].map(f) print(t4) """ utah     0.74 ohio     0.47 texas   -0.66 oregon  -0.15 """ 对指定列进行操作: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 data=np.arange(0,16).reshape(4,4) data=pd.DataFrame(data,columns=['0','1','2','3']) def f(x):     return x-1 print(data) print(data.ix[:,['1','2']].apply(f))     0   1   2   3 0   0   1   2   3 1   4   5   6   7 2   8   9  10  11 3  12  13  14  15     1   2 0   0   1 1   4   5 2   8   9 3  12  13 对行操作: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 data=np.arange(0,16).reshape(4,4) data=pd.DataFrame(data,columns=['0','1','2','3']) def f(x):     return x-1 print(data) print(data.ix[[0,1],:].apply(f))     0   1   2   3 0   0   1   2   3 1   4   5   6   7 2   8   9  10  11 3  12  13  14  15    0  1  2  3 0 -1  0  1  2 1  3  4  5  6 整体对列操作: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 data=np.arange(0,16).reshape(4,4) data=pd.DataFrame(data,columns=['0','1','2','3']) def f(x):     return x.max() print(data) print(data.apply(f))     0   1   2   3 0   0   1   2   3 1   4   5   6   7 2   8   9  10  11 3  12  13  14  15 0    12 1    13 2    14 3    15 dtype: int64 整体对行操作: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 data=np.arange(0,16).reshape(4,4) data=pd.DataFrame(data,columns=['0','1','2','3']) def f(x):     return x.max() print(data) print(data.apply(f,axis=1))     0   1   2   3 0   0   1   2   3 1   4   5   6   7 2   8   9  10  11 3  12  13  14  15 0     3 1     7 2    11 3    15 dtype: int64

 apply、applymap、map 区别

一、总结

• apply —— 应用在 dataFrame 上，用于对 row 或者 column 进行计算
• applymap —— 应用在 dataFrame 上，元素级别的操作
• map —— python 系统自带函数，应用在 series 上， 元素级别的操作

二、实操对比

构建测试数据框：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

import pandas as pd import numpy as np df = pd.DataFrame(np.random.randint(0, 10, (4, 3)),                   columns=list('abc'),                   index=range(4)) df '''     a   b   c 0   5   4   8 1   7   5   2 2   1   2   2 3   1   6   2 '''

apply 作用在 dataframe 上的一行或者一列上

1 2 3 4 5 6 7 8 9 10 11 12 13

# 默认按列操作 axis=0 # 求每列的最大值、最小值之差 df.apply(lambda x: x.max() - x.min()) # axis=0 # 求每行的最大值、最小值之差 df.apply(lambda x: x.max() - x.min(), axis=1)

applymap 作用在 dataframe 的每一个元素上

1 2 3

# 偶数放大10倍 df.applymap(lambda x: x*10 if x%2 == 0 else x)

map 函数作用在 series 上的每一个元素

1 2 3

# 单独的序列 df['b'].map(lambda x: 1 if x%2 == 0 else 0)

总的来说，要对数据进行应用函数操作时，考虑数据结构是 DataFrame 还是 Series ，再考虑是要按行执行还是按列执行，进行函数的选择。