函数是将执行特定任务或特定功能的一段代码整合到一个整体并命名，在需要的位置调用这个名称即可完成对应的需求。它仅在调用时运行。

函数在开发过程中，可以更高效的实现代码重用。还可以提高可维护性和可读性，便于调试。

python中有很多内置函数，可以通过help()来查看函数的说明文档：

help(max)   #  查看max函数的说明文档

定义函数

语法：

def 函数名(参数列表):
    '''函数说明文档'''
    代码块
    [return xxx]

定义函数以def关键词开始。

函数名：自己定义的，符合python标识符规则即可，最好见名知意。

参数列表：可以接收多个参数，参数之间用英文逗号隔开。可有可无。

函数说明文档：说明函数实现的功能，可写可不写。添加说明文档可以帮助我们快速了解函数实现的功能。

[return xxx]：返回一个值给调用方。可以有返回值也可以没有返回值，需要根据实际情况而定。return结束函数。

函数必须先定义后使用。

def fun_add(a,b):
    return a+b

# 如果定义一个函数还没想好代码块怎么写，可以先写上pass
def demo():
    pass

函数的调用

函数要先定义再调用。

语法：函数名([实际参数])

# 3、跳到定义函数的地方，接收参数
def fun_add(a,b):
    return a+b   # 4、执行函数体，并将结果返回
# 1、先给变量赋值
num1 = 10
num2 = 20
# 2、调用fun_add()函数，并将num1,num2作为参数传递进去
result = fun_add(num1,num2)    # 5、将fun_add的返回值赋给result变量
# 6、打印输出result
print(result)   # 30

函数的执行流程：

函数的参数

形参和实参

形参：形式参数，函数定义时给出的用于接收用户数据的参数。

实参：实际参数，调用函数时传入的真实数据。

def fun_add(a,b):    # a,b是形参，定义函数的同时定义的用于接收用户数据的参数，只是一个占位符号罢了，自定义的
    return a+b

num1 = 10
num2 = 20
result = fun_add(num1,num2)   # num1,num2是实参，调用函数时传入的真实的数据。将来做运算的数据
print(result)   # 30

参数可以是任何数据类型，如字符串、数字、列表、字典等，

参数传递

实参和形参的名称可以不一样。

在函数调用过程中，进行参数传递，如果传递的参数是不可变对象，在函数体内的修改不会影响实参的值；如果传递的参数是可变对象，在函数体内的修改会影响实参的值。

def fun(arg1,arg2):
    print('arg1:',arg1)
    print('arg2:',arg2)
    arg1 = 999
    arg2.append(100)
    print('arg1:', arg1)
    print('arg2:', arg2)

n = 10
lst = [11,22,33]
print('n:',n)   # n: 10
print('lst:',lst)   # lst: [11, 22, 33]
# 跳到函数定义处，执行函数内的代码
fun(n,lst)      
# 函数体执行完成后继续执行下面代码
# 10是不可变对象，在函数体内的修改arg1 = 999不会影响实参n。
print('n:',n)    # n: 10
# 列表是可变对象，在函数体内进行了修改arg2.append(100)，实参lst也跟着变了。
print('lst:',lst)   # lst: [11, 22, 33, 100]

1）位置参数

根据形参对应的位置进行实参传递。

def my_function(name,age):
    str = f'我叫{name}，今年{age}。'
    return str

print(my_function('张三',20)) # 我叫张三，今年20。

# 实参和形参的位置要一一对应，才能正确的传递信息
print(my_function(20,'张三')) # 我叫20，今年张三。

2）关键字参数

根据形参名称进行实参传递。使用关键字参数允许函数调用时参数和函数定义时的参数顺序不同（可以无序），python解释器会根据关键字参数名匹配参数值。

def my_function(name,age):
    str = f'我叫{name}，今年{age}。'
    return str

print(my_function(name = '张三',age = 20)) # 我叫张三，今年20。

# python解释器会跟据关键字参数名去匹配参数值，age,name就是关键字参数
# age是形参名称，20是实参值；name是形参名称，'张三'是实参值。
print(my_function(age = 20,name = '张三')) # 我叫张三，今年20。

def fun(a,b,*,c,d):  # *后面的参数，在函数调用时，只能使用关键字传参
    print(a,b,c,d)

# fun(10,20,30,40)    # TypeError: fun() takes 2 positional arguments but 4 were given
fun(10,20,c=88,d=456)   # 10 20 88 456

3）默认值参数

函数在定义时，给形参设置一个默认值，只有在与默认值不符的时候才需要传递实参。

def fun_add(a,b=100):   # 给形参b设置了默认值为100，b就是默认值形参
    return a+b

# 值传一个参数时，b采用默认值
m = fun_add(20)
print(m)    # 120

# 传递的实参30和形参b = 100的值不相同，采用实参的值30
n = fun_add(10,30)
print(n)    # 40

4）任意参数

a、个数可变的位置参数（包裹位置传递）

定义函数的时候，若无法确定传递的位置实参的个数，可以在参数名前添加’*’，定义一个个数可变的位置形参。得到的是一个元组。

注意：个数可变的位置参数，一次只能定义一个。

# 个数可变的位置形参
def fun(*args):   # args变量将传进的所有参数收集，根据传进参数的位置合并为一个元组
    print(args)   # 把传递的参数打印输出

fun(99)         # (99,)
fun(76,345)     # (76, 345)
fun(9,32,21)    # (9, 32, 21)

b、个数可变的关键字参数（包裹关键字传递）

定义函数时，若无法确定传递的关键字实参的个数，可以在参数名前添加’**’，来定义一个个数可变的关键字形参。得到的是一个字典。

注意：个数可变的关键字参数，一次只能定义一个。

# 个数可变的关键字形参
def fun(**args):   # args收集所有传进的关键字参数，打包成一个字典
    print(args)

fun(a = 99)         # {'a': 99}
fun(a = 76,b = 345)     # {'a': 76, 'b': 345}
fun(a = 9,b = 32,c = 21)    # {'a': 9, 'b': 32, 'c': 21}

上面两种方法都是一个组包的过程。

如果在定义函数的过程中，既要有个数可变的位置形参，也要有个数可变的关键字形参，那么，个数可变的位置形参必须放在个数可变的关键字形参前面。否则报错。

def fun(*arg,**args):
    print(arg,args)

fun(10,20,a = 99)         # (10, 20) {'a': 99}
fun(20,43,21,65,a = 76,b = 345)     # (20, 43, 21, 65) {'a': 76, 'b': 345}

如果形参有多个，在传递列表时，需要将列表中的每个元素都转换为位置实参传入：

def fun(a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)

lst = [78,32,65]
# fun(lst)    # TypeError: fun() missing 2 required positional arguments: 'b' and 'c'
fun(*lst)

形参有多个，在传递字典时，需要将字典中的每个键值对转换成关键字实参传入：

def fun(a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)

dct = {'a': 100,'b': 888,'c': 562}
fun(**dct)

函数的返回值

函数返回值可有可无。

a、函数无返回值，return可省略。

b、只有一个返回值，直接返回原类型。

c、当函数有多个返回值时，结果为元组。（可以拆包，使用多个变量去接收返回值）

def fun(num):
    odd = []    # 存放奇数
    even = []   # 存放偶数
    for i in num:
        if i%2:     odd.append(i)
        else:   even.append(i)
    return odd,even
lst = [10,23,32,12,54,89,76,90]
print(fun(lst))     # ([23, 89], [10, 32, 12, 54, 76, 90])
# 拆包，使用多个变量去接收返回值
lst1,lst2 = fun(lst)
print('lst1 =',lst1,'，lst2 =',lst2) # lst1 = [23, 89] ，lst2 = [10, 32, 12, 54, 76, 90]