函数
一、大纲：
1、函数的创建和调用
2、函数的参数传递
3、函数的返回值
4、函数的参数定义
5、变量的作用域
6、递归函数
二、 函数的创建和调用
1.什么是函数
- 函数就是执行特定任务和以完成特定功能的一段代码
2.为什么需要函数
- 复用代码
- 隐藏实现细节
- 提高可维护性
- 提高可读性便于调试
3.函数的创建
创建格式：
def 函数名（[输入参数]）：
函数体
[return xxx]
代码示例：
'''函数的创建和调用'''
def calc(a,b):
c=a+b
return c
result=calc(10,20)
print(result)
执行结果：
图解函数执行：
说明：当执行到calc(10,20)时，会先去找到calc()函数，然后带入参数，函数计算完成后退出函数，然后继续执行下一条语句
使用debug模式查看程序执行顺序：
首先在函数调用所在行打断点，如下图，然后点击debug图标（绿色小虫子）调出debug模式
点一下向下的箭头开始执行，如下图： 
会跳转到下一步，即函数定义处
再点击一次向下箭头，会跳转到定义函数的下一行，即执行该行
再点一次向下箭头，返回到函数调用处，即断点所在行
再点击一次向下箭头，会执行最后的Print函数，将结果输出
再点击一次向下箭头，则结束debug，返回Console视图，则可以看到返回结果是30
三、函数的参数传递（位置实参和关键字实参）
函数调用的参数传递
- 位置实参：根据形参对应的位置进行实参传递
- 关键字实参：根据形参名称进行实参传递
位置实参示意图：
关键字实参示意图：
代码示例：
#函数的形参与实参
def calc(a,b): #a,b成为形式参数，简称形参，形参的位置是在函数的定义处
c=a+b
return c
result=calc(10,20) #10,20称为实际参数的值，简称实参，实参的位置是函数的调用处
print(result)
res=calc(b=10,a=20) # =左侧的变量名称为 关键字参数
print(res)
执行结果：
说明：calc(10,20)使用的是位置实参，即在调用处不定义形参，按照位置来一一传值，也就是会将10传递给a，20传递给b，如下图：
calc(b=10,a=20)因为定义了形参，则会根据形参来传值，即10对应的关键字参数是b，则会将10传递给b,20对应的关键字参数是a，则会将20传递给a,如下图：
四、函数参数传递的内存分析
代码示例：
'''函数参数传递的内存分析'''
def fun(arg1,arg2):
print('arg1',arg1)
print('arg2', arg2)
arg1=100
arg2.append(10)
print('arg1', arg1)
print('arg2', arg2)
n1=11
n2=[22,33,44]
print('n1',n1)
print('n2',n2)
fun(n1,n2) #位置传参，arg1,arg2，是函数定义处的形参，n1,n2是函数调用处的实参，总结，实参名称和形参名称可以不一致
print('n1',n1)
print('n2',n2)
'''在函数调用过程中，进行参数的传递
如果是可变对象，在函数体的修改不会影响实参的值， arg1修改为100，不会影响n1的值
如果是可变对象，在函数体的修改会影响到实参的值， arg2的修改，append(10),会影响到n2的值
'''
执行结果：
说明：fun(n1,n2)使用的是位置传参，所以函数调用之时n1的值11 会赋给函数定义处的arg1，n2的值[22,33,44]会赋给函数定义处的arg2，因11是字符串，是不可变类型，所以尽管在函数定义处将arg1赋值了100，还是不会影响最后n1的值，所以最后输出的n1的值是11，n2是列表，是可变类型，在函数定义处将n2添加了一个10，所以最后输出n2的值是[22,33,44,10]，示意图如下：
五、函数的返回值
函数返回多个值时，结果为元组，返回一个值则返回原类型，视情况判断是否需要返回(return)信息
代码示例：
每个字符串都有一个bool值，0的bool值是False，非0的bool值是True
print(bool(0)) #False print(bool(8)) #True
执行结果：
案例：将判断列表[10,29,34,23,44,53,55]中的数据是奇数还是偶数
def fun(num):
odd=[] #存奇数
even=[] #存偶数
for i in num:
if i%2:
odd.append(i)
else:
even.append(i)
return odd,even
#函数的调用
lst=[10,29,34,23,44,53,55]
print(fun(lst))
执行结果：
说明：
函数的返回值：
（1）如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】return可以省略不写
（2）函数的返回值，如果是1个，直接返回原类型
（3）函数的返回值，如果是多个，返回的结果为元组
所以案例中的返回值为元组，元组中有2个列表，第一个列表是奇数，第二个列表是偶数
- 没有返回值的情况
def fun1():
print('hello')
fun1()
执行结果：
说明：当没有返回值时，可以不写return
- 返回值是1个的情况
def fun1():
return 'hello'
res=fun1()
print(res)
执行结果：
说明：当返回值是一个时，返回原类型
- 返回值是多个的情况
def fun2():
return 'hello','world'
print(fun2())
执行结果：
说明：当返回值是多个值时，返回的是一个元组
六、函数的参数定义（默认值参数）
函数定义默认值参数
- 函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参
代码示例：
def fun(a,b=10): #b称为默认值参数
print(a,b)
fun(100)
fun(20,30)
执行结果：
说明：fun(100)只传递了一个参数，那么会将100传递给a,b的值保持默认10，输出则为100,10，fun(20,30)将20传递给a,30传递给b，此时b的默认值值被覆盖，所以输出为20,30
实参覆盖形参以print()函数为例：
在Pycharm中新建python 文件，写上print()函数，然后按住CTRL不放，鼠标点击print，即可跳转到print函数的调用处，如下图，print函数有一个end形参的值是' '即换行，那么我们来试试覆盖这个形参
代码示例：
#不覆盖end形参的情况，输出两个值时会默认换行
print('hello')
print('world')
#覆盖end形参的值为' '，输出两个值时会在同一行显示
print('hello',end=' ')
print('world')
执行结果：
说明：当不覆盖形参时，会使用形参的默认值，当覆盖形参后会使用实参的值
七、函数参数定义（个数可变的位置形参，个数可变的关键字形参）
1. 个数可变的位置参数
- 定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数
- 使用*定义个数可变的位置形参
- 结果为一个元组
2. 个数可变的关键字形参
- 定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
- 使用**定义个数可变的关键字形成
- 结果为一个字典
3. 个数可变的位置参数 代码示例
def fun(*args):
print(args)
fun(10)
fun(20,30)
fun(40,50,60)
执行结果：
说明：当不知道多少个位置形参时，定义函数时可以使用*args进行定义，支持多个位置实参的输入，输出结果是一个元组
4. 个数可变的关键字形参 代码示例
'''个数可变的关键字形参'''
def fun(**args):
print(args)
fun(a=1)
fun(a=2,b=3)
fun(a=4,b=5,c=6)
执行结果：
说明：当不知道要输入多少个关键字形参时，定义函数时参数可以使用**args来代替，调用函数时支持输入多个关键字形参，输出结果是字典
再看，print函数定义时有一个参数是*args，表示print函数支持多个形参输入，所以pint支持同时输入多个实参
print('hello','world','python')
执行结果：
可否同时定义多个个数可变的位置形参和个数可变的关键字形参？答案是：一个函数中只能定义一个位置形参和关键字形参，而且必须位置形参在前，否则代码会报SyntaxError: invalid syntax错误
'''是否可定义多个位置形参和关键字形参？'''
#以下代码会报错，同一个函数中，只能定义一个位置形参
def fun2(*args,*args1):
pass
#以下代码会报错，同一个函数中，只能定义一个关键字形参
def fun3(**args1,**args2):
pass
#同一个函数中可以同时定义一个位置形参和一个关键字形参，但是必须是位置形参在前
def fun4(*args1,**args2):
pass
#以下代码会报错，同一个参数中定义位置形参和关键字形参是，必须是位置形参在前
def fun5(**args1,*args2):
pass
八、函数的参数总结
1. 位置实参
'''函数的参数总结'''
#位置实参
def fun(a,b,c): #a,b,c在函数的定义处，所以是形式参数
print('a=',a)
print('b=', b)
print('b=', c)
#函数的调用
fun(10,20,30) #函数调用时的参数传递，称为位置传参
执行结果：
2. 将序列中的每个元素都转换为位置实参
#位置实参
def fun(a,b,c): #a,b,c在函数的定义处，所以是形式参数
print('a=',a)
print('b=', b)
print('b=', c)
#函数的调用
lst=[11,22,33]
fun(*lst)
执行结果：
说明：将列表的值转换为位置实参时，需要在方法调用处的列表前加一个*，最终形式为fun(*lst)，如果写成fun(lst)会报TypeError: fun() missing 2 required positional arguments: 'b' and 'c'，如下图
3. 关键字实参
def fun(a,b,c): #a,b,c在函数的定义处，所以是形式参数
print('a=',a)
print('b=', b)
print('b=', c)
#函数的调用
fun(a=100,b=200,c=300) #函数的调用，所以是关键字实参
执行结果：
4. 将字典中的每个键值对都转换为关键字实参
def fun(a,b,c): #a,b,c在函数的定义处，所以是形式参数
print('a=',a)
print('b=', b)
print('b=', c)
#函数的调用
dic={'a':111,'b':222,'c':333}
fun(**dic) #在函数调用时，将字典中的键值对都转换为关键字实参传入
执行结果：
5. 默认值形参
'''默认值形参'''
def fun(a,b=10): #b是在函数的定义处，所以b是形参，而且进行了赋值，所以b称为默认值形参
print('a=',a)
print('b=', b)
6.个数可变的位置形参和个数可变的关键字形参
def fun2(*args): #个数可变的位置形参
print(args)
def fun3(**args2): # 个数可变的关键字形参
print(args2)
fun2(10,20,30,40)
fun3(a=11,b=22,c=33,d=44,e=55)
执行结果：
位置实参和关键字实参存在于同一个函数
def fun4(a,b,c,d):
print('a=',a)
print('b=', b)
print('c=', c)
print('d=', d)
#函数调用
fun4(10,20,30,40) #位置实参传递
fun4(a=11,b=22,c=33,d=44) #关键字实参传递
fun4(10,20,c=30,d=40) #前两个参数，采用的是位置实参传递，后两个采用关键字实参传递
执行结果：
练习：参数c，d只能采用关键字实参传递
def fun4(a,b,*,c,d): #从*之后的参数，在函数调用时，只能采用关键字参数传递
print('a=',a)
print('b=', b)
print('c=', c)
print('d=', d)
fun4(a=11,b=22,c=33,d=44)
fun4(10,20,c=30,d=40)
执行结果：
7. 在Pyton中，一个函数的参数可以同时存在位置形参、关键字形参，个数可变的位置形参和个数可变的关键字形参，如下：
'''函数定义时的形参的顺序问题，以下几种参数的混合写法都是可以的'''
def fun5(a,b,*,c,d,**args):
pass
def fun6(*args,**args2):
pass
def fun7(a,b=10,*args,**args2):
pass
------------------------------以上为Python中函数的基本内容