一、函数的定义与调用
1、什么是函数：
函数就是执行特定任务和完成特定功能的一段代码。
2、为什么需要函数
（1）复用代码；（2）隐藏实现细节；（3）提高可维护性；（4）提高可读性便于调试；
3、函数的创建
举例：创建一个加法函数：
def calc(a,b): #a和b称为形式参数，简称形参，形参的位置是在函数的定义处
c=a+b
return c #返回的c是结果
result = calc(10,20) #调用函数；10和20称为实际参数的值，简称实参，实参的位置是函数的调用处
print(result)
二、函数的参数（难点）
函数的参数分为：
（1）函数的调用时的实际参数。
（2）函数的定义时的形式参数。
1、函数的参数传递-------位置实参，关键字实参
（1）位置实参：
根据形参对应的位置进行参数传递。
def calc(a,b): #a和b称为形式参数，简称形参，形参的位置是在函数的定义处
c=a+b
return c #返回的c是结果
result = calc(10,20) #调用函数；10和20称为实际参数的值，简称实参，实参的位置是函数的调用处
print(result)（2）关键字实参：
根据形参名称进行参数传递。
def calc(a,b):
c=a+b
return c
res=calc(b=10,a=20) # 等号左侧的变量的名称称为 关键字参数
print(res)
2、函数参数传递的内存分析
def fun(arg1,arg2):
print("arg1:",arg1)
print("arg2:",arg2)
arg1 = 100 #令形参arg1等于100
arg2.append(10) #给形参arg2末尾加上10
print("arg1:",arg1)
print("arg2:",arg2)
print("--------------------------")
n1 = 11
n2 = [22,33,44]
print("n1:",n1)
print("n2:",n2)
print("--------------------------")
fun(n1,n2) #执行函数
print("--------------------------")
print("n1:",n1) #函数执行完毕后，你会发现，n1没有变化，n2变化了。
print("n2:",n2)代码结果：
总结：?? ?函数调用过程中，进行参数的传递
?? ?如果是不可变对象，在函数体的修改不会影响实参的值；
?? ?如果是可变对象，在函数体的修改会影响实参的值。
注意：字符串是不可变对象，列表是可变对象；所以上面代码中最后n1没有变，n2变化了。
3、函数的默认值参数
函数定义时，给形参定义默认值，只有与默认值不符的时候才需要传递实参。
def fun(a,b=10):#b=10是默认值参数
print(a,b)
#函数的调用
fun(100) #只传一个参数，b采用默认值
fun(20,30) #30将默认值10替换4、个数可变的位置参数与关键字参数
1、个数可变的位置参数
（1）定义函数时，无法事先确定传递的位置实参的个数时，使用可变的位置参数
（2）使用*定义个数可变的位置形参
（3）结果为一个元组
def fun1(*args):#函数定义时的，可变的位置参数。 而且个数可变的位置参数，函数中只能有一个。
print(args)
print(args[0])#输出坐标为0的那一个
fun1(10)
fun1(11,20,30)2、个数可变的关键字参数
（1）定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字参数
（2）使用**定义个数可变的关键字形参
（3）结果为一个字典
def fun2(**args):#个数可变的关键字参数，函数中只能有一个。
print(args)
fun2(a=10)
fun2(a=10,b=20,c=30)3、两个可变参数的顺序
个数可变的位置参数 只能放在 个数可变的关键字参数 之前。*只能在**之前。
def fun3(*args1,**arg2):#个数可变的位置参数 只能放在 个数可变的关键字参数 之前。*只能在**之前。
pass5、函数的参数总结:
1、函数的实参传递：
（1）函数调用时按照位置的参数传递，称为位置传参。?
（2）函数在调用时，将列表中的每个元素都转换为位置实参传入。列表前加 * 。?? ?
（3）函数关键字的调用，是关键字实参。
（4）在函数调用时，将字典中的键值对都转换为关键字实参传入，字典前加 ** 。
代码：
def fun(a,b,c):#a,b,c在函数的定义处，所以是形式参数。
print('a=',a)
print('b=',b)
print('c=',c)
#函数的调用：
fun(10,20,30) #函数调用时的参数传递，称为位置传参。
print("------------------------------------")
lst=[11,22,33]
fun(*lst) #函数在调用时，将列表中的每个元素都转换为位置实参传入。列表前加 * 。
print("------------------------------------")
fun(c=200,a=100,b=222) #函数的调用，所以是关键字实参。
print("------------------------------------")
dic={'a':555,'b':666,'c':777}
fun(**dic) #在函数调用时，将字典中的键值对都转换为关键字实参传入，字典前加 ** 。2、函数的形参
（1）默认值形参
def fun(a,b=10): #b是在函数的定义处，所以b是形参，而且进行了赋值，所以b称为默认值形参。
print('a=',a)
print('b=',b)（2）个数可变的位置形参 与 个数可变的关键字形参
def fun2(*args1): #个数可变的位置形数
print(args1)
def fun3(**args2): #个数可变的关键字形参
print(args2)
fun2(10,20,30,40)
fun3(a=11,b=22,c=33,d=44,e=55)（3）函数的形参中加入 * 。（也叫命名关键字参数）
def fun4(a,b,*,c,d): #从*之后的参数，在函数调用时，只能采用关键字参数传递。
print('a=',a)
print('b=',b)
print('c=',c)
print('d=',d)
fun4(a=10,b=20,c=30,d=40) #关键字实参传递
fun4(10,20,c=30,d=40) #前两个参数，采用的是位置实参传递，而c,d才用的是关键字实参传递。
''' c,d只能采用关键字实参传递'''
(4)函数定义时的形参的顺序问题 ?参数组合
def fun5(a,b,*,c,d,**args):
pass
def fun6(*args,**args2):
pass
def fun7(a,b=10,*args,**args2):
pass三、函数的返回值（return）
1、函数返回多个值时，结果为元组
例子：将一个列表中的数分为奇数和偶数
def fun(num):
odd=[] #存奇数
even=[] #存偶数
for i in num:
if i%2: #'''i与2的布尔值是ture'''
odd.append(i)
else:
even.append(i)
return odd,even
list=[10,29,34,23,44,53,55]
print(fun(list))结果：
判断布尔值：
print(bool(0)) #0的布尔值：False
print(bool(8)) #非0的布尔值：Ture2、函数的返回值总结：
（1）如果函数没有返回值【函数执行完毕之后，不需要给调用出提供数据】 ?return可以省略不写
（2）函数的返回值，如果是1个，直接返回类型
（3）函数的返回值，如果是多个，返回的结果是元组
3、函数在定义时，是否需要返回值，视情况而定。
print("------------------------------------")
def fun1():
print("hello")
fun1()
print("------------------------------------")
def fun2():
return"hello"
res=fun2()
print(res)
print("------------------------------------")
def fun3():
return 'hello','world'
print(fun3())四、函数变量的作用域（局部变量、全局变量）
1、局部变量
def fun(a,b):
c=a+b #c,就称为局部变量，因为c是在函数体内进行定义的变量；a、b为函数的形参，作用范围也是函数内部，相当于局部变量。
print(c)
# print(c) #因为a超出了起作用的范围（超出了作用域）所以会报错。
2、全局变量
name = "阿文" #name的作用范围是函数内部和外部都可以使用 ---> 称为全局变量。
print(name)
def fun2():
print(name)
#调用函数
fun2()
def fun3():
global age #函数内部定义的变量，局部变量，局部变量可以使用global声明，这个变量实际上就变成了全局变量。
age=20
print(age)
fun3()
print(age)五、递归函数
1、什么是递归函数：
如果在一个函数的函数体内调用了这个函数本身，该函数就称为递归函数。
2、递归的组成部分：
递归调用与递归终止的条件
3、递归的调用过程：
每递归调用一次函数，都会在栈内存分配一个栈帧
每执行完一次函数，都会释放相应空间
4、递归的优缺点：
优点：思路和代码简单
缺点：占用内存多，效率低下
使用递归来计算阶乘：
def fac(n):
if n==1:
return 1
else:
res=n*fac(n-1)
return res
print(fac(6)) #计算6的阶乘使用递归来计算斐波那契数列：
def fib(n):
if n==1:
return 1
elif n==2:
return 1
else:
return fib(n-1)+fib(n-2)
#计算斐波那契数列第六位上的数字
print(fib(6))
print("------------------------------")
#输出斐波那契数列前六位的数字
for i in range(1,7):
print(fib(i))总结图：
?注：图片来自于哔哩哔哩@Python_子木
以上就是python函数的主要内容了，感谢观看，阿哩嘎豆！！OVO！！
?