在程序中，具备某种功能的工具就是"函数"，实现准备工具的过程就是"函数的定义"，"拿来就用"就是函数的调用。
函数的语法结构原则：先定义，后调用
函数的定义相当于实现将函数体代码保存起来，然后将内存地址赋值给函数名，函数名就是对函数体代码的引用。
# 函数语法结构
def 函数名(参数1,参数2,...):
'''函数注释'''
函数体
return 值
1.def(必须的)
是定义函数的关键字
2.函数名(必须的)
是函数的名字 相当于变量名
函数名的命名规范与风格遵循变量名的
3.参数1,参数2(可选的)
参数可以没有也可以有多个
表示在使用函数之前需要满足的一些条件
4.函数注释(可选的)
类似于产品说明书
主要用于介绍函数功能 参数使用 及其他情况
5.函数体代码(必须的)
函数核心的代码逻辑(重要)
6.return返回值(可选的)
使用函数之后反馈给使用者的结果 可以有也可以没有
1、函数必须先定义，后使用
2、函数在定义阶段只检测语法，不运行代码
3、函数在调用阶段才会执行函数体代码
参数是函数的调用者向函数体传值的媒介，若函数体代码逻辑依赖外部传来的参数时则需要定义为参函数
def my_min(x,y):
res=x if x < y else y
return res
无参函数
def interactive():
user=input('user>>: ').strip()
pwd=input('password>>: ').strip()
return (user,pwd)
函数体为pass代表什么都不做，称之为空函数。定义空函数通常是有用的，因为在程序设计的开始，往往是先想好程序都需要完成什么功能，然后把所有功能都列举出来用pass充当函数体“占位符”，这将使得程序的体系结构立见，清晰且可读性强。
函数的调用函数名加括号即函数调用，需要注意在函数定义时需要传入几个参数，在调用时就要传入几个参数
按照在程序出现的形式和位置，可将函数的调用形式分为三种：
#1、语句形式： foo() #2、表达式形式： i = my_min(1,2) #将调用函数的返回值赋值给x n = 10 * my_min(1,2) #将调用函数的返回值乘以10的结果赋值给n #3、函数调用作为参数的形式： # my_min（2，3）作为函数my_min的第二个参数，实现了取1,2,3中的较小者赋值给m i = my_min(1，my_min（2，3）)函数在定义与调用阶段底层原理
函数的返回值1.在内存空间中申请一块空间存储函数体代码
2.将函数体代码所在的空间地址绑定给函数名
3.函数名加括号则会执行函数体代码
若需要将函数体代码执行的结果返回给调用者，则需要用到return。
return后无值或直接省略return，则默认返回None，return的返回值无类型限制，且可以将多个返回值放到一个元组内。
def test(x,y,z):
return x,y,z #等同于return (x,y,z)
res = test(1,2,3)
print(res)
# (1, 2, 3)
return是一个函数结束的标志,函数内可以有多个return，但只执行一次函数就结束了，并把return后定义的值作为本次调用的结果返回。
函数参数 形参与实参函数的参数分为形式参数和实际参数，简称形参和实参：
形参即在定义函数时，def后 括号内 声明的参数。形参本质就是一个变量名，用来接收外部传来的值。
实参即在调用函数时，括号内传入的值，值可以是常量、变量、表达式或三者的组合:
#1：实参是常量 res = my_min(1,2) #2：实参是变量 a=1 b=2 res=my_min( a , b ) #3：实参是表达式 res=my_min( 10*2 , 10*my_min(3,4) ) #4：实参可以是常量、变量、表达式的任意组合 a=2 my_min( 1 , a , 10*my_min(3,4))
在调用有参函数时，实参（值）会赋值给形参（变量名）。
形参与实参的使用 位置参数位置参数指的是按顺序定义的参数，需要从两个角度去看：
1、在定义函数时，按照从左到右的顺序依次定义形参,称为位置形参，凡是按照这种形式定义的形参都必须被传值
2、在调用函数时，按照从左到右的顺序依次传入位置实参，传入的个数必须与定义的位置形参一一对应
def register(name,age,sex): #定义位置形参：name，age，sex，三者都必须被传值
print('Name:%s Age:%s Sex:%s' %(name,age,sex))
register() #TypeError：缺少3个位置参数
register('lili',18,'male') #对应关系为：name=’lili’,age=18,sex=’male’
# Name:lili Age:18 Sex:male
关键字参数
在调用函数时，实参可以是key=value的形式，称为关键字参数，凡是按照这种形式定义的实参，可以完全不按照从左到右的顺序定义，但仍能为指定的形参赋值
需要注意:
在调用函数时，实参也可以是按位置或按关键字的混合使用，但必须保证关键字参数在位置参数后面，且不可以对一个形参重复赋值
简单记忆：形参在定义时，格式越简单，写在越前面，越复杂，写在越后面
def register(name,age,sex): #定义位置形参：name，age，sex，三者都必须被传值
register(sex='male',name='lili',age=18)
# Name:lili Age:18 Sex:male
register('lili',sex='male',age=18) #正确使用
register(name='lili',18,sex='male')
#SyntaxError：关键字参数name=‘lili’在位置参数18之前
register('lili',sex='male',age=18,name='jack')
#TypeError：形参name被重复赋值
默认参数
在定义函数时，就已经为形参赋值，这类形参称之为默认参数，当函数有多个参数时，需要将值经常改变的参数定义成位置参数，而将值改变较少的参数定义成默认参数。
例如编写一个注册学生信息的函数，如果大多数学生的性别都为男，那完全可以将形参sex定义成默认参数
def register(name,age,sex='male'): # 默认sex的值为male
print('Name:%s Age:%s Sex:%s' %(name,age,sex))
register('tom',17) #大多数情况,无需为sex传值,默认为 male
# Name:tom Age:17 Sex:male
register('Lili',18,'female') #少数情况,可以为sex传值female
# Name:Lili Age:18 Sex:female
注意：
1、默认参数必须在位置参数之后
2、默认参数的值仅在函数定义阶段被赋值一次
3、默认参数的值通常应设为不可变类型
简单记忆：形参在定义时，格式越简单，写在越前面，越复杂，写在越后面
x=1
def foo(arg = x):
print(arg)
x=5 #定义阶段arg已被赋值为1，此处的修改与默认参数arg无任何关系
foo() # 结果为 1
'arg 指向的是一个固定列表 因此每一次都是对同一个列表进行修改'
def foo( n , arg=[] ):
arg.append(n)
return arg
foo(1) # [1]
foo(2) # [1, 2]
foo(3) # [1, 2, 3]
'每次调用是在上一次的基础上向同一列表增加值，修改如下'
def foo(n,arg=None):
if arg is None:
arg=[]
arg.append(n)
return arg
foo(1) # [1]
foo(2) # [2]
foo(3) # [3]
可变长形参__ *号 在形参中的使用 ( *args )
实现需求： 函数无论传入多少位置实参 都能够正常运行。
*号, 在形参中使用时，用于接受传入的多余的位置实参，并组织成元组的形式赋值给 * 后的变量名
def func(*a):
print(a)
func() # ()
func(1) # (1,)
func(1, 2) # (1, 2)
func(1, 2, 3, 4, 5) # (1, 2, 3, 4, 5)
def func(x,y,*a):
print(x,y,a)
func(1, 2) # 1 2 ()---> x = 1, y = 2, a = ()
func(1, 2, 3, 4, 5) # 1 2 (3, 4, 5)---> x = 1, y = 2, a = (3, 4, 5)
可变长形参__ ** 号 在形参中的使用 ( **kwargs )
实现需求： 函数无论传入多少关键字参数 都能够正常运行。
** 号在形参中使用，用于接受 多余的关键字参数 ，并组织成 字典的形式 赋值给 **号后面的变量名
def func(**b):
print(b)
func() # {}
func(x=1,y=2,z=3) # {'x': 1, 'y': 2, 'z': 3}
def func(x,y,**b):
print(x,y,b)
func(y=2,x=3) # 3 2 {}
func(x=1,y=2,z=3,r=9) # 1 2 {'z': 3, 'r': 9}
可变长实参__ * 号在实参中的使用
实现需求： 函数需要传入的形参是 * args ，列表中有很多元素 如何按照位置一一传入
def index(*args):
print(args)
list1 = [1,2,3,4]
index(list1) # ([1, 2, 3, 4],) ---> 赋值给 args的元组中只有一个元素，一个列表,
index(*list1) # (1, 2, 3, 4) ---> 将列表中的元素打散成一个个的位置实参，并一一传入，再组成了元组赋值给 args
可变长实参__ ** 号在实参中的使用*号, 在实参中使用时，将列表、元组中的元素打散成一个个的位置实参，并一一传值
实现需求： 函数需要传入的形参是 **kwargs , 将 字典中的键值对 转换成关键字参数传入
def index(**kwargs):
print(kwargs)
dict = {'name':'frank','age':18}
index(dict)
# 报错，index 不需要传入位置参数，但是却传入了一个位置实参
index(**dict) # {'name': 'frank', 'age': 18}--> kwargs
'1、** 将 dict 打散成 关键字实参--> name="frank",age = 18 '
"2、关键字实参传入，** 将两组关键字实参组织成字典形式 {'name': 'frank', 'age': 18}"
"3、组织后的字典 赋值给 kwargs"
命名关键字参数 (了解)** 号, 在实参中使用时，将字典中的键值对打散成一个个的关键字实参，并一一传值
在定义形参时，用* 号作为一个分隔符号，* 号之后的形参称为关键字参数。对于这类参数，在函数调用时，必须按照key=value的形式为其传值，且必须被传值
def register(name,age,*,sex,height): #sex,height为命名关键字参数
pass
register('lili',18,sex='male',height='1.8m') #正确使用
register('lili',18,'male','1.8m')
# TypeError:未使用关键字的形式为sex和height传值
register('lili',18,height='1.8m')
# TypeError没有为命名关键字参数height传值。
命名关键字参数也可以有默认值，从而简化调用
def register(name,age,*,sex='male',height):
print('Name:%s,Age:%s,Sex:%s,Height:%s' %(name,age,sex,height))
register('lili',18,height='1.8m')
# Name:lili,Age:18,Sex:male,Height:1.8m
注意：sex不是默认参数，height也不是位置参数，因为二者均在* 号后，所以都是命名关键字参数，形参sex=’male’属于命名关键字参数的默认值，因而即便是放到形参height之前也不会有问题。另外，如果形参中已经有一个 * args了，命名关键字参数就不再需要一个单独的* 作为分隔符号了
def register(name,age,*args,sex='male',height):
print('Name:%s,Age:%s,Args:%s,Sex:%s,Height:%s' %(name,age,args,sex,height))
register('lili',18,1,2,3,height='1.8m') #sex与height仍为命名关键字参数
# Name:lili,Age:18,Args:(1, 2, 3),Sex:male,Height:1.8m
