函数定义
函数定义：使用函数最基本的意义就是解决代码复用问题，解决代码冗余，解决代码可维护性差的问题。
函数的写法：
def test(): #定义函数名,括号里可以加参数，arg1，arg2用“，”分隔开。 """ 函数的基本描述信息 :return: """ print('hello world !') #这是函数的实现功能代码 return 1 #return返回值，后面可以跟任何数据类型。 test() #这是调用函数 这是无参函数，所以调用时也不参
空函数：设计程序功能函数，用pass代替函数体。
def test(): pass
函数的参数：括号里有值的，叫有参函数，没值的，叫无参函数。
无参函数：就是一些普通的语句。完全不依赖外部传入的值，就可以运行的函数，就是无参函数。
def print_line(): print("#"*13) def print_msg(): print("hello world !")
# 这就是无参函数
有参函数：就是依赖外部传入的值，才可以调用的函数，就是有参函数。最为直观的就是函数名括号里有值。
有参函数，在定义时有参数，那么在调用时，就需要传入对应的参数。 ret = test(1,5) 是函数调用的表达式形式。
def test(x,y): print("from test")
res = x+y #将x和y的结果赋给res return res #return返回的res是函数test的结果。 ret = test(1,5) #test函数定义时有参，调用时需要传参，test函数会拿到return的返回值，将返回值赋给一个变量ret，就可以打印结果了 print(ret)
函数的返回值：有三种情况，一种是无参函数。一种是返回一个值。还有一种是返回多个值。
注意：函数只能执行一个return的返回值。只要执行一个return，函数就执行完了。
无参函数不需要写return。返回一个值的，就是函数定义里面return返回的1，也可以返回多个值，因为return可以返回任何数据类型。
无参函数返回值：
def test(): """ 不写返回值的情况，结果是None。 :return: """ print('from the test') res = test() print(res) #打印结果是None。也算是有返回值的。
有参函数返回一个值：
def test(x,y): """ 有返回值的情况, 返回结果 :param x: :param y: :return: """ res=x if x>y else y return res res = test(1,4) print(res)
有参函数返回多个值：因为return可以返回任何数据类型。返回多个值是以元组的形式。
def test(x,y): """ return可以返回任何数据类型 :param x: :param y: :return: """ return 1,2,3,[1,2],{'a':1},{1,2,3} res = test(1,2) print(res)
res1,res2,res3,res4,res5,res6 = test(1,2) #这样就可以打印return返回的多个值
print(res1,res2,res3,res4,res5,res6)
函数的实参和形参：实参是调用函数时，传入的参数。形参是定义函数时，定义的参数。
形参就好比是变量名，实参就好比是变量明确的值。在实参传值给形参时，就是按参数位置传参。1传给x，5传给y。
注意：实参的数据类型要用不可变的数据类型，有数字，元组，字符串。
实参在函数调用使用后失效。
def test(x,y): #函数定义阶段，括号里的参数是形式参数 print(x) print(y) test(1,5) #调用函数时，括号内加的参数是实际参数
在实参中，还有一种赋值方法，就是按关键字传值。在传参中，直接赋予变量值。
def test(x,y): #函数定义阶段，括号里的参数是形式参数 print(x) print(y) test(x=3,y=4) #直接在传参中，赋予变量值。 test(y=7,x=8)
当然，关键字参数和位置参数可以混用。
注意：混用的注意事项是位置参数必须在关键字参数前面。
def test(x,y): #函数定义阶段，括号里的参数是形式参数 print(x) print(y) test(1,y=2) #调用函数时，括号内加的参数是实际参数 ##### 问题一：按位置传值必须在按关键字传值的前面 test(y=2,1) #报错，因为关键字参数在位置参数前面
对于参数，不能重复赋值。
def test(x,y): #函数定义阶段，括号里的参数是形式参数 print(x) print(y) test(1,x=1,y=2) #这就是对参数x多次赋值。会报错。
可变数据类型会改变原有的实参参数。这样操作会有副作用，他会改变全局变量。也就会导致可控性很差。(不推荐使用可变数据类型)
def test(x,y): #函数定义阶段，括号里的参数是形式参数 print(x) x.append(4) print(y) a = [1,2,3] #可变数据类型 b = 6 test(a,b) print(a,b)
注意：
形参角度：
一、位置参数：必须传值的参数，并且形参定义几个参数，就要传几个参数，传多或传少都不行。
def foo(x,y): print(x) print(y) # foo(1) #传少报错 # foo(1,2,3) #传多报错 foo(y=2,x=1)
二、默认参数：形参定义好的参数，在传值时，对于定义好的参数可以不传值，如果传值，新值会覆盖定义好的默认值。
def foo(x,y=1): #默认参数定义好y=1，那么在传参数时，对于y就可以不传 print(x) print(y) foo(1) #只传一个值，按位置给x，但结果依旧是1，1。 foo(1,2) #传两个值，按位置y的实参会覆盖默认的y=1，结果是1，2 foo(y=2,x=2) #按关键字传值，y的默认值也会被实参覆盖
注意：默认参数必须在位置参数后面。
#默认参数必须注意的问题是：默认参数必须放到位置参数的后面 def register(sex='male',name): #报错 name 应该在sex前面 print("name:", name) print("sex:", sex) register('george')
可变参数：*args，**kwargs。
*args：当位置参数传入多余的值，就交给*args处理，并且将这些多余的值，存成元组的形式。
def foo(x,*args): #args=(2, 3, 4, 5, 6, 6, 'a', 'b') print(x) print(args) foo(1,2,3,4,5,6,6,'a','b')
样例：应用*args。
#sum求和函数 def test_sum(*args): res = 0 for i in args: res+=i return res print(test_sum(1,2,3,4,5))
注意： *args 与位置参数和默认参数混用方式，是 *args 要放到位置参数后面。
def foo(x,*args,y=1): # *args在位置参数后面 print(x) print(y) print(args) foo(1,2,3,4,5,6,7,8,9,10,y=10000000)
**kwargs：当关键字传值传入多余的值，就交给**kwargs处理，并且将这些多余的值，存成字典的形式。
def foo(x,**kwargs): print(x) print(kwargs) foo(1,y=1,z=2)
如果函数foo()的参数是1，2，3，4，并且都有位置参数接收，那么**kwargs的结果就是一个空字典。
问题：当位置参数和*args以及**kwargs混用的时候。会出现位置参数后的值赋给*args处理，处理成元组。而之后的关键字参数会交给**kwargs处理，处理成字典。
def foo(x,*args,**kwargs): print(x) print(args) print(kwargs) foo(1,2,3,4,5,y=1,z=2)
*args和**kwargs的最终使用方式：位置参数的实参交给*args处理，关键字参数的实参交给**kwargs处理。
def foo(*args,**kwargs): print(args) print(kwargs) foo(1,1,1,1,1,1,a=1,b=2)
*args和**kwargs的应用：
def auth(name,password,sex='male'): print(name) print(password) print(sex) def foo(*args,**kwargs): #args=('george','123') kwargs={} print('from foo') auth(*args,**kwargs) # auth(*'george','123'), ###**{})--->auth('george','123') foo('george','123') foo(1,2,3,4,x=5,y=6) #报错 foo('george','456',sex='female') foo(name='george',password='789',sex='female')
------------- END --------------