5、Python函数

记得多吃点

已于 2024-08-18 09:11:20 修改

阅读量268

点赞数 11

分类专栏： Python 文章标签： python 开发语言

于 2024-08-18 08:51:49 首次发布

本文链接：https://blog.csdn.net/Lyg970112/article/details/141232040

版权

Python 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Python函数

前言
一、函数介绍
二、函数说明文档
三、函数的参数介绍
四、函数返回值介绍
五、函数的嵌套调用
六、变量的作用域
七、多函数执行流程
八、函数同时返回多个值
九、函数参数详解
十. 组包和拆包
十一、引用
十二、匿名函数(lambda函数/表达式)
总结

前言

本章我们开始学习Python中的函数，对函数中出现的参数、变量、返回值、变量作用域、匿名函数等等来对函数进行深入浅出的学习。

一、函数介绍

"""
1、概述:
     函数也叫方法, 就是把 一些具有独立功能的代码封装到一起, 使其称为具有特殊功能的代码集.
     函数: function,  方法: method
2、例如:
     独立功能: 出门，坐公交，走到菜市场，挑菜买菜，付钱回家
     代码集: 我们可以把他抽成一个动作：买菜
3、作用:
     1. 模块化编程, 方便我们进行管理.
     2. 提高代码的复用性.
4、格式:
     def 函数名(形式参数1, 形式参数2...):
          函数体
          return 具体的返回值
    格式解释:
        def         固定写法, defined, 定义的意思.
        函数名       类似于变量名, 见名知意即可.
        形参列表     表示调用函数, 应该传入什么内容(值)
        函数体       具体的逻辑代码, 就是以前我们写的if, while, for, 容器...
        return      作用1: 结束方法的(类似于break)   作用2: 可以把函数的执行结果进行返回.

5、细节:
     1. 函数必须先定义, 然后才能调用.
     2. 定义函数小技巧, 三个明确:
            明确函数名
            明确形参列表
            明确返回值
     3. 调用函数小技巧, 三个步骤
            写 函数名()
            传参, 要什么给什么, 不要就不给.
            接收返回值, 返回什么就接收什么, 不给就不接收.
     4. 如果函数没有明确的返回值, 则return可以省略不写.
     5. 函数必须调用, 才会执行.
"""

# 例如将买菜的动作封装成一个函数
# 模拟第一次出去买菜
print('出门')
print('坐公交')
print('走到菜市场')
print('挑菜买菜')
print('付钱回家')

# 模拟第二次出去买菜
print('出门')
print('坐公交')
print('走到菜市场')
print('挑菜买菜')
print('付钱回家')

# 我们发现不管第几次出去买菜都会执行相同的流程，那我们就可以把他们封装到一个函数中，即：
def maicai():
	print('出门')
	print('坐公交')
	print('走到菜市场')
	print('挑菜买菜')
	print('付钱回家')


#当初去买菜的时候，调用maicai函数即可
maicai() # 打印结果跟上边效果一样

二、函数说明文档

"""
1、概述:
     函数的说明文档也叫 文档说明, 就是解释函数的 参数, 作用, 返回值的.
2、格式:
     在函数内的第一行, 用 三引号的写法来实现即可, 可以是双引号(推荐), 也可以单引号.
3、如何查看说明文档:
     help(函数名)
     鼠标放到函数上, 点击: ctrl + Q
"""

def get_sum(a, b):
    """
    自定义函数, 用于计算 两个整数的 和
    :param a: 要求和计算的第 1个整数
    :param b: 要求和计算的第 2个整数
    :return: 返回 a 和 b 的求和结果
    """
    sum = a + b
    return sum

# 调用函数get_sum
sum = get_sum(10, 20)
print(f'求和结果为: {sum}')

# 也可以查看函数的说明文档.
help(get_sum)

三、函数的参数介绍

"""
1、概述:
    定义函数的时候, 写的参数叫: 形式参数, 简称: 形参, 形容调用 函数 需要传入什么值.
    调用函数的时候, 写的参数叫: 实际参数, 简称: 实参, 表示 实际参与运算的数据.
2、根据 参数 和 返回值不同, 主要分为 如下的四种写法:
 	1. 无参无返回值.
    2. 有参无返回值.

    3. 无参有返回值. #  3 和 4 在学习返回值后看
    4. 有参有返回值.
"""

切记函数只有被调用，才会执行。

# 需求: 定义 get_sum()函数, 用于计算两个整数的和.

# 写法1: 无参, 无返回值的函数.
# 定义函数
def get_sum():
    a, b = 10, 20
    sum = a + b
    print(f'求和结果为: {sum}')

# 调用函数
get_sum()      # 求和结果为:30

# 虽然上述的操作已经实现了需求, 但是不够灵活, 上述的函数属于把两个数值写"死"了, 只能计算10 和 20的结果.
# 如果我们想计算任意两个整数的和, 如何实现呢?
# 写法2: 有参, 无返回值的函数.
# 定义函数
def get_sum2(a, b):   # 形参, 形容调用函数需要给几个参数
    """
    该函数用于计算两个整数和
    :param a: 求和计算的第1个整数
    :param b: 求和计算的第2个整数
    :return: 无
    """
    sum = a + b
    print(f'求和结果为: {sum}')

# 调用函数
get_sum2(11, 22)    # 33,     11 和 22 叫 实际参数(实参), 表示实际参与运算的数据.

c, d = 100, 200
get_sum2(c, d)      # 300       c(100), d(200) 叫实参, 表示实际参与运算的数据.

四、函数返回值介绍

"""
1、概述:
     返回值指的是 函数操作完毕后, 需要返回给 调用者 1个什么结果.
2、格式:
     在函数内部通过 return 返回值 这个格式即可返回.
3、细节:
     在哪里调用函数, 就把返回值返回到哪里.
"""

# 接上个节 接着写.
# 写法3: 有参有返回值的函数.  即: 计算两个整数和, 并返回结果.
# 定义函数
def get_sum3(a, b):     # 形参
    """
    该函数用于计算两个整数和
    :param a: 求和计算的第1个整数
    :param b: 求和计算的第2个整数
    :return: 返回求和结果.
    """
    sum = a + b
    return sum


# 调用函数
sum = get_sum3(1, 2)         # 实参
print(f'求和结果为: {sum}')   # 求和结果为: 3
print(f'平均值为: {sum // 2}')# 平均值为: 1

五、函数的嵌套调用

"""
1、概述:
     函数的嵌套指的是 函数的嵌套调用, 并不是函数的嵌套定义.
     例如: 在 func_B 函数中 调用 func_A 这个函数, 就叫: 函数的嵌套调用.
2、回顾:
     顺序结构: 代码会按照 从上往下, 从左往右, 依次逐行执行.
"""

# 1. 定义func_A()函数.
def func_A():
    print('----- func_A start -----')       # 2  这是执行顺序
    print('我是 funcA函数 ')                 # 3 这是执行顺序
    print('----- func_A end -----')         # 4 这是执行顺序


# 2. 定义func_B()函数.
def func_B():
    print('----- func_B start -----')       # 1 这是执行顺序
    # 3. 在这里调用 funcA()函数.
    func_A()
    print('----- func_B end -----')         # 5 这是执行顺序


# 4. 在main函数中, 调用 func_B()函数, 观察程序的打印结果.
# main函数是程序的主入口, 所有代码的执行都是从这里开始的.
# main方法可以省略不写(建议写), Python解释器底层执行的时候, 会自动帮我们加.
if __name__ == '__main__':
    func_B()

六、变量的作用域

"""
1、概述:
     变量的作用域指的是 变量的哪里能用, 哪里不能用, 即: 变量的作用区间.
2、分类:
     局部变量: 定义在函数内 或者 函数形参列表中的 变量.
     全局变量: 定义在函数外的变量, 或者用 global 关键字修饰的变量.

3、 局部变量 和 全局变量的区别?
     答案:
        1. 定义位置不同.
            局部变量: 定义在函数内 或者 函数形参列表中的 变量.
            全局变量: 定义在函数外的变量, 或者用 global 关键字修饰的变量.
        2. 在内存中的存储位置不同.
            局部变量: 存储在 堆区.
            全局变量: 存储在 方法区.
        3. 生命周期不同.
            局部变量: 随着函数的调用而存在, 随着函数的调用完毕而消失.
            全局变量: 随着 .py文件加载而存在, .py文件从内存中移除而消失.

4、细节:
     使用变量遵循就近原则, 局部位置有就直接使用, 没有就去 全局位置找, 有就使用, 没有就报错.
"""

# 案例1: 演示 局部变量的生命周期.
def func1():
    a = 10      # 局部变量
    print(f'a: {a}')
# 调用 func1()函数.
func1()

# 报错, 超出了 局部变量的作用域
# print(f'在func1()函数外, 调用变量a: {a}')


# 案例2: 演示 全局变量的生命周期.
b = 100

def func2():
    print(f'func2函数, b: {b}')

def func3():
    print(f'func3函数, b: {b}')

# 调用函数
func2()
func3()


# 案例3: 演示global关键字.
c = 66

def func4():
    print(f'func4函数, c: {c}')

def func5():
    global c        # global声明的变量, 属于: 全局变量.   不写global, 下述的c是 局部变量.
    c = 200
    print(f'func5函数, c: {c}')   # 使用变量遵循 就近原则.


# 调用函数
func4() # 66
func5() # 200
func4() # 200

七、多函数执行流程

"""
    1. 函数的返回值可以作为 (另一个函数的)参数进行传递.
    2. 函数可以作为 (另一个函数的)参数进行传递.
"""

# 演示 1. 函数的返回值可以作为 (另一个函数的)参数进行传递.
def fun1():
    return 100      # 返回1个结果 100

def fun2(num):      # 需要1个参数
    print(num)

# 调用fun1()函数, 获取返回值.
a = fun1()          # 相当于 a = 100

# 调用fun2()函数.
fun2(a)

# 合并版.
fun2(fun1())        # 函数的返回值可以作为 (另一个函数的)参数进行传递.


# 演示 直接写函数名, 是函数对象.
def get_sum(a, b):
    return a + b

# 正常调用
sum = get_sum(10, 20)
print(sum)

# 直接写函数名 是 对象, 可以赋值给变量, 那个变量就有了和该函数一样的功能.
# 意思就是一个函数有两个名字，两个名字都可以实现这个函数，相当于起小名
he = get_sum        # 等价于:   def he(a, b): return a + b
sum2 = he(20, 30)
print(sum2)


# 演示 2. 函数可以作为 (另一个函数的)参数进行传递.
def get_substract(a, b):
    return a - b

def calculate(a, b, fn):
    """
    自定义函数, 模拟计算器, 传入什么 函数(对象), 就做什么操作.
    :param a: 要操作的第1个整数
    :param b: 要操作的第2个整数
    :param fn: 具体的操作规则
    :return: 计算结果.
    """
    return fn(a, b)

# 相当于给传入了一个运算逻辑   相当于让calculate()返回的是 get_sum(10, 20)
print(calculate(10, 20, get_sum))        # 30        

print(calculate(10, 20, get_substract))  # -10

八、函数同时返回多个值

"""
1、函数返回多个结果: 
	会把多个结果 封装成1个元组进行返回.

2、请问：1个函数可以同时返回多个结果(返回值)?
	答案: 错误, 因为1个函数只能返回1个结果, 如果同时返回多个值则会封装成1个元素进行返回.
"""

# 需求: 定义函数 my_calculate(a, b), 返回两个整数的: 加减乘除结果.
def my_calculate(a, b):
    add = a + b
    sub = a - b
    mul = a * b
    div = a // b
    return add, sub, mul, div   # 如果函数同时返回多个结果, 则会封装到1个元组中, 进行返回.


# 测试函数
if __name__ == '__main__':
    result = my_calculate(10, 3)
    print(type(result)) # <class 'tuple'>
    print(result)       # (13, 7, 30, 3)

九、函数参数详解

参数写法主要有如下的四种:
1、位置参数
2、关键字参数
3、默认参数(缺省参数)
4、不定长参数
注意
1. 位置参数和关键字参数是针对于实参来讲的.
2. 缺省参数和不定长参数是针对于形参来讲的.

1. 位置参数

"""
位置参数:
    我们之前写的实参写法 就是位置参数, 即: 实参的 个数 和 顺序 必须和 形参保持一致.
"""

# 1. 定义函数 user_info(), 接收三个参数, 打印自己的信息: name, age, address
def user_info(name, age, address):
    print(f'我叫: {name}, 今年 {age} 岁了, 我住在: {address}')


# main函数是程序的 主入口, 所有的代码都是从这里开始执行的.
if __name__ == '__main__':
    # 2. 调用函数 user_info()
    user_info('张三', 23, '北京')  # 我叫: 张三, 今年 23 岁了, 我住在: 北京
    user_info('张三', '北京', 23)  # 不报错, 但是结果是：我叫: 张三, 今年 北京 岁了, 我住在: 23

2. 关键字参数

"""
    我们上边写的实参写法 就是位置参数, 即: 实参的 个数 和 顺序 必须和 形参 保持一致.
    如果 实参 和 形参的顺序不一致, 结果不一定是我们想要的, 所以为了更灵活的调用函数, 引入了: 关键字参数.

1、格式:
    采用 键 = 值 的形式来传递 实参.
2、细节:
     如果有多个参数(实参), 则: 位置参数在前, 关键字参数在后(且多个关键字参数之间, 没有顺序要求)
"""

# 1. 定义函数 user_info(), 接收三个参数, 打印自己的信息: name, age, address
def user_info(name, age, address):
    print(f'我叫: {name}, 今年 {age} 岁了, 我住在: {address}')


# main函数是程序的 主入口, 所有的代码都是从这里开始执行的.
if __name__ == '__main__':
    # 2. 调用函数 user_info()
    # 位置参数
    user_info('张三', 23, '北京')
    user_info('张三', '北京', 23)  # 位置参数, 故意传错位置. 不报错, 但是结果不是我们要的.
    

    # 关键字参数, 多个关键字参数之间无顺序要求.
    user_info(address='广州', name='李四', age=24)

    # 如果既有关键字参数, 又有位置参数. 则: 位置参数在前, 关键字参数在后.
    # user_info(address='广州', name='李四', 25)      # 报错, 顺序不对.

    #           位置参数              关键字参数
    user_info('王五', address='深圳', age=25)

3. 默认参数(缺省参数)

 """
1、概述：
	缺省参数也叫 默认参数, 即: 定义在 函数的形参列表的 最后.

2、格式:
    采用 键 = 值 的形式来定义, 且必须放 形参列表的最后.
3、细节:
    1. 调用函数时, 没有给缺省参数赋值, 则: 用缺省参数的默认值.
    2. 调用函数式, 如果给缺省参数赋值, 则: 用赋的新值.
    3. 最重要：形参列表中如果有 缺省参数, 则必须放 参数列表的最后.
"""

# 1. 定义函数 user_info(), 接收三个参数, 打印自己的信息: name, age, address
# def user_info(name, address='北京', age):     # 报错, 缺省参数必须在 形参列表的最后.
def user_info(name, age, address='三亚'):
    print(f'我叫: {name}, 今年 {age} 岁了, 我住在: {address}')

# main函数是程序的 主入口, 所有的代码都是从这里开始执行的.
if __name__ == '__main__':
    # 2. 调用函数 user_info()
    # 位置参数
    user_info('张三', 23, '北京')
    user_info('张三', '北京', 23)  # 位置参数, 故意传错位置. 不报错, 但是结果不是我们要的.
 

    # 关键字参数, 多个关键字参数之间无顺序要求.
    user_info(address='广州', name='李四', age=24)

    # 如果既有关键字参数, 又有位置参数. 则: 位置参数在前, 关键字参数在后.
    # user_info(address='广州', name='李四', 25)      # 报错, 顺序不对.

    #           位置参数              关键字参数
    user_info('王五', address='深圳', age=25)
    

    # 不给默认参数传值. 默认值adress是三亚
    user_info('王五', age=25) # 我叫: 王五, 今年 25 岁了, 我住在: 三亚

4. 不定长参数

 """
1、概述:
     不定长参数也叫 可变参数, 即: 参数的个数是可以变化的.
2、应用场景:
     适用于 实参的个数不确定的情况, 就可以把 形参定义成 可变参数.
3、格式:
      *args     只能接收所有的 位置参数, 封装到: 元组中.
      **kwargs  只能接收所有的 关键字参数, 封装到: 字典中.
4、细节:
      1. 关于实参, 位置参数在前, 关键字参数在后.
      2. 关于形参, 如果两种 可变参数都有, 则: *args 在前, **kwargs 在后.
      3. 关于形参, 如果既有 缺省参数 又有不定长参数, 则编写顺序为:  *args, 缺省参数, **kwargs
"""

# 需求1: 演示 不定长参数(可变参数)之 接收 位置参数.
def method01(*args):                       # 约定俗成, 变量名可以任意写, 但是建议写成 args
    print(f'接收到的所有参数为: {args}')     # 你把 args变量当做 元组来用即可.
    print(type(args))

# 需求2: 演示 不定长参数(可变参数)之 接收 关键字参数.
def method02(**kwargs):
    print(f'接收到的所有参数为: {kwargs}')
    print(type(kwargs))

# 需求3: 同时定义两种 参数.
#             不定长(可变)参数
def method03(*args, **kwargs):
    print(f'args: {args}')
    print(f'kwargs: {kwargs}')

# 需求4: 同时定义 缺省参数, 不定长参数.
#          不定长参数   缺省参数    不定长参数
def method04(*args, name='张三', **kwargs):
    print(f'name: {name}')
    print(f'args: {args}')
    print(f'kwargs: {kwargs}')



# main充当程序的 主入口.
if __name__ == '__main__':
    # 调用 method01()函数.
    method01(1, '张三', 23)
    # method01(1, '张三', age=23)       # 报错, *args 只能接收所有的 位置参数.

    # 调用 method02()函数.
    method02(name='张三', age=23, phone='13112345678')
    # method02('李四', age=24, phone='13112345678')     # 报错, **kwarg 只能接收所有的 关键字参数.

    # 调用 method03()函数
    #                位置参数           关键字参数
    method03(10, 20, 'aa', name='王五', age=25, address='杭州')

    # 调用 method04()函数
    #                位置参数             关键字参数
    method04(10, 20, 'aa', name='王五', age=25, address='杭州')

5. 综合参数讲解

演示普通参数 + 缺省参数 + 不定长参数之接收所有的位置参数和关键字参数.

def user_info4(a, b, c=10, d=20, e='测试', *args, **kwargs):   # 不定长参数
    print(f'a: {a}, b: {b}, c: {c}, d: {d}, e: {e}')
    print(f'args: {args}')     
    print(f'kwargs: {kwargs}') 

# 测试上述的函数.
if __name__ == '__main__':

    #                   位置参数                                      关键字参数
    user_info4(1, 2, 3, 4, 5, 6, 7, 8, 9, name='李四', age=24, gender='女')
    #  打印结果：a: 1, b: 2, c: 3, d: 4, e: '5')
   	#		    args: （6, 7，8, 9）    
    #           kwargs: {'name': '李四', 'age': 24, 'gender': '女'}
    user_info4(1, 2, name='李四', age=24, gender='女')
    #  打印结果：a: 1, b: 2, c: 10, d: 20, e: '测试')
   	#		    args: （）    
    #           kwargs: {'name': '李四', 'age': 24, 'gender': '女'}

十. 组包和拆包

"""
1、概述:
     组包 和 拆包 是Python中的一种独有写法.
2、格式:
     把 多个值 => 1个变量 的过程, 称之为: 组包.
     把 1个(容器)变量 => 多个变量值 的过程, 称之为: 拆包.
3、细节:
      1. 拆包针对于 元组, 列表, 字典, 集合, 字符串有效.
      2. 如果针对于 字典拆包, 则只能获取 键 的数据.
"""

# 1. 演示组包.       多个值 => 1个值
s1 = 'fasdfs'
list1 = [1, 2, 3, 4, 5]
tuple1 = (1, 2, 3, 4, 5)
dict1 = {'a': 1, 'b': 2, 'c': 3}
set1 = {1, 2, 3, 4, 5}

# 2. 演示拆包.      1个值 => 多个值
# 演示字符串拆包.
# a, b, c, d = s1     # 报错, 变量的个数 和 字符串值的个数 不匹配.
a, b, c, d, e, f = s1
print(a, b, c, d, e, f)    # f a s d f s

# 演示列表拆包.
a, b, c, d, e = list1
print(a, b, c, d, e)       # 同上

# 演示元组拆包.
a, b, c, d, e = tuple1
print(a, b, c, d, e)       # 同上

# 演示集合拆包.
a, b, c, d, e = set1
print(a, b, c, d, e)       # 同上

# 演示字典拆包.
a, b, c = dict1
print(a, b, c)             # a b c (只能获取 键)

十一、引用

"""
1、概述:
     Python中的引用 指的是 地址值,即: 变量在内存中的位置(地址).
2、格式:
     id(变量名)         可以查看变量在内存中的地址.
3、细节:
     1. Python中只有 引用传递, 即: 我们以前看到的所有赋值动作, 都是把 地址值拷贝(赋值)过去.
     2. 区分 可变 和 不可变类型的依据: 在不改变地址值的情况下, 是否可以修改变量的内容, 可以: 可变类型, 不可以: 不可变类型.
          可变:     列表, 字典, 集合.
          不可变:   int, float, bool, str, 元组
     3. 观察如下的代码, 分析程序结果:
          形参是可变类型:    形参的可变直接影响实参.
          形参是不可变类型:  形参的改变对实参没有任何影响.
"""

# 案例1: 查看变量的地址值.
a = 10
b = a
c = a

print(id(a))    # 140719741221592, 说明: 10在内存中就1份, abc分别指向它.
print(id(b))    # 140719741221592, 说明: 10在内存中就1份, abc分别指向它.
print(id(c))    # 140719741221592, 说明: 10在内存中就1份, abc分别指向它.

# 案例2: 演示可变 和 不可变类型.
# 场景1: 可变类型, 即: 在不改变地址值的情况下, 可以修改里边的元素内容.
list1 = [1, 2, 3]
print(f'list1 修改前元素值: {list1}')         # [1, 2, 3]
print(f'list1 修改前地址值: {id(list1)}')     # 1967989313856
# 修改list1的元素.
list1.append(100)
list1[1] = 200
print(f'list1 修改后元素值: {list1}')         # [1, 200, 3, 100]
print(f'list1 修改后地址值: {id(list1)}')     # 1967989313856


# 场景2: 不可变类型, 即: 在不改变地址值的情况下, 不可以修改里边的元素内容.
s1 = 'abc'
print(f's1 修改前元素值: {s1}')         # abc
print(f's1 修改前地址值: {id(s1)}')     # 140719740359832
# 修改s1的元素.
s1 = 'xyz'
print(f's1 修改前元素值: {s1}')         # xyz
print(f's1 修改前地址值: {id(s1)}')     # 1968046325856

观察如下的代码, 分析程序结果:
1、形参是可变类型: 形参的可变直接影响实参.
2、形参是不可变类型: 形参的改变对实参没有任何影响.

# 定义函数, 接收 参数, 一会传入: 整数(int), 不可变类型.
def change(num):
    num = 200

# 定义函数, 接收 参数, 一会传入: 列表(list), 可变类型.
def change2(list1):
    list1[1] = 28

if __name__ == '__main__':
    # 演示: 不可变类型 函数的调用.
    a = 100
    print(f'调用 change 函数前, a: {a}')     # 100
    change(a)
    print(f'调用 change 函数前, a: {a}')     # 100

    # 演示: 可变类型 函数的调用.
    list1 = [1, 2, 3, 4, 5]
    print(f'调用 change 函数前, list1: {list1}')  # 1, 2, 3, 4, 5
    change2(list1)
    print(f'调用 change 函数后, list1: {list1}')  # 1, 28, 3, 4, 5

十二、匿名函数(lambda函数/表达式)

"""
1、概述:
      没有名字的函数 就叫 匿名函数.
2、格式:
      变量名 = lambda 形参列表 : 函数体(只能写一行代码, 且该行代码的结果会被自动返回)
3、细节:
      1. Python的匿名函数 类似于 Java中的Lambda表达式.
      2. 匿名函数适用于简单的业务需求, 即: 函数体只有一行代码的函数.
      3. 匿名函数的应用场景:
           当对方法仅调用一次.
           匿名函数 可以作为 函数对象 进行传递.
"""

# 案例1: 匿名函数入门.
# 需求: 定义函数, 用于计算两个整数和.
# 场景1: 普通函数.
def get_sum(a, b):
    return a + b

print(get_sum(10, 20))


# 场景2: 匿名函数实现
my_get_sum = lambda a, b :  a + b
print(my_get_sum(11, 22))


# 案例2: 定义函数, 接收2个整数, 分别计算两个整数的: 和, 差, 积, 商, 最大值, 最小值.
# 场景1: 普通函数.
def get_sum(a, b):
    return a + b            # 求和

def get_sub(a, b):
    return a - b            # 差

def get_mul(a, b):
    return a * b            # 积

# ...... 依次类推, 把其他的函数全部做出来即可, 但是这样就会导致 多个需求, 每个需求都对应1个函数, 函数太多了, 一方面开发效率下降,
# 另一方面不方便维护和管理, 光记忆函数名 就是1个非常庞大的工程, 如何解决呢?
# 可以通过 匿名函数的方式 解决.


# 场景2: 匿名函数 方式实现.
def my_func(a, b, fn):
    """
    自定义函数, 根据传入的规则, 来计算两个整数的结果.
    :param a: 要操作的第1个数据
    :param b: 要操作的第2个整数
    :param fn: 具体的 计算规则 函数.
    :return: 具体的计算结果.
    """
    return fn(a, b)


# 调用 my_func()函数.
# 加
# print(my_func(10, 3, get_sum))
print(my_func(10, 3, lambda a, b : a + b))

# 减
# print(my_func(10, 3, get_sub))
print(my_func(10, 3, lambda a, b: a - b))

# 乘
print(my_func(10, 3, lambda a, b: a * b))

# 除
print(my_func(10, 3, lambda a, b: a // b))

# 最大值
# print(my_func(10, 3, lambda a, b: max(a, b)))
print(my_func(10, 3, lambda a, b: a if a >= b else b))

# 最小值
print(my_func(10, 3, lambda a, b: a if a <= b else b))

# 平均值
print(my_func(10, 3, lambda a, b: (a + b) // 2))