函数
为何要用函数？
如果不使用函数，写程序时将会遇到这三个问题：
1.程序冗长
2.程序的扩展性差
3.程序的可读性差
如何使用函数
先定义函数，后调用。
- 定义函数：
def 函数名(param1、param2)：
"""
函数功能的描述信息
：param1：描述
：param2：描述
：return：返回值
"""
code1
code2
...
return 返回值
- 调用函数
函数名(param1,param2)
函数定义阶段
def func():
bar() # 不属于语法错误，不会报错
print('*'*50)
1.只检测语法，不执行函数体代码
函数调用阶段
1.执行函数体代码
定义函数的三种形式
一、无参函数
在函数定义阶段括号内没有参数，称为无参函数。需要注意的是：定义时无参，意味着调用时也无需传入参数。
如果函数体代码逻辑不需要依赖外部传入的值，必须得定义成无参函数。
def input_user_pwd():
username = input('请输入你的用户名>>>>').strip()
pwd = input('请输入你的密码>>>>').strip()
return username,pwd
二、有参函数
在函数定义阶段括号内有参数，称之为有参函数。需要注意的是：定义时有参，意味着调用时也必须传入参数。
如果函数体代码逻辑需要依赖外部传入的值，必须得定义成有参函数。
def self_max(x,y):
if x >y:
return x
return y
res = self_max(10,20) # res接收返回值
print(res) # 20
三、空函数
当你只知道你需要实现某个功能，但不知道该如何用代码实现时，你可以暂时写一个空函数，然后实现其他的功能。
def register():
pass
函数的返回值
一、什么是返回值
函数内部代码经过一系列逻辑处理获得的结果。
def input_user_pwd():
username = input('请输入你的用户名>>>>').strip()
pwd = input('请输入你的密码>>>>').strip()
return username,pwd
二、为什么要有返回值
如果需要在程序中拿到函数的处理结果做进一步的处理，则需要函数必须要有返回值。
需要注意的是：
- return是函数结束的标志，函数内可以有多个return，只要执行到return，函数就会结束。
- return的返回值可以是任意数据类型
- return的返回值无个数限制，即可以使用逗号隔开返回多个值
- 没有return或return None：返回None
- 返回1个值：返回值是该值本身，可以是是任意数据类型
- 返回多个值：返回的是元组
返回多个值，如果不想让return帮你处理，自己手动加上你想返回的数据类型符号。
def func():
return [[1,2,3,4],[1,2,3,4],[1,23,5]]
res = func()
print(res) # [[1, 2, 3, 4], [1, 2, 3, 4], [1, 23, 5]]
三、为什么函数返回多个值是以元组返回？
函数不希望自己处理的结果被修改
1.所有的函数都有返回值，无论你写不写return，python中所有的函数都有返回值，不写的情况下默认返回None。
2.光写return或者return None并不是为了考虑返回值，而是为了结束函数的运行。
函数参数
一、形参与实参
1.1形参
在函数定义阶段括号内定义的参数，称之为形式参数，简称形参，本质就是变量名。
def save_file(content):
with open(r'user_info.txt','a',encoding='utf-8') as fw:
fw.write(content)
return True
1.2实参
在函数调用阶段括号内传入的参数，称之为实际参数，简称实参，本质就是变量的值。
save_file(f'{username}:{pwd}:1500:0')
二、位置参数
2.1 位置形参
在函数定义阶段，按照从左到右的顺序依次定义的形参，称之为位置形参。
特点：按照位置定义的形参，都必须被传值，多一行不行，少一行不行。
def func(x,y): # x,y就是位置形参
print(x)
print(y)
2.2 位置实参
在函数调用阶段，按照从左到右的顺序依次定义的实参，称之为位置实参。
特点：按照位置为对应的形参依次传值。
func(1,2) # 1，2就是位置实参
三、默认形参
在定义阶段，就已经被赋值。
在调用的时候就可以不为默认值形参传值，默认使用定义阶段就已经绑定的值
在调用的时候，如果可以给默认形参传值，传了那么就使用你传的值。
在定义阶段，默认形参必须放在位置形参后面。
默认形参的值通常应该是不可变数据类型。默认形参的值如果是可变数据类型，每调用一次函数，默认形参的值就会被实参的值代替，从而使后面多次调用函数处理的结果出现错误。
# 给默认形参传值
def self_max(x,y=100): # y=100为默认形参
if x > y:
return x
return y
res = self_max(200) # 200是为x传值
res1 = self_max(200,1000) # 1000给默认形参传值了，那么y=1000
res2 = self_max(y=200,x=1000) # 通过关键字实参给默认形参传值
print(res1,res2) # 1000 1000
# 调用函数阶段，可以不用给默认形参传值
def register(username,age,gender='male'): # 定义默认形参为gender='male'
print(username,age,gender)
register('jason',18) # 调用函数，不需要给默认形参传值
register('tank',28)
register('egon',84)
register('nick',19)
register('xiaohou',17,'female') # 调用函数，不同的，需要给默认形参传值
jason 18 male
tank 28 male
egon 84 male
nick 19 male
xiaohou 17 female
def register(name,hobby,hobby_list=[]): # 定义阶段hobby_list列表为空
hobby_list.append(hobby) # 在列表中添加爱好
print(f"{name}更喜欢{hobby_list}")
register('nick','read') # 在函数执行结束，'read'就会被当做默认形参存放在列表中
register('tank','zuopiao') # 在函数执行结束，'zuopiao'就会被当做默认形参存放在列表中
register('jason','piao') # 在函数执行结束，'piao'就会被当做默认形参存放在列表中
nick更喜欢['read']
tank更喜欢['read', 'zuopiao']
jason更喜欢['read', 'zuopiao', 'piao']
# 解决默认形参是可变类型结果出现的问题
# 函数每次调用，都将默认形参hobby_list置空
def register(name,hobby,hobby_list=[]):
hobby_list.append(hobby)
print(f"{name}更喜欢{hobby_list}")
register('nick','read',[])
register('tank','zuopiao',[])
register('jason','piao',[])
def register(name,hobby,hobby_list=None): # 默认形参为None
if hobby_list ==None:
hobby_list = []
hobby_list.append(hobby)
print(f"{name}更喜欢{hobby_list}")
register('nick','read') # 位置实参中，没有给默认形参传值，默认为None
register('tank','zuopiao') # 位置实参中，没有给默认形参传值，默认为None
register('jason','piao') # 位置实参中，没有给默认形参传值，默认为None
四、关键字实参
在调用函数时，按照key = value的形式为指定的参数传值，称为关键字实参。
特点：可以打破位置的限制，但仍能为指定的形参赋值。
注意：
1.可以混用位置实参和关键字实参，但是位置实参必须放在关键字实参的左边。
2.可以混用位置实参和关键字实参，但不能对一个形参重复赋值。
func(y=2,x=1)
func(x,y=2)
func(y=2,x) # 报错，位置实参必须在关键字实参左边
func(x,x=1) # 报错，不能重复对一个形参赋值
位置形参可以接收位置实参和关键字实参的值。
默认形参可以接收位置实参和关键字实参的值。
def my_max(x,y=100): # 位置形参接收关键字实参的值，默认形参接收关键字实参的值
if x > y:
return x
return y
res = my_max(y=200,x=1000)
print(res)
五，可变长参数
可变长参数：指的是在调用函数时，传入的参数个数可以不固定
调用函数时，传值的方式无非两种，一种是位置实参，另一种是关键字实参。因此形参需要两种解决方法，来分别接收溢出的位置实参(*)与关键字实参(**)。
一、可变长形参值*
形参中的*会将溢出的位置实参全部接收，然后存储成元组的形式，然后把元组赋值给*后的参数。需要注意的是：*后的参数名约定俗成为args。
def func(x,y,*z): #*args将溢出的位置实参存储成元组形式。赋值给*后面的参数
print(x,y,z)
func(1,2,3,4,5,5,5,66,99,44,89)
1 2 (3, 4, 5, 5, 5, 66, 99, 44, 89)
二、可变长实参之*
实参中的*，*会将*后的参数循环取出，打散成位置实参。以后但凡碰到实参中带*的，它就是位置实参，应该马上打散成位置实参去看。
def func(x,y,z,m,n,o):
print(x,y,z)
func(*[1,2,3,4,5,6]) # 将*后面的参数打散成位置实参传给位置形参
1 2 3
三、可变长形参之**
形参中的**会将溢出的关键字实参全部接收，存储成字典的形式，然后把字典赋值给**后的参数。需要注意的是：**后的参数名约定俗成为kwargs。
def func(x,y,**z): # 将多余的关键字实参存储成字典的形式，赋值给**后的参数。
print(x,y,z)
func(x=1,y=2,z=3,a=1,b=2,c=3)
1 2 {'z': 3, 'a': 1, 'b': 2, 'c': 3}
四、可变长实参之**
实参中的**，**会将**后的参数的值循环取出，打散成关键字实参。以后但凡碰到实参中带**的，它就是关键字实参，应该马上打散成关键字实参去看。
def func(x,y,z):
print(x,y,z)
d = {'x':1,'y':2,'z':3}
func(**d) # 等价于func(x=1,y=3,z=3)
总结*与**
*在形参中能够接收多余的位置实参，并存储成一个元组，赋值给*后面的变量名
**在形参中能够接收多余的关键字实参，并存储成一个字典，赋值给**后面的变量名。
*在实参中*能够将列表、元组、集合、字符串打散成位置实参的形式传递给函数
**在实参中能够将字典打散成key=value的形式，按照关键字参数传递给函数。
python中推荐*和**通用的写法
def func(*args,**kwargs): # 无论是位置实参和关键字实参都能够传参
print(args,kwargs)
func(1,2,3,4,5,x=1,y=2,z=3)
(1, 2, 3, 4, 5) {'x': 1, 'y': 2, 'z': 3}