python学习篇之【匿名函数、filter、map、reduce 函数用法】

一、匿名函数

# 语法:
# lanbda x : x + 1
# x      函数的形参
# x + 1  函数的返回值 = return
# 通常与其他函数联合使用,不应该独立存在

# 普通函数写法:
def calc(x):
    return x+1
print(calc(2))

# 匿名写法(理解版):
func = lambda x: x + 1
res = func(2)
print(res)


# 需求 把 name = 'alex'修改成 alex_sb
name = 'alex'
func = lambda a: str(a) +"_sb"
test = func(name)
print(test)

# lambda 多个返回值,需要加括号
a = 1
b = 2
c = 3
fun = lambda x,y,z:(x+1,y+1,z+1)
res = fun(a,b,c)
print(res)

 

二、map函数

1、map() 加工序列:

依次处理序列中的每一个元素,得到的结果是一个"列表",该"列表"元素个数及位置与原来一样。

#1、功能:
  map() :会根据提供的函数,对指定序列做映射。
  第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回
包含每次 function 函数返回值的新列表。

#2、语法:
map(function, iterable)
function -- 函数
iterable -- 一个或多个序列(可迭代对象)

#3、示例:

li1 = [0,1,2,3,4,5]
li2 = ['a','b','c','d']

def calc(num):
    #'传入int类型,每个元素 + 1'
    return num + 1
# 1、可自定义函数实现,第一个参数传入函数,第二个传入可迭代序列
# 注意定义后的函数,只传入函数名,不需要加括号。最终返回值需要 使用 list
# 或者其他数据类型进行转换,在python2中,会自动把结果输出成列表。
res1 = list(map(calc,li1))    

# 2、可使用匿名函数做逻辑。
res2 = list(map(lambda x:x.upper(),li2))
print(res1)
print(res2)

# map实际上做的操作如下:(个人理解版)

test = [0,1,2,3,4,5]
def func_cover(iterb):     #使用函数自定义一个元素自增1的功能
    #自增1
    return iterb + 1
def map_cover(func,iterb):   #定义两个参数,func 为功能,iterb 为可迭代对象
    li = []
    for item in iterb:   #使用for 循环拿取传入的可迭代对象
        res = func(item) #使用自定义的功能 改造每次传入过来的迭代的元素,(这句最重要)
        li.append(res)   #把转换完成后的元素插入li列表中
    return li            #返回值 定义为转换完成的新列表
print(map_cover(func_cover,test))
print(map_cover(lambda x:x * 2,test)) 

 

三、filter函数

遍历序列中的每个元素,判断每个元素得到的布尔值,如果是true 则留下来。
#内置函数:filter() 
#1、功能:
  filter() 用于 过滤序列
  作用是:过滤掉不符合条件的元素,返回一个迭代器对象,如果要转换为列表,可以使
用 list() 来转换。该接收两个参数,第一个为函数,第二个为序列序列的每个元素作为
参数传递给函数进行判断,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。

#2、语法
filter(function, iterable)

#3、参数:
function -- 判断函数。
iterable -- 可迭代对象

#4、示例:
# 迭代判断,判断结果为 True 的话,取出来放到新列表中,反之不放。

li1 = [1,2,3,4,5]
li2 = ['a_a','a_b','cc','a_d','ee']
li3 = [1,2,3,4,5,'a_a','a_b','cc','a_d','ee']
# 1、奇数判定   不能被 2 整除的拿出来
filist1 = list(filter(lambda x:not x%2 == 0,li1))
print(filist1)
# 2、取出开头为 a 的元素
filist2= list(filter(lambda x:x.startswith('a'),li2))
print(filist2)

#5、其他玩法:
people = [
    {'name':'欧阳锋','age':1000},
    {'name':'郭靖','age':10000},
    {'name':'黄蓉','age':9000},
    {'name':'洪七公','age':18},
]
res = list(filter(lambda x:x['age'] <= 18,people)) #小于等于18的筛选出来
print(res)

 

四、reduce函数

处理一个序列,然后把序列进行合并操作
内置函数:reduce()
  注意:Python3.x reduce() 已经被移到 functools 模块里,如果我们要使用
需要引入 functools 模块来调用 reduce() 函数,调用方法如下:

from functools import reduce

#1、功能:
  reduce() 函数会对参数序列中元素进行累积,用 function 函数运算,最后得到一个结果
  
  函数将一个数据集合(链表,元组等)中的所有数据进行下列操作:用传给 reduce 中
的函数 function(有两个参数)先对集合中的第 1、2 个元素进行操作,得到的结果再与
第三个数据用 function 函数运算,最后得到一个结果。

#2、语法:

    reduce(function, iterable[, initializer])
    
#3、参数

    function -- 函数,有两个参数
    iterable -- 可迭代对象
    initializer -- 可选,初始参数

# 4、返回值

    返回函数计算结果。

# from funnctools import reduce
# 在python2中可以直接用,python3中需要 如上调用。

# 3、示例:使用高阶函数来完成reduce功能(个人理解版)

li = [1,2,3,100]
def add_test(x,y):
    return x+y

def reduce_test(func,iterb,init=None): # 默认init 等于空,增加起始值功能
    if init is None:        #判断执行函数时是否传入,默认参数
        res = iterb.pop(0)  #如果没传,使用pop 拿到序列第一位的值 作为起始值 
    else:
        res = init          #如果传入,起始值为 init
    for item in iterb:      #判断完成后,循环传入的序列
        res = func(res,item)#把得到的res 与 item 使用传入的功能进行加工
    return res              #返回加工后的 值

res1 = reduce_test(add_test,li)  #使用函数自定义功能
res2 = reduce_test(lambda x,y:x*y,li,10) #使用lambda自定义功能,并初始值为10
print(res1)
print(res2)

# 4、使用reduce来完成:

from functools import reduce

def add_test(x,y):           #使用函数定义一个序列每个元素相加功能。
    return x+y

li = [1,2,3,100]   #注意,reduce得到的值为序列累加的和,所以不需要将输出结果
                   #转化为列表,如:res1 = reduce(add_test,li,10)
res1 = reduce(add_test,li,10)   #使用自定义函数,并将初始值设置为 10
res2 = reduce(lambda x,y:x*y,li)# 使用lambda函数定义 序列每个元素累计相乘功能。

print(res1)  
print(res2)

# 5、其他玩法 配合 range
from functools import reduce

print(reduce(lambda x,y:x+y,range(100),1)) # 99以内的数累加,起始值 为 1
print(reduce(lambda x,y:x+y,range(1,101))) # 1-100所有数的和

 

上一篇:java8 lambda表达式 if else 策略模式优化


下一篇:Spark