函数式编程

函数式编程

定义

用一系列函数解决问题

• 函数可以赋值给变量，赋值后变量绑定函数
• 允许将函数作为参数传入另一个函数
• 允许函数返回一个函数

语法

# 函数式编程 -- 语法
def fun01():
    print("hello world")
def fun02(func):
    print(""人生苦短，我用python"")
    func()
# 理论支柱1:将函数赋值给变量
a = fun01
a()
# 理论支柱2:允许将函数作为参数传入另一个函数
fun02(fun01)

应用

list01 = [3, 4, "a", 6, "b", 8, 98, ]
# 需求1:定义函数,获取列表中所有字符串
def find01():
    for item in list01:
        if type(item) == str:
            yield item
# 需求2:定义函数,获取列表中所有大于10的整数
def find02():
    for item in list01:
        if type(item) == int and item > 10:
            yield item
# "封装" -- 分 -- 提取变化
def condition01(item):
    return type(item) == str
def condition02(item):
    return type(item) == int and item > 10
# "继承" -- 隔(抽象->统一) -- 提取共性
# 万能查找函数
def find(target, func):
    for item in target:
        if func(item):
            yield item
# "多态" -- 做 -- 重写
for item in find(list01, condition01):
    print(item)	

高阶函数

将函数作为参数或返回值的函数

函数作为参数

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

lambda 表达式

1. 定义：是一种匿名函数
2. 作用：
   作为参数传递时语法简洁，优雅，代码可读性强
   随时创建和销毁，减少程序耦合度
3. 语法
   变量 = lambda 形参: 方法体
4. 调用：变量(实参)
5. 说明：
   形参没有可以不填
   方法体只能有一条语句，且不支持赋值语句

内置高阶函数

1. map(函数，可迭代对象)：映射，使用可迭代对象中的每个元素调用函数，将返回值作为新可迭代对象元素；返回值为新可迭代对象
2. filter(函数，可迭代对象)：过滤，根据条件筛选可迭代对象中的元素，返回值为新可迭代对象

   for item in filter(lambda element: element > 5, list01):
       print(item)
   

3. sorted(可迭代对象，key = 函数，reverse = bool值)：排序，返回值为排序结果
4. max(可迭代对象，key = 函数)：根据函数获取可迭代对象的最大值
5. min(可迭代对象，key = 函数)：根据函数获取可迭代对象的最小值

函数作为返回值

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

闭包

1. 三要素：
   必须有一个内嵌函数
   内嵌函数必须引用外部函数中变量
   外部函数返回值必须是内嵌函数
2. 语法

   def 外部函数名(参数):
   	外部变量
   	def 内部函数名(参数):
   		使用外部变量
   return 内部函数名
   

   def fun01():
   	a =100
   	def fun02():
   		print(a)
   	return fun02
   re = fun01()
   re()
   

3. 调用：
   变量 = 外部函数名(参数)
   变量(参数)
4. 定义：在一个函数内部的函数,同时内部函数又引用了外部函数的变量
5. 本质：闭包是将内部函数和外部函数的执行环境绑定在一起的对象
6. 优点：内部函数可以使用外部变量
7. 缺点：外部变量一直存在于内存中，不会在调用结束后释放，占用内存
8. 作用：实现python装饰器。

函数装饰器decorator

1. 定义：在不改变原函数的调用以及内部代码情况下，为其添加新功能的函数
2. 作用：拦截
3. 语法

   def 函数装饰器名称(func ):
   	def 内嵌函数(*args, **kwargs): 
   		需要添加的新功能
   		return func(*args, **kwargs) 
   	return内嵌函数
   原函数 = 内嵌函数
   @ 函数装饰器名称 # 拦截 = 函数装饰器名称(原函数)
   def 原函数名称(参数):
   	函数体
   原函数(参数)
   

   # 计时装饰器
   import time
   def print_execute_time(func):
       def wrapper(*args, **kwargs):  # 形参--->合
           start_time = time.time()
           re = func(*args, **kwargs)  # 实参--->拆
           stop_time = time.time()
           print("执行时间：", (stop_time-start_time))
           return re
       return wrapper
   

4. 本质：使用“@函数装饰器名称”修饰原函数，等同于创建与原函数名称相同的变量，关联内嵌函数；故调用原函数时执行内嵌函数
   原函数名称 = 函数装饰器名称（原函数名称）
5. 装饰器链：一个函数可以被多个装饰器修饰，执行顺序为从近到远

作用域

变量起作用的范围

局部作用域Local

函数内部

• 定义在函数内部的变量(形参也是局部变量)
• 只能在函数内部使用
• 调用函数时才被创建，函数结束后自动销毁

外部嵌套作用域Enclosing

函数嵌套

全局作用域Global

模块(.py文件)内部

• 定义在函数外部,模块内部的变量
• 在整个模块(.py文件)范围内访问（但函数内不能将其直接赋值）

内置模块作用域Builtin

builtins.py文件

变量名的查找规则

• 由内到外：L -> E -> G -> B
• 在访问变量时，先查找本地变量，然后是包裹此函数外部的函数内部的变量，之后是全局变量，最后是内置变量

相关语句

1. global语句

• 作用：

在函数内部修改全局变量
在函数内部定义全局变量(全局声明)

• 语法：global 变量1, 变量2, …
• 说明:

在函数内直接为全局变量赋值，视为创建新的局部变量
不能先声明局部的变量，再用global声明为全局变量

2. nonlocal 语句 (闭包修饰器)

• 作用：在内层函数修改外层嵌套函数内的变量
• 语法：nonlocal 变量名1,变量名2, …
• 说明：在被嵌套的内函数中进行使用

# 全局变量：在整个文件中可以访问
a = 10
def fun01():
	# 局部变量：只能在函数内部访问
	# 外部嵌套变量
    b = 20
    def fun02():
        c = 30  # 局部变量
        # 在局部作用域中，可以读取全局变量
        # print(a)
        # 可以读取外部嵌套变量
        # print(b)
        
        # 声明全局变量
        global a
        a = 100
        print(a)
        # 声明全局变量(创建全局变量)不建议
        global d
        d = 40
        # 声明外部嵌套变量
        nonlocal b  
        b = 200
        print(b)
    return fun02()
fun01()