一.函数
1.引入
我们知道圆的面积计算公式为： S = πr^2,当我们知道半径r的值时，
就可以根据公式计算出面积
假设我们需要计算3个不同大小的圆的面积：
r1 = 1
r2 = 2
r3 = 3
#1.求r1的面积：
s1 = 3.14*r1**2
print(s1)
#2.求r2的面积：
s2 = 3.14*r2**2
print(s2)
#1.求r3的面积：
s3 = 3.14*r3**2
print(s3)当我们求不同的r的面积的时候，发现有好多重复的代码。比如print()函数需要写3遍。3.14也需要写3遍。导致我们
程序代码重复率不高。因此我们可以使用函数提高代码的重复率。
2.函数的定义
函数是组织好的，可重复使用的，用来实现独立功能的代码段。
函数可以提高程序代码的重复率
3.函数的格式
注意：
（1）函数名称必须遵循 标识符 规则 数字，字母 ，下划线，并且不能以数字开头不能使用关键
（2）函数先定义后调用
（3）函数不调用是不执行的。
（4）函数可以调用多次
2.函数的调用：函数名（）
练习1：定义一个求r = 3
#定义一个求圆面积的函数
def area ():
s = 3.14 * 3 ** 2
print(s)
#调用函数
area()运行结果：
3.函数调用的本质
def area ():
s = 3.14 * 3 ** 2
print(s)
print(id(area))
area1 = area
print(id(area1))
area1()运行结果：
area 和area1的内存地址是一样的
4.定义带有参数的函数
格式:
注意:
（1）调用的时候，这个函数定义了几个参数，就需要传递几个参数，参数值和参数名称是按函数
声明中定义的顺序匹配起来的。
（2）定义函数时“参数1，参数2....”,用来接受参数用的，称为“形参”。
调用函数时括号里的参数，用来传递给函数用的，称为“实参”
上面的练习我们求圆的面积时，是不能修改半径的，现在我们定义带参数的函数来写一下：
#定义一个求圆面积的函数
def area (r):
s = 3.14 * r ** 2
print(s)
area(2)
area(3)
area(4)运行结果：
5.定义带返回值的函数
所谓“返回值”，就是程序中函数完成一件事情后，最后调用的结果。
调用着根据需求利用返回值做不同的操作
练习：定义一个求圆的面积的函数，并且将面积返回给调用者
#定义一个求圆面积的函数
def area(r):
s = 3.14 * r ** 2
return s
mianji = area(3)#调用函数将返回值，赋值给变量“mianji”
print(mianji)运行结果如下
（1）返回多个值
格式：
练习：定义一个求圆的面积和周长的函数，并将面积，周长返回给调用者
#定义一个求圆面积和周长的函数
def area(r):
s = 3.14 * r ** 2
c = 2 * 3.14 * r
return s,c
#使用一个变量ret,接受多个值
ret = area(3)
print(ret)
#使用等量变量来接受返回值
a , b = area(3)
print("面积为:", a)
print("周长为:",b)运行结果如下：
注意：
1.如果函数不写返回值，默认返回None
2.return关键字有两个作用，一个作用是返回内容，另一个作用是结束此方法（return后面的代码不会执行，
因此一般不建议在return 后面写代码）
二.函数的参数
在python中函数参数的定义方式有以下4种方式。
1.位置参数
我们传参数的时候，实参传递的顺序按照形参定义的顺序进行传递
例：
2.关键字参数
这种传递方式实参可以不按照形参定义的顺序进行传递
但是实参必须以形参等于实参的格式进行书写
例：
#关键字传递参数：
def sum_2_num(num1,num2,num3):
total = num1 + num2 + num3
print(total)
sum_2_num(num3 = 1,num1 = 5,num2 = 6)注意：关键字参数和位置参数同时使用时，关键字参数必须在位置参数的前面定义
def sum_2_num(num1,num2,num3):
total = num1 + num2 + num3
print(total)
#注意关键参数必须在位置参数后面
sum_2_num(2,num3 = 2 ,num2 = 3)
sum_2_num(num3 = 2 ,num2 = 3,2)#报错3.默认参数
在我们定义参数的时候，我们给参数一个默认值，在我们调用函数的时候，如果不给有默认值的形参传参，
会自动采用默认值。
当某个值变化较小的时候，我们就可以使用默认参数。
#保存用户信息
def User_info(Name = "贾克斯",age = 20,sex = "man"):
print("用户信息:")
print("姓名:%s,年龄:%d,性别:%s"%(Name,age,sex))
#调用函数
#不传参数
User_info()
#只传一个参数
User_info("武器大师")
#传是三个参数
User_info("金克斯",18,"woman")运行结果：
4.可变参数
如果函数中的参数过多，我们一个个定义非常麻烦，调用起来也比较麻烦，因此python给我们提供了
可变参数类型。能处理比当初声明时更多的参数，会将参数变成元组（*args）或者字典（**kwargs）
（1）元组参数 *args
通过给形参前面添加 * 使参数变成一个元组，所有传递的参数变成元组的元素
注意：args参数名称可以任意命名，但是一般我们就用args
#元组参数args
def func(*args):
print(args)
#获取元组中的元素
print(args[0],args[1])
func("q","w","e","r")运行结果:
*具有打散序列的功能
我用几个例子来解释下：
#定义带三个参数的函数
def func(a,b,c):
print(a,b,c)
#定义一个字符串
tup = "123"
# * 打散了这个字符串
func(*tup)运行结果：
注意：上面的“tup ="123”"他只能是长度是3的字符串，因为函数定义的参数只有三个，
如果字符串长度过长则会报错。
例2：
#打散元组
tup = (1,2,3,4)
print(*tup)
#打散列表
lst = [1,2,3,4]
print(*lst)
#打散字符串
s1 = "hello world"
print(*s1)
运行结果：
（2）字典参数
通过给形参前面添加 ** 使参数变成字典，所有传递的参数变成字典的键值对
这里传参要求键等于值的形式。
**kwargs 结果类型是字典，传递值是以key == value方式传入
例：
#字典参数
def func (**kwargs):
print(kwargs)
print(kwargs["name"],kwargs["age"],kwargs["sex"])
func(name="GnezIew",age=10,sex="男")
结果：
注意：**具有打散字典的功能
#打散字典
def func(name = "GnezIew",age = 10):
print(name,age)
dic = {"name":"赵四","age":30}
func(**dic)
运行结果:
注意事项:*args必须放在**kwargs前面
def func(*args,**kwargs):
print(args,kwargs["name"])
func(1,2,3,name = "GnezIew")运行结果:
函数参数总结：
定义函数时参数的顺序：位置参数，元组参数，默认参数，字典参数。
三.函数的嵌套及其调用
函数内部再嵌套函数。
例：
#函数的嵌套
def func1():
print("调用func1函数")
def func2():
func1()
print("调用func2函数")
func2()运行结果:
四.递归函数
如果一个函数在内部调用自身本身，这个函数就是递归函数。
使用递归函数的条件:
1.自己调用自己
2.必须留出口，否则会变成死循环
练习1：用嵌套函数向控制台打印3，2，1
#递归函数
def print_num(num):
print(num)
#留的出口
if num == 1:
return
print_num(num-1)
print_num(3)运行结果:
流程图如下
练习2：使用递归求1到10 的阶乘
#求1到10的阶乘
def jiecheng(num):
if num ==1 :
return 1
ret = jiecheng(num - 1)
return ret * num
for i in range (1,11):
num = jiecheng(i)
print("%d的阶乘为:"%i,num)运行结果:
