一、函数式编程

• 定义：用一系列函数解决问题。

函数可以赋值给变量，赋值后变量绑定函数。

允许将函数作为参数传入另一个函数。

允许函数返回一个函数。

• 高阶函数：将函数作为参数或返回值的函数。

1、函数作为参数

将核心逻辑传入方法体，使该方法的适用性更广，体现了面向对象的开闭原则。

基础案例1

1 def fun01():
 2   print("fun01执行执行喽")
 3 
 4 # 有小括号,是调函数,a变量得到是函数返回值
 5 # a = fun01()
 6 # 没小括号,没调函数,a变量得到是函数地址
 7 a = fun01
 8 # 通过变量a,调用函数fun01.
 9 a()
10 #fun01执行执行喽

基础案例2

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 = 函数):根据函数获取可迭代对象的最小值。

6、函数作为返回值

逻辑连续，当内部函数被调用时，不脱离当前的逻辑。

四、闭包

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、装饰器链

一个函数可以被多个装饰器修饰，执行顺序为从近到远。

基础案例

 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