python函数

1、函数概述

（1） 什么是函数

函数(function)从代码角度狭义上描述：包含了一部分代码的功能模块！

• 声明过程：通过函数语法，将一行或者多行可能会重复的代码，包装到一个代码块中！

• 具备过程：一个函数声明完成，并不会立即执行，而是当前代码中具备了函数的功能！

• 调用过程：通过函数名称调用函数，函数内部代码才会执行！

（2） 认识函数

需求：开发的一个应用中，可能出现了功能相似的代码(一行或者多行)，并且需要在不同的位置执行

解决方案1：传统顺序结构，造成代码大量重复的问题，专业术语称为代码冗余

解决方案2：使用循环，只能让重复的代码在同一个位置执行，无法解决不同位置的代码重复问题

解决方案3：使用函数，既可以解决代码重复的问题，也可以解决不同位置执行相同/相似代码的问题

2、函数分类、语法

（1） 基础语法

函数使用关键字def声明：define function 定义函数缩写

① 函数的声明语法

• 声明函数，函数中包含了多行代码，但是函数内部的代码程序运行的时候不会立即执行

def 函数名称():
    """函数的文档注释：描述函数的作用"""
    函数内一行或者多行代码

② 函数的调用语法

调用函数，需要通过函数名称调用，调用的时候函数内部的代码才会执行；多次调用代码也会重复执行多次

# 调用执行函数
函数名称()

（2）函数返回值

函数的返回值描述了函数的执行结果

① 不需要结果

def fn11(money):
    """充话费: 让隔壁小伙伴帮忙冲一下话费，手机自动开机了"""
    print("充话费完成，充值了:", money)

# 函数结果(不重要)
fn11(100)

② 需要结果333

def fn22():
    """获取快递"""
    print("帮忙去一下快递")
    # 返回结果，使用关键字return
    return "IPhone 16"

# 调用函数，获取执行结果
# result = "IPhone 16"
result = fn22()
print("获取到快递：", result)

3.函数参数

形式参数与事实参数

 def add(a, b):  # a,b叫做形式参数
     return a + b  # return关键字 不仅仅会返回运算结果 同时他还会立即结束函数


 result = add(10, 20)  # 10,20 叫做实际参数
 print(result)

4.参数类型

 位置参数

一般情况下实参的传参顺序必须跟形参列表一致

 如果先传某个后面的参数,需要指名道姓的传参

# 位置参数，一般情况下实参的传参顺序必须跟形参列表一致
# 如果先传某个后面的参数,需要指名道姓的传参
def add(a, b):
    return a + b


result = add(b=20, a=10)
print(result)

默认值参数

在形参列中提前给参数赋值

调用具有默认值参数的函数时，可以省略默认值参数的传参

如果觉得默认值参数不好用，我们可以主动传参替换掉默认值

# 默认值参数
# 在形参列中提前给参数赋值
# 调用具有默认值参数的函数时，可以省略默认值参数的传参
# 如果觉得默认值参数不好用，我们可以主动传参替换掉默认值
def circle_area(r, pi=3.14):
    return pi * r * r


# result = circle_area(10)
result = circle_area(10, 3.1415926)
print(result)

 默认值参数的可以当做是一个全局的变量，每调用一次都会修改原有的内容，下一次调用在修改后结果上继续

 所以默认值参数,虽然不禁止参数数据类型为可变，但是建议默认值参数的数据类型为不可变

可变参数

可以0~n个实际参数，会将实际参数打包成元组交给函数运算

在函数中可变参数就是一个元组

def add(*args, a, b, c):  # 此时a,b,c出现在可变参数之后，他们不再是位置参数而是 命名参数
    result = 0
    for num in args:
        result += num
    return result

print(add(1, 2, 3, 4, 5, 6, 7, 9, a=10, b=11, c=12))

 命名参数

就是必须指名道姓传参的参数,他一般出现在*args之后或者 * 之后

避免参数过多时，出现传参错误的情况，同时也可以提升代码清晰度，一眼就能知道那个实参传给了哪个形参

def test(*, a, b, c, d, ):
    print(a, b, c, d)

test(a=1, b=2, c=3, d=4)

关键字参数

 关键字参数的自由度非常高，参数的名称可以在传入实参是临时赋予

def function(**kwargs):
    for key, value in kwargs.items():
        print(key, value)


function(学号="001", name="zs", age=18,)

参数的建议数学顺序

 def function(a, b, c, d=10, *args, e, f, g, **kwargs):
     pass

参数组合传递

def function(a, b, c=0, *args, **kwargs):
    print(a, b, c, args, kwargs)


function(*(1, 2, 3, 4, 5, 6, 7, 8, 9), {'name': 123, 'age': 123, 'haha': 'hehe'})



#结果：1 2 3 (4, 5, 6, 7, 8, 9, {'name': 123, 'age': 123, 'haha': 'hehe'}) 

4.递归函数：自己调用自己的函数就叫递归函数

递归本质分治思想，它的思路通常跟我们正常思维不一样

递归必须具备两个条件：

1.自己调用自己

2.要有终止递归的条件

def test():
    test()


test()  # python对递归函数做了限制递归次数不能超过1000次
print("123123")

例： 求自然数n以内的和

def _sum(n):
    if n == 0:
        return 0
    else:
        return n + _sum(n - 1)
        #  100 + 99 + 98 + ......+ 3 + 2 + 1 + 0


print(_sum(100))

5.匿名函数

lambda函数

语法结构：lambda:参数1,参数2....参数n:一行代码

整个lambda函数只能有一行代码

自动返回代码的运行结果

lambda函数一般会直接作为实参传递其他函数

result = main(lambda a, b: a + b, 10, 20)
print(result)
result = main(lambda a, b: a - b, 10, 20)
print(result)

 map函数，他会将传入的序列中的每一个元素 通过一个lambda函数进行修改

ls = [1, 2, 3, 4, 5, 6]
result = list(map(lambda n: n ** 2, ls))
print(result)

filter函数,他会根据lambda函数过滤条件对序列进行筛选

ls = [1, 2, 3, 4, 5, 6]
result = list(filter(lambda n: n % 2 == 0, ls))
print(result）

sort函数，根据lambda函数进行排序

ls = [1, 2, 3, 4, '10', '20']
result = list(sorted(ls, key=lambda n: int(n)))
print(result)