再说函数

1. 函数的引用赋值和参数操作

PYTHON 中的函数，本身也是一个对象，常规定义语法的函数，就是将一个函数对象的引用地址赋值给函数名称的变量，通过函数名称的变量调用执行函数。

#声明定义一个函数对象，赋值给了变量show_msg
def show_msg():
    print("函数代码执行")
#通过变量show_msg可以直接调用执行函数的代码
show_msg()

如果函数就是对象，那么函数也是和对象一样可以被引用赋值

#声明定义一个函数对象，赋值给了变量show_msg
def show_msg():
    print("函数代码执行")

#函数可以赋值给一个变量
show_info = show_msg
#同样可以通过变量show_info来调用执行函数show_msg
show_info()

函数也可以被当成参数传递给其他函数执行

#声明定义一个函数对象展示第一类信息
def show_msg1():
    print("函数代码执行，信息1...")

def show_msg2():
    print("函数代码执行，信息2...")

#定义展示处理函数
def show(message):
    message()

#执行代码：函数可以当成参数被传递
show(show_msg1)
show(show_msg2)

2.函数默认调用：偏函数

有一种函数操作，可以让函数的操作执行更加人性化的操作处理

#引入函数工具模块中的偏函数扩展
from functools import partial

#定义普通函数
def calculation(num1, num2, opra):
    res = None
    if opra == "+":
        res = num1 + num2
    elif opra == "-":
        res = num1 - num2
    elif opra == "*":
        res = num1 * num2
    elif opra == "/":
        res = num1 / num2
    return res

#普通函数的调用
result = calculation(12, 10, "+")
print(result)

#通过偏函数进行处理，添加默认操作方式
calculation2 = partial(calculation, opra="+")
result = calculation2(22, 24)
print(result)

但是偏函数的操作，在一定程度上来说只是一个语法糖，因为 python 中对于函数参数的处理已经有默认值的操作，完全可以替代偏函数的复杂操作

def calculation(num1,num2,opra="+")
    pass

if __name__ == "__main__":
    result = calculation(22, 24)
    print(result)

3. 功能织入：装饰器函数

软件开发原则中，有一项是 OCP(open close principle：开闭原则)
OCP:对软件功能的扩展开放，对软件原来代码的修改关闭

那么如果在函数中，我们要给一个函数添加功能但是又不允许修改函数的代码，如上述计算函数 calculation()，在计算前后添加日志记录，应该怎么操作呢？

最原始的操作方式如下：

# 目标函数
def calculation():
    pass
# 操作代码
print(“开始运算，日志记录…”)
calculation()
print(“运算结束，得到结果…”)

但是上述这样的代码，对于代码的复用性的提升较差
PYTHON 提供了一种新的处理方式，可以更加友好的在符合OCP 原则的情况下，扩展函数的操作功能

#定义装饰器函数，用于给指定的函数增加功能
def loggin(fn):
    def wrapper(*args, **kwargs):
        print("新增功能代码>>>>")
        res = fn(*args, **kwargs)
        print("新增功能代码<<<<")
        return res
    return wrapper

#定义普通函数
@loggin
def calculation(num1, num2, opra)
    print("目标函数执行中", num1, opra, num2)

#普通函数的调用：目标函数调用时，已经新增加了新的处理功能
calculation(12, 18, "+")

4. 数据扩展：闭包函数

函数中的数据一般情况都是局部变量作用域，所以函数执行结束，意味着函数中的数据就会丢失，在函数外部就不能访问函数中的数据。
但是在有些情况下，我们需要在函数外部直接操作函数中的数据，能有什么样的操作方式呢
⚫ 将函数中的数据直接通过返回值返回
⚫ 通过闭包函数进行操作

返回值的操作方式比较固定单一，能作为简单数据的处理手段
更加灵活的操作方式就是闭包函数
所谓闭包函数：就是在函数中声明另一个函数

def outer():
    print("外部函数")

    def inner():
        print("内部函数：闭包函数")
    
    return inner
#调用执行outer()函数时，得到一个函数对象的返回值
x = outer()
#该返回值是一个函数，所以也可以执行
x()

5. 强大功能：匿名函数

匿名函数，在很多语言中都存在这样一种操作方式
更加广为人知的名称：兰木达表达式[lambda 表达式]，它的主要作用是简化函数操作，将简单的处理逻辑封装在一个表达式中，而省去了定义函数的繁杂的操作方式

基本语法结构：

lambda 参数列表：运算表达式
参数列表：lambda 表达式运算的数据输入
运算表达式：可以执行计算的简单代码，最终会成为该表达式的数据输出

基本操作方式：
⚫ 计算三个数据的基本运算

fn = lambda x, y, z : x + y + z

等价于

def fn(x, y, z):
    return x + y + z

主要起到简单处理函数的功能，所以 lambda 表达式才在很多地方被称为匿名函数