python中apply函数怎么用 python中apply(lambda)

转载

云端筑梦工匠 2024-01-26 07:22:04

文章标签 python中apply函数怎么用 python 可变长参数 Python 迭代器 文章分类 Python 后端开发

lambda:

提到 Lambda演算，更多时候是与函数式编程纠缠在一起的。这种设计思想讲究抛弃变量和状态，使用纯函数的递归系统来构建程序（个人理解）。虽然函数式编程与 Python 的面向对象背道而驰，但并不妨害 Python 借鉴其中某些有价值的内容。即是说，并不能因为 lambda 的存在就认为 Python 是一门函数式编程语言，它只是因为在某些细节上显得更有效率而被引入的。比如 Python 里用 lambda 来定义匿名函数，并与标题中提到的 apply() 等内建函数一起构建一些程序结构。

匿名函数与标准方式声明的函数区别在于，不需要使用 def 语句，也不需要一个名字来引用它。使用 lambda 语句可以直接得到一个函数对象，它的语法是：

lambda [arg1[,arg2…]]: expression

参数可有可无，冒号后面是一个表达式，函数的作用就是返回这个表达式的值。在 def 语句下等同于：

def func([arg1[,arg2…]]):return expression

可以看到 lambda 函数没有中间状态，也不适合构建过于复杂的函数，因为它的函数体只有一个表达式。所以应用 lambda 的场合更多是构建一些临时的、简单的和无需复用小函数。虽然原则上可以给 lambda 函数起别名，就像下面这样，以备后续引用。但如果你打算重复利用这个函数，干嘛不用 def 语句定义一个标准函数呢，那样功能更多且更易维护。

>>> foo = lambda a,b: a+b
>>> foo(1,2)
3
>>> foo = lambda a,b: a+b
>>> foo(1,2)
3

filter(), map(), reduce()：

apply() 函数因为涉及到可变长参数，并且与这三个函数的作用不同，因此放到最后。filter(), map(), reduce() 这三个内建函数的功能属于一类，都是处理可迭代对象，然后返回结果。

filter(function or None, iterable) --> filter object 的功能就和它的名字一样，使用可迭代对象 iterable 中的每一个元素作为参数来调用布尔函数 function，并将所有返回 True 的元素放在一个迭代器中返回。如果 function 为 None，则将 iterable 中值为 True 的元素返回。例：

>>> a = filter(lambda x:x>2,[1,2,3,4])
>>> type(a)
<class 'filter'>
>>> for i in a:print(i)

3
4
>>>
>>> a = filter(lambda x:x>2,[1,2,3,4])
>>> type(a)
<class 'filter'>
>>> for i in a:print(i)

3
4
>>>

在以前的版本中 filter() 函数返回的是一个列表，但 Python3 改为了返回一个迭代器，所以上面的例子使用了 for 语句来显示结果。另外返回迭代器的一个注意点就是：上例中的 a 中的元素并不是在赋值的时候一次性生成的，因此如果使用 iterable 的元素调用 function 会产生异常的话，那么该异常实际会在 for 循环中被抛出。可以看到在这种“过滤元素”的应用环境中，我们需要的函数形式非常简单，只有一条表达式，所以使用 lambda 是个不错的选择。（实际下面的两个函数也是一样）

map(func, *iterables) --> map object 的功能是将函数 func 作用于 iterable 的每一个元素，并将结果用迭代器返回。注意这里可以提供多个 iterable，如果这样做，调用 func 的时候就会从每个 iterable 中依次取一个元素，直到最短的 iterable 耗尽。所以这里 func 的参数个数应该等于 iterable 的个数。

>>> a = map(lambda x,y:x+y,[1,2,3],[3,2,1])
>>> type(a)
<class 'map'>
>>> for i in a:print(i)

4
4
4
>>> a = map(lambda x,y:x+y,[1,2,3],[3,2,1])
>>> type(a)
<class 'map'>
>>> for i in a:print(i)

4
4
4

reduce(function, sequence[, initial]) –> value 的功能是：function 接受两个参数，第一个是 initial，第二个是 sequence 的第一个元素。如果没有提供 initial ，那么就取前两个 sequence 的元素。然后这次调用的返回值再作为第一个参数传递给 function，第二个参数则是 sequence 的下一个元素。这样循环直到 sequence 耗尽，并将最终的值返回。因为 reduce() 函数在 Python3 中已经不是内建函数了，想要使用的话需要 from functools import reduce，所以这里就不举例了。

实际上不只 reduce，这三个函数在现在的版本中都可以说已经没什么用了。filter() 和 map() 都可以由列表解析（生成器表达式）取代，而且明显列表解析更高级好用。所以一般知道这几个函数是干吗用的就够了，基本没必要去实际使用他们。不过下面用来取代 map() 的列表解析示例貌似只能用于单容器的状况，多容器的比如上面那个 map() 的例子该怎么写我想不出。。。

>>> [x for x in [1,2,3,4] if x>2]# filter
[3, 4]
>>> [x+1 for x in [1,2,3]]# map
[2, 3, 4]
>>> [x for x in [1,2,3,4] if x>2]# filter
[3, 4]
>>> [x+1 for x in [1,2,3]]# map
[2, 3, 4]

apply() 比 reduce() 还惨，在 functools 里都已经不存在了。这是因为早在 1.6 版本他就已经失去作用。我们这里还要提它，仅是为了引出下面的话题：可变长参数。其实在 1.6 以前，函数还不支持可变长参数，而 apply() 就是干这个用的，他可以使用可变长参数来调用函数。

可变长参数：

可变长参数的意思就是：我在调用函数的时候不知道要传多少个参数进来，可能没有，也可能 100 多个。比如一张电子账单，算总额的时候谁知道会有多少项呢。类似这种问题虽然有很多种其他方法把金额加到一起，但使用单一函数来实现总能收获到多余的好处。而且虽然用一个元组也可以实现变长参数的功能，但接下来介绍的方式能做的更好。定义一个函数时可使用的形参完全体如下：

def func(positional_args, keyword_args, *tuple_grp_nonkw_args, **dict_grp_kw_args):

这四种参数形式都是独立可选的。前两个不表，后面带个 * 和带 ** 的就是变长参数了。在位置上，带 * 的必须放在不带 * 的后面，否则会报错。举个栗子，operator 模块里有个 add() 函数：

add(a, b) -- Same as a + b.

该函数只接受两个参数，如果使用可变长参数的话，我们就能让它接受无限个参数并返回他们的和：

>>> def add(*args):
	result = 0
	for num in args:
		result += num
	return result

>>> add(1,2,3,4)
10
>>> add(*(1,2,3,4))
10
>>> add(1,2,*(3,4))
10
>>> def add(*args):
	result = 0
	for num in args:
		result += num
	return result

>>> add(1,2,3,4)
10
>>> add(*(1,2,3,4))
10
>>> add(1,2,*(3,4))
10

从上面的例子可以看出 *tuple_grp_nonkw_args 的作用。只要你的形参里有 *args 这种设定，函数就自动变得对非关键字参数来者不拒。并把接收到的所有参数统一放在一个元组里。

不过这个函数较 operator 里的 add() 有个不足之处，就是那个 add() 除了加数字，还能连接字符串，而我们定义的这个就只能处理数字。于是，接下来就要把位置参数（positional_args）和可变长非关键字参数（*tuple_grp_nonkw_args）一起用了，这也是能体现他们之间联系的一个例子：

>>> def add(first,*args):
	result = first
	checked = type(first)
	for item in [x for x in args if type(x)==checked]:
		result += item
	return result

>>> add(1,2,3,4)
10
>>> add('1','2','3','4')
'1234'
>>> add(1,2,'3','4')
3
>>> add(*(1,2,3,4))
10
>>> def add(first,*args):
	result = first
	checked = type(first)
	for item in [x for x in args if type(x)==checked]:
		result += item
	return result

>>> add(1,2,3,4)
10
>>> add('1','2','3','4')
'1234'
>>> add(1,2,'3','4')
3
>>> add(*(1,2,3,4))
10

这里我们从 *args 里独立出来了一个非关键字参数，并把它命名为 first，再之后的参数只有和 first 同类型的才会加在一起。可以看到这时的 *args 自动让出了第一个参数给 first，而只包含剩余的参数，不论你是单独传入第一个参数，还是用 *（）的方式一股脑传入，函数内部对待他们的方式都是一样的。