函数式编程
1. 定义：用一系列函数解决问题。
-- 函数可以赋值给变量，赋值后变量绑定函数。
-- 允许将函数作为参数传入另一个函数。
-- 允许函数返回一个函数。
2. 高阶函数：将函数作为参数或返回值的函数。
函数作为参数
将核心逻辑传入方法体，使该方法的适用性更广，体现了面向对象的开闭原则。
1 def fun01(): 2 print("fun01执行执行喽") 3 4 # 有小括号,是调函数,a变量得到是函数返回值 5 # a = fun01() 6 # 没小括号,没调函数,a变量得到是函数地址 7 a = fun01 8 # 通过变量a,调用函数fun01. 9 a() 10 #fun01执行执行喽
1 def fun03(): 2 print("fun03执行执行喽") 3 4 def fun04():# 定义很多具体函数 [封装] 5 print("fun04执行执行喽") 6 7 # func 代表(抽象) fun03 fun04 [继承] 8 def fun02(func): 9 print("fun02的逻辑") 10 func()# 调用func执行.... [多态] 11 12 fun02(fun03) 13 #fun02的逻辑 14 #fun03执行执行喽 15 fun02(fun04) 16 #fun02的逻辑 17 #fun04执行执行喽
lambda 表达式
1.定义：是一种匿名方法。
2.作用：作为参数传递时语法简洁，优雅，代码可读性强。
3.语法
-- 定义：
变量 = lambda 形参: 方法体
-- 调用：
变量(实参)
4.说明：
-- 形参没有可以不填
-- 方法体只能有一条语句，方法体必须有返回值，且不支持赋值语句。
lambda 表达式
匿名方法
lambda 参数列表: 方法体
普通方法
def 方法名称(参数列表):
方法体
相对与普通方法的优缺点:
优点:省略方法名称，随时创建和销毁，降低了程序间耦合度
缺点:由于没有名称,所以不能重复使用.
1 list01 = [4,5,6,7,89] 2 def find(list_targt, func): 3 for item in list_targt: 4 if func(item): 5 yield item 6 #普通方法 7 def condition01(item): 8 return item % 2 == 0 9 for item in find(list01, condition01): 10 print(item) 11 12 # 使用 lambda 代替普通方法 13 for item in find(list01, lambda item:item % 2 == 0): 14 print(item)
内置高阶函数
1.map（函数，可迭代对象）：使用可迭代对象中的每个元素调用函数，将返回值作为新可迭代对象元素；返回值为新可迭代对象。
2.filter(函数，可迭代对象)：根据条件筛选可迭代对象中的元素，返回值为新可迭代对象。
3.sorted(可迭代对象，key = 函数,reverse = bool值)：排序，返回值为排序结果。
4.max(可迭代对象，key = 函数)：根据函数获取可迭代对象的最大值。
5.min(可迭代对象，key = 函数)：根据函数获取可迭代对象的最小值。
函数作为返回值
逻辑连续，当内部函数被调用时，不脱离当前的逻辑。
闭包
1.三要素：
-- 必须有一个内嵌函数。
-- 内嵌函数必须引用外部函数中变量。
-- 外部函数返回值必须是内嵌函数。
2.语法
-- 定义：
def 外部函数名(参数):
外部变量
def 内部函数名(参数):
使用外部变量
return 内部函数名
-- 调用：
变量 = 外部函数名(参数)
变量(参数)
1 def fun01(): 2 a = 1 # 对于fun02 而言,属于外部嵌套作用域 3 4 def fun02(): 5 print(a) 6 7 return fun02 8 9 # 闭包: 10 # 内部函数可以使用外部嵌套变量,外部函数执行完毕后, 11 # 没有释放内存,而是等待内部函数执行结束. 12 func = fun01()# 调用外部函数 13 func()# 再调用内部函数
1 def give_gife_money(money): 2 """ 3 获取压岁钱 4 """ 5 print("得到压岁钱:",money) 6 def child_buy(target,price): 7 """ 8 孩子需要买东西 9 """ 10 nonlocal money 11 if money >= price: 12 money -= price 13 print("孩子需要花%d钱,买%s"%(price,target)) 14 else: 15 print("钱不够") 16 # 希望外部可以调用内部函数 17 return child_buy 18 19 action_buy = give_gife_money(30000) 20 action_buy("飞机",1000) 21 action_buy("手机",10000) 22 action_buy("房子",10000000) 23 #得到压岁钱: 30000 24 #孩子需要花1000钱,买飞机 25 #孩子需要花10000钱,买手机 26 #钱不够
3.定义：在一个函数内部的函数,同时内部函数又引用了外部函数的变量。
4.本质：闭包是将内部函数和外部函数的执行环境绑定在一起的对象。
5.优点：内部函数可以使用外部变量。
6.缺点：外部变量一直存在于内存中，不会在调用结束后释放，占用内存。
7.作用：实现python装饰器。
函数装饰器decorators
1.定义：在不改变原函数的调用以及内部代码情况下，为其添加新功能的函数。
语法
2.def 函数装饰器名称(func):
def 内嵌函数(*args, **kwargs):
需要添加的新功能
return func(*args, **kwargs)
return wrapper
@ 函数装饰器名称
def 原函数名称(参数):
函数体
原函数(参数)
3.本质：使用“@函数装饰器名称”修饰原函数，等同于创建与原函数名称相同的变量，关联内嵌函数；故调用原函数时执行内嵌函数。
原函数名称 = 函数装饰器名称（原函数名称）
4.装饰器链：
一个函数可以被多个装饰器修饰，执行顺序为从近到远。
1 def print_func_name(func): # 提供旧功能 2 def wrapper(*args, **kwargs): # 包装 3 print(func.__name__) # 新功能 4 return func(*args, **kwargs) # 旧功能 5 6 return wrapper 7 8 9 @print_func_name # say_hello = print_func_name(say_hello) 10 def say_hello(): 11 print("hello") 12 return "ok" 13 14 15 @print_func_name 16 def say_goodbye(name): 17 print(name, "goodbye") 18 19 20 result = say_hello() 21 print(result) 22 say_goodbye("张无忌") 23 #-------------------------------- 24 #say_hello 25 #hello 26 #ok 27 #say_goodbye 28 #张无忌 goodbye