函数
函数就是具有某个具体功能的工具，函数可以帮助我们提高开发效率，避免代码过于繁琐，提高程序等的扩展性。
如何定义？
关键词：def
规则：函数名的命名规则与变量名一致，不能以关键字命名（*****），命名要做到见名知意。
# 函数在定义的时候只检测函数体的语法，不执行函数的代码。
***调用函数的固定格式：函数名()
# 函数名只要遇到括号就会立刻执行函数体代码；
# 代码中遇到函数名加括号，优先级最高；
# 先去执行函数，再看下面的代码。
函数包括有内置函数、自定义函数：
内置函数：python提前给你写好了的函数，直接调用就可以。如len()
自定义函数：必须先定义后调用****定义了的函数可以在任意位置调用。如：
l = [1,2,3,4,5] def my_len(): # 自定义函数 n = 0 for i in l: n += 1 print(n) # 5 res = my_len() print(res) # None # 由此可以看出，目前定义的函数有两个问题： 1.没有返回值，只能固定的执行打印操作 2.只能够固定的统计某一个容器类型的长度。
要想函数内返回给调用者值，必须用关键词return：
①不写return：函数默认返回None。如：
def func(): print('hahaha') # hahaha res = func() print(res) # None
②只写return：返回的也是None。如：
def func(): l = ['jason','egon','tank'] while True: for i in l: if i == 'egon': # break return # 当i为egon的时候 直接结束函数运行 print(i) # jason res = func() print(res) # None
ps：return除了可以返回值之外，还可以直接结束整个函数的运行。
③写return None：跟只写return是一样的。
④写return返回一个值：这个值可以是python任意类型数据。如：
def func(): return '123' def func1(): return [1,2,3] def func2(): return {'name':'jason'} def func3(): return (1,) def func4(): return {1,2,3,4,5} def func5(): return True print(func()) # 123 print(func1()) # [1, 2, 3] print(func2()) # {'name': 'jason'} print(func3()) # (1,) print(func4()) # {1, 2, 3, 4, 5} print(func5()) # True 可以看到，return返回的值可以是整型、列表、字典、元祖、集合、布尔值等各种python类型数据。
⑤写return返回多个值：return会自动将多个值一元祖的形式返回给调用者。如：
def func(): return 1,2,3,4 res = func() print(res) # 返回的是(1, 2, 3, 4) def func1(): return [1,2,3],[1,2,3],[1,2,3] res1 = func1() print(res1) # 返回的是([1, 2, 3], [1, 2, 3], [1, 2, 3]) def func2(): return {'name':'jason'},{'username':'tank'},{'user_name':'egon'} res2 = func2() print(res2) # 返回的是({'name': 'jason'}, {'username': 'tank'}, {'user_name': 'egon'}) # 不管你return的什么值，结果都以元祖的形式给你返回
如何不返回元祖？>>>自己手动加上你想返回的数据类型。如：
def func3(): return [[1,2,3,4],[1,2,3,4],[1,2,34]] # 想要返回的是列表类型 res3 = func3() print(res3) # 返回的是[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 34]] 列表类型
小结：
1.所有的函数都有返回值，无论写不写return，不写的情况下默认为None。
2.只写return或return None并不是为了考虑返回值，而是为了结束函数的运行。
函数的参数：形参和实参
形参：函数的定义阶段，()内写的变量名是该函数的形式参数
实参：函数的调用阶段，()内实际传入的值叫做实际参数
关系：形参相当于变量名，实参相当于变量的值。（函数调用传参的过程，就是给形参变量名赋值的过程）
注意：形参与实参的绑定关系只在函数的调用阶段有效，函数运行结束后关系自动解除。此外，只在函数内部有效，函数外部无任何影响
因此现在可以总结出函数的简易结构：
def 函数名(形参1，形参2......) :
"""函数的注释，用来描述该函数的作用以及各个参数的类型"""
函数体代码1
函数体代码2
...
return 函数的返回值
如：
def func(x,y) : """ 该函数的作用 ：param x：对形参x的解释 ：param y：对形参y的解释 ：return：对函数返回值的解释 """ print('ncegfbr') return 'ubvjhrsb'
此外，print(help(func))可以查看内置函数及自定义函数的注释。
位置参数：
位置形参：在函数定义阶段按照位置从左到右依次书写变量名，叫做函数的位置形参。（位置形参在调用的时候，必须为其传值）如：
def my_max(x,y): print(x,y) if x > y : return x else : return y res = my_max(1) # 报错（在调用函数的时候，少一个参数不行） res = my_max(1,2,3) # 报错（在调用函数的时候，多一个参数不行） res = my_max(1,2) # 结果为2，表明此时是一一对应关系，x对应1，y对应2
位置实参：在函数调用阶段，传入的参数会按照位置一一对应给形参。
ps：两种传参方式：
①直接按照位置以一对一，也就是上面的例子。
②指名道姓的传（关键字传参）
如：
def my_max(x,y): print(x,y) if x > y : return x else : return y res = my_max(x=1,y=2)
除此之外，还可以位置和关键字混合使用，如：
def my_max(x,y): print(x,y) if x > y : return x else : return y res = my_max(1,y=2)
但是，混合使用必须保证位置参数在关键字参数前面，且同一个形参不能被多次赋值。（越短越靠前，越长越复杂的越靠后）
默认值参数：（应用场景：当形参接收到的值比较单一的情况下）
在函数定义阶段，形参就已经被赋值了。
# 在调用的时候可以不为默认值形参传值，默认使用已经绑定的值；
# 在调用的时候如果可以给默认值形参传值，使用传后的值；
# 在定义阶段，默认值形参必须放啊在位置形参的后面。
如：
def register(username,age,gender='male'): # 已经被赋值的gender就是默认为male print(username,age,gender) register('jason',18) # jason 18 male register('tank',28) # tank 28 male register('egon',84) # egon 84 male register('kevin',58) # kevin 58 male register('xiaohou',17,'female') # xiaohou 17 female # 第三个参数不传则默认为male，传的话就为传的值，在此为female
*****************************
函数在定义阶段 内部所使用的变量都已经初始化完毕了
不会因为调用的位置的变化 而影响到内部的值(暂时可忽略)
函数无论在什么地方被调用
都会跑到函数定义阶段去执行代码
形参中用到的值都是往函数定义阶段代码往上找
**************************************
可变长参数：在形参和实参中用*和**表示不同的含义。
1.形参中*能够接收多余的位置参数，组织成一个元祖赋值给*后面的形参名。如：
def func(x,y,*z): print(x,y,z) func(1,2,3,4,5,6,7,8,54,43,4,5,6,6,7,8,) # 阴影部分为多余的未知参数 # 结果为1 2 (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8) # 其中z（*后面的形参名） = (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8) 元祖形式
2.形参中**能够接收多余的关键字参数，组织成一个字典赋值给**后面的形参名。如：
def func(x,y,**z): print(x,y,z) func(x=1,y=2,z=1,a=1,b=2,c=3) # 阴影部分为多余的关键字参数 # 结果为1 2 {'z': 1, 'a': 1, 'b': 2, 'c': 3} 其中z（**后面的形参名） = {'z': 1, 'a': 1, 'b': 2, 'c': 3}
组成的字典：字典的value就是关键字的名字指向的值
3.实参中*能够将列表、元祖、集合、字符串打散成位置实参的形式传递给函数。如：
def func(x,y,z): print(x,y,z) # func(*[1,2,3,4,5,6]) # *会将列表打散成位置实参一一传入等价于func(1,2,3,4,5,6) func(*(1,2,3)) # 1 2 3 等价于func(1,2,3) # *的内部你可以看成是for循环
4.在实参中**能够将字典打散成 key = value 的形式，按照关键字参数传送给函数。如：
def func(x,y,z): print(x,y,z) func(12,3,4) # 12 3 4 位置传参 func(x=1,y=2,z=3) # 1 2 3 关键字传参 d = {'x':1,'y':2,'z':333} func(**d) # 1 2 333 # 等价于func(x=1,y=2,z=333) **会将字典拆封成 key = value的形式
*********************************************************
attention：python中推荐使用形参*和**通用的写法：
def func(*args,**kwargs) :
print(args,kwargs)
func(？) # 里面可以是任意类型数据，但必须是先位置传参，后关键字传参。