🍖匿名函数

引入

1.编程范式

• 编程范式指的是编程的套路
• 主要的套路有三种 : 命令式编程, 函数式编程, 逻辑式编程
• 常见的面向对象就是命令式编程, 常见的面向过程就是逻辑式编程

2.函数式

• 什么是函数式

🍋函数式编程中的函数指的并非编程语言中的函数（或方法）
🍋它指的是数学意义上的函数，即映射关系（如：y = f(x)），就是 y 和 x 的对应关系

• 函数式与逻辑式

🍋比起逻辑式, 函数式更加注重的是执行结果并不是执行的过程

• Python提供的函数式编程特性

🍋Python并非一门函数式的编程语言,但却提供了不少函数式编程的特性
🍋好比 : lambda, max, min, map, reduce, filter

一.匿名函数

1.什么是匿名函数

• 没有名字的函数

2.应用场景

• 临时用一次, 一般用于与其余函数配合使用

3.匿名函数的强调点

• 匿名函数的目的就是要没有名字, 给匿名函数赋值一个名字是没有意义的
• 匿名函数的参数规则, 做用域关系与有名函数是同样的
• 匿名函数的函数体一般应该是一个表达式, 该表达式必须要有一个返回值

4.匿名函数与有名函数的对比

• 有名函数

🍋有函数名,循环使用,保存了名字,经过名字就能够重复引用函数
def foo(x,y):
    return x**y
foo(2,3)  # 8

• 匿名函数

🍋没有函数名,一次性使用,随时随地定义
f = lambda x,y:x ** y
print(f(2,4))  # 16
# 通常配合应用 : max, min, sorted, map, reduce, filter

5.匿名函数的调用方式

• 方式一 : 直接加括号执行

res = (lambda x, y: x + y)(7,8)
print(res)  # 15

• 方式二 : 给函数指定名字

f = lambda x,y:x ** y
print(f(2,4))  # 16
🍋匿名函数的本质就是没有名字,这里指定名字是没有意义的(匿名函数只用于临时调用一次)
🍋匿名函数通常用来与其余函数配合使用,如下来展开介绍

二.匿名函数的应用

1.max( ) : 最大值

• 接收两个参数 : ([可迭代对象],[函数])

2.min( ) : 最小值

• 接收两个参数 : ([可迭代对象],[函数])

3.sorted( ) : 排序

• 接收三个参数 : ([可迭代对象],[函数],[排列顺序])

• 若是传入的可迭代对象是字典, 默认是按照字典的 "key" 来进行排序的

  • sorted 函数会迭代可迭代对象中的每一个元素, 把迭代后获得的值依次传给匿名函数
  • 若是是字典，那么迭代之后传给字典的就是 key, 最终，以匿名函数的返回值做为比较依据
  • 好比传入的是字典, 默认迭代的就是字典的 key, 那么返回的只就是字典的 key, 虽然你是用 value来进行比较的

• reverse参数 : "False"表明从小到大, "True"表明的是从大到小

🍋以每一个人的薪资来作比较
salaries = {
    'song' : 1000,
    'hai' : 10000,
    'xing' : 100000,
    'shawn' : 1000000,
}

🍋"max"接收两个参数([可迭代对象],[函数]),函数循环取的是"salaries[k]",而后进行比较,返回的是"key"
print(max(salaries,key=lambda k:salaries[k]))    # shawn

🍋"min"接收两个参数([可迭代对象],[函数]),函数循环取的是"salaries[k]",而后进行比较,返回的是"key"
print(min(salaries,key=lambda k:salaries[k]))    # song

🍋"sorted"接收三个参数([可迭代对象],[函数],[排列顺序]),函数循环取的是"salaries[k]",而后进行排序,默认排序从小到大
print(sorted(salaries,key=lambda k:salaries[k]))  # ['song', 'hai', 'xing', 'shawn']

🍋排序加上顺序参数"reverse","False"表明从小到大,"True"表明的是从大到小
print(sorted(salaries,key=lambda k:salaries[k],reverse=True))  # ['shawn', 'xing', 'hai', 'song']

4.map( ) : 映射

• 接收两个参数 : ([函数],[可迭代对象])
• 运行原理 : map 函数遍历可迭代对象中的每一个元素, 把遍历获得的值当作参数传给匿名函数, 以返回值的处理结果当作返回值返回
• map 获得的结果是迭代器对象

🍋将"nums"里面的只都进行平方计算
nums = [1,2,3,4,5,6,7]

res = map(lambda x:x**2,nums)
print(res.__next__())  # 这是迭代器对象的一个方法,每次 next 都取出一个值(说明了获得的结果是一个迭代器)
print(list(res))       # [1, 4, 9, 16, 25, 36, 49]

🍋生成器表达式来替代"map"
nums = [1,2,3,4,5,6,7]

res = (i ** 2 for i in nums)
print(res)  # 获得的是一个生成器 <generator object <genexpr> at 0x0000015FD8EDAAC8>
print(res.__next__())  # 1
print(res.__next__())  # 4
print(res.__next__())  # 9
print(res.__next__())  # 16
...

🍋需求 : "song"加上"_hp"结尾,其余的加上"_np"结尾
names = ["song","hai","xing","shawn"]

res = map(lambda i:i+"_hp" if i == "song" else i + "_np", names)  # 三元表达式
print(res)       # 迭代器对象  <map object at 0x000001A1C34DFBC8>
print(list(res)) # ['song_hp', 'hai_np', 'xing_np', 'shawn_np']

5.reduce( ) : 合并

• 接收三个参数 : ([函数],[可迭代对象],[初始值])

• **reduce **在python2中是内置函数, 在python3中被集成到模块 functools 中, 须要导入使用

• 运行原理 : 以初始值做为第一个参数传给 x , 而后迭代传入的可迭代对象, 拿到的值 y 与 x 相加剧新赋值给 x , 再次迭代取值, 周而复始, 直到迭代器被迭代完

🍋需求 : 求和
from functools import reduce

res1 = reduce(lambda x,y: x + y , range(1,10),0)  # 从 0 开始,迭代相加(9)次
res2 = reduce(lambda x,y: x + y , range(1,10),1)  # 从 1 开始,迭代相加(9)次
res3 = reduce(lambda x,y: x + y , range(1,100))   # 不写初始值默认就是 0
print(res1)  # 0+1+2+3+4+5+6+7+8+9=45
print(res2)  # 1+1+2+3+4+5+6+7+8+9=46
print(res3)  # 45

🍋列表求和
array = [1, 4, 9, 16, 25]

res = reduce(lambda x, y: x + y, array)
print(res)  # 55

6.filten( ) : 过滤

• 接收两个参数 : ([函数],[可迭代对象])
• 遍历可迭代对象, 过滤出结果为真的元素, 若是是字典, 最终返回的结果是字典的 key
• filten 返回的结果是迭代器

🍋需求 : 返回以"_sb"结尾的元素
names = ['song', 'hai_sb', 'xing','shi_sb','nb_sb']

res = filter(lambda x:True if x.endswith('sb') else False,names)  #三元表达式
res = filter(lambda x:x.endswith('sb'),names)
print(res)         # <filter object at 0x000001445164FC08>
print(list(res))   # ['hai_sb', 'shi_sb', 'nb_sb']

🍋过滤大于或等于 23 的数
l = [12,23,45,10,25,58,47,69]
res = filter(lambda x:x >= 23,l)
print(res)        # <filter object at 0x00000227F5510708>
print(list(res))  # [23, 45, 25, 58, 47, 69]

🍋过滤薪资大于 30000 的小伙
salaries = {
    'song' : 1000,
    'hai' : 10000,
    'xing' : 100000,
    'shawn' : 1000000,
}

res = filter(lambda k:salaries[k] >30000 ,salaries)
print(res)       # <filter object at 0x000001CFC1138F48>
print(list(res)  # ['xing', 'shawn']