Python常用内置函数整理（lambda，reduce，zip，filter，map）

Posted 2020-10-12

匿名函数lambda

lambda argument1,argument2,...argumentN :expression using arguments

1、lambda是一个表达式，而不是一个语句。

因为这一点，lambda可以出现在python语法不允许def出现的地方---例如，在一个列表常量中或者函数调用的参数中。

2、lambda 的主体是一个单个的表达式，而不是一个代码块。

lambda是一个为编写简单的函数设计的，而def用来处理更大的任务。

例如：

lambda表示式写法：
f=lambda x,y,z:x+y+z

print(f(2,3,4))

打印结果：
9

函数写法：

def f(x,y,z):
    return x+y+z

print(f(2,3,4))

打印结果：
9

 

lambda表示式写法：
foo=lambda a=‘lll‘,b=‘que‘,c=‘rade‘:a+b+c

print(foo(‘mas‘))
打印结果：
masquerade

函数写法：

def foo(a=‘lll‘,b=‘que‘,c=‘rade‘):
    return a+b+c

print(foo(‘mas‘))

打印结果：
masquerade

 

l=[lambda x:x**2,lambda x:x**3,lambda x:x**4]
for f in l:
    print(f(2))
打印结果：
4
8
16

print(l[1](3)) 
打印结果：
27

 嵌套的lambda

式一：
def foo(x):
    return (lambda y:x+y)

bar=foo(99)
print(bar(2))

打印结果：101

式二：
foo=lambda x:(lambda y:x+y)
bar=foo(99)
print(bar(2))

式三：

print((lambda x:(lambda y:x+y)(99))(2))
打印结果：
101

 

 

filter函数

filter函数会对指定序列执行过滤操作。

定义：filter(function or None, sequence) ->iterator

filter函数会对序列参数sequence中的每个元素调用function函数，最后返回的结果包含调用结果为True的元素。

返回可迭代对象，需要list调用来显示所有结果。

def f(x):
    if x>20:
        return True
    else:
        return False

l1=[2,8,15,22,36]
print(filter(f,l1))
l2=filter(f,l1)
print(l2.__next__())    #22
print(l2.__next__())    #36
print(l2.__next__())    #StopIteration

#或者我们可以使用for循环遍历过滤器l2：
 for i in l2:
     print(i)

打印结果：
22
36

 

print(list(filter(lambda x:x>0,range(-5,5))))    #[1, 2, 3, 4]

print(list(filter(None,[1,2,3,4,5])))   #[1, 2, 3, 4, 5]

 

map（func,iter1,iter2）函数-> iterator

通过定义可以看到，这个函数的第一个参数是一个函数，剩下的参数是一个或多个序列，返回值是一个迭代器。

function可以理解为是一个一对一或多对一函数，map的作用是以参数序列中的每一个元素调用function函数，返回包含每次function函数返回值的迭代器。

返回可迭代对象，需要调用list来显示所有结果。

def f(x,y):
    return (x,y)
l1 = [ 0, 1, 2, 3, 4, 5, 6 ]
l2 = [ ‘Sun‘, ‘M‘, ‘T‘, ‘W‘, ‘T‘, ‘F‘, ‘S‘ ]
l3=map(f,l1,l2)
# print(l3)   #<map object at 0x0000000002301470>
print(list(l3)) #[(0, ‘Sun‘), (1, ‘M‘), (2, ‘T‘), (3, ‘W‘), (4, ‘T‘), (5, ‘F‘), (6, ‘S‘)]

def f2(x):
    return x**2
print(list(map(f2,l1)))  #[0, 1, 4, 9, 16, 25, 36]

def f3(x,y):
    return x*2,y*2

print(list(map(f3,l1,l2)))  #[(0, ‘SunSun‘), (2, ‘MM‘), (4, ‘TT‘), (6, ‘WW‘), (8, ‘TT‘), (10, ‘FF‘), (12, ‘SS‘)]

 

print(list(map(lambda x: x + 2, [1, 2, 3])))    #[3, 4, 5]
print(list(map(pow,[1,2,3],[2,3,4])))           #[1, 8, 81]
#pow(x,y)是计算x的y次幂（方）

 

reduce函数

在Python 3里,reduce()函数已经被从全局名字空间里移除了,它现在被放置在fucntools模块里,用的话要先引入:即functools.reduce(function,sequence,initial)

reduce函数会对参数序列中元素进行累积。

定义：

function参数是一个有两个参数的函数，reduce依次从iterable中取一个元素，和上一次调用function的结果做参数再次调用function。

第一次调用function时，如果提供initial参数，会以iterable中的第一个元素和initial作为参数调用function，否则会以iterable中的前两个元素做参数调用function。

 等价于：

def reduce(function, iterable, initializer=None):

it = iter(iterable)

    if initializer is None:

        value = next(it)

    else:

        value = initializer

    for element in it:

        value = function(value, element)

return value

示例：

import functools

print(functools.reduce(lambda x,y:x+y,[1,2,3,4]))       #10
print(functools.reduce(lambda x,y:x+y,[1,2,3,4],10))    #20
print(functools.reduce(lambda x,y:x*y,[1,2,3,4]))       #24

##############
如果没有initial参数，这么算：（（（1+2）+3）+4）

如果有initial参数，这么算： （（（（10+1）+2）+3）+4）

 注意：function函数不能为None，function必须是有2个参数的函数。

 

zip函数

定义：zip([seql, ...])接受一系列可迭代对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）。若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同。

print(list(zip([1,2,3],[11,22,33])))    #两个列表长度一致

#[(1, 11), (2, 22), (3, 33)]

print(list(zip([1,2,3],[11,22,33,44,55])))  #两个列表长度不一致，以短的为准

#[(1, 11), (2, 22), (3, 33)]