一、匿名函数

# 语法:
# 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所有数的和