一 定义1个函数
无参函数的定义方法，就是def 后面加上函数名，函数名后面必须要有一个括号
格式：def 函数名():
函数体（也就是函数的功能）
def aa(): return 11 a=aa() print(a) def bb(): print(111) bb() 输出结果 11 111
有参函数的定义方法：def后面加上函数名，函数名的后面括号里传入一个参数。
格式：def 函数名(参数)： （参数可以时任意的数据类型）
函数体（函数的功能）
def aa(a,b): return a,b bb=aa(1,2) print(bb) 输出结果 (1, 2)
二 函数的参数
在定义的阶段传入的参数，就叫做形式参数，简称形参，形参相当于一个变量名
在调用阶段传传入的参数，就叫做实际参数，简称实参，实参相当于一个变量名的值
def aa(a): #a就是一个形参 return a bb=aa(5) #5 就是一个实参 print(bb) 输出结果 5
注意：在定义 阶段时可以传入多个参数，但是在定义阶段传入几个形参（*）星号除外，在调用阶段就传入几个形参。
三 函数里面的return
return：返回内容，也可以当终止符使用，一个函数只要遇见了return，执行完return，就会终止。
def aa(): print(123) return print(456) bb=aa() print(bb) 输出结果 123 None
调用时返回none的现象：1 直接返回的时None
2 没有return这个关键字
3 返回的内容为空
def aa(): pass a=aa() print(a) def bb(): return b=bb() print(b) def cc(): return None c=cc() print(c) 输出结果 None None None
return可以返回多个内容，每个内容之间用逗号隔开，在调用时返回的值会以一个元组的格式返回。返回的值可以为任意的内容
def aa(): return 1,[2],'3',{4},(5),{6:7} a=aa() print(a) 输出结果 (1, [2], '3', {4}, 5, {6: 7})
接收返回值：
一个值接收，直到调用时遇见第一个return，就会返回第一个return返回的内容，然后终止这个函数
def aa(x): return x return x+x a=aa(1) print(a) 输出结果 1
多个值接受，返回的变量有几个，就要用几个值去接收返回的内容。
def bb(x,y,z): return x,y,z b=bb(2,5,0) print(b) 输出结果 (2, 5, 0)
函数里如果有print（）打印，直接可以用函数名后面跟上一个括号去执行这个函数，如果在定义时函数传入了参数，在执行的时候也要传入相对应个数的参数值。
def a(): print(123) a() def b(x,y): print(x,y) b(3,4) 输出结果 123 3 4
三 详解： 函数
def func(a,b): #站在函数定义的角度上：位置参数 ：必须传的参数 print(a,b) #站在调用函数的角度上 func(1,2) #按照位置传参 func(b = 1,a = 2) #按照关键字传参 func(1,b = 2) #混用 : 必须先按照位置传参，再按照关键字传参 输出结果 1 2 2 1 1 2
位置参数
站在实参角度
1.按照位置传值
def mymax(x,y): #此时x=10,y=20
if x > y ：
the_max = x
else ：
y return the_max ma = mymax(10,20) print(ma) # 按照位置传参置传参，再按照关键字传参 输出结果 20
2.按照关键字传值
def mymax(x,y): #此时x = 20,y = 10 print(x,y) the_max = x if x > y else y return the_max ma = mymax(y = 10,x = 20) print(ma) # 按照关键字传参 输出结果 20 10 20
3.位置、关键字形式混着用
def mymax(x,y): #此时x = 10,y = 20 print(x,y) the_max = x if x > y else y return the_max ma = mymax(10,y = 20) print(ma) # 位置、关键字混用传参 输出结果 10 20 20
正确用法
问题一:位置参数必须在关键字参数的前面
问题二:对于一个形参只能赋值一次
站在定义函数的角度上——默认参数
def welcome(name,sex='male'): #sex默认参数 print('welcome,%s,sex: %s'%(name,sex)) welcome('黄中山') welcome('曹海娇') welcome('鲁旭彤','female') 输出结果 welcome,黄中山,sex: male welcome,曹海娇,sex: male welcome,鲁旭彤,sex: female
def age(age,my_age=18): if age > my_age: return False else: return True def age(a1,a2=18): print(a1,a2) a2 = 20 age(10) 输出结果 10 18
默认参数
是可以不传的参数
如果不传默认是设置的默认值，如果传就用传入的值
默认的值是在定义阶段就确定了
默认参数的陷阱:针对可变的数据类型
比较奇怪的例子：
1
def demo3(a=[]): a.append(1) print(a) demo3(a = []) demo3([]) demo3([]) 输出结果 [1] [1] [1]
2
def func(l = []): l.append(123) print(l) func() func([]) func() 输出结果 [123] [123] [123, 123]
陷阱
def defult_param(a,l = []): l.append(a) print(l) defult_param('alex') defult_param('egon') 输出结果 ['alex'] ['alex', 'egon']
动态参数
计算元素之和
1.普通用法
def my_sum(a,b,c): sum_ret = a+b+c return sum_ret print(my_sum(1,2,3)) 输出结果 6
2.利用动态参数以后
def my_sum(*args): count_sum = 0 for i in args: count_sum += i return count_sum print(my_sum(1,2,3)) 输出结果 6
动态参数
站在函数定义的角度上：*做聚合用，将一个一个的参数组合成一个元组
站在函数调用的角度上：*做打散用，将一个列表或者元组打散成多个参数
*只针对按位置传参
**动态参数，接受按关键字传递过来的参数，组织成一个字典
def demo4(**kwargs): #*args **kwargs print(kwargs) #demo4(a = 1,b = 2,c = 3) d = {'a': 1, 'b': 2, 'c': 3} demo4(**d) #demo4(a = 1,b = 2,c = 3) 输出结果 {'a': 1, 'b': 2, 'c': 3}
站在传参角度：按位置 按关键字
def demo5(*args,**kwargs): print(args) print(kwargs) demo5(1,2,3,a=10,b=20) #必须按照 t = (1, 2, 3) d = {'a': 10, 'b': 20} demo5(*t,**d) 输出结果 (1, 2, 3) {'a': 10, 'b': 20} (1, 2, 3) {'a': 10, 'b': 20}
站在函数定义的角度：所有的参数都是形式参数
位置参数
默认参数
动态参数：*args，**kwargs
站在函数调用的角度上:所有的参数都是实际参数
按照位置传
按照关键字传
混用：按照位置传必须在关键字传参之前
def func(位置参数1,位置参数2,*args,默认参数=10,**kwargs): print(位置参数1,位置参数2) print(默认参数) print(args) print(kwargs) func(1,2,3,4,5,默认参数='hahaha',a=10,b=20) func(1,2,3,4,5,a=10,b=20) 输出结果 1 2 hahaha (3, 4, 5) {'a': 10, 'b': 20} 1 2 10 (3, 4, 5) {'a': 10, 'b': 20}
动态传参：*args,**kwargs组合在一起可以hold 100%所有的传参
嵌套函数
函数的嵌套调用
def func(): print(123) def func2(): func() print(345) func2() print(234) 输出结果 123 345 234
函数的嵌套定义
def func(): print(123) def func2(): print(234) func2() func() 输出结果 123
234
两个重要例子：
1.
def func(x,y,z): print(x,y,z) def func_inner(a,b,c): print('func_inner',a,b,c) func_inner(x,y,z) func(4,5,6) 输出结果 4 5 6 func_inner 4 5 6
2.
def func(*args,**kwargs): print(args) #(1,2) --> 1,2,3 print(kwargs) #{'c': 3} def func_inner(a,b,c): print('func_inner',a,b,c) func_inner(*args,**kwargs) func(1,b = 2,c = 3) 输出结果 (1,) {'b': 2, 'c': 3} func_inner 1 2 3
