函数的使用必须遵循:先定义后使用的原则
函数的定义,与变量的定义是相似的,如果没有事先定义函数而直接引用
就相当于在引用一个不存在变量名
def func(): print('hello world') func()
定义阶段
def foo(): print('from foo') bar() def bar(): print('from bar')
调用阶段
foo()
定义阶段:只检测语法,不执行代码
#语法有问题
def func():
if 1>2
print('hahahahahahah')
#语法没问题,逻辑有问题,引用一个不存在的变量名
def func():
asdfasdfasdfasdfasdf
函数的返回值
返回值:可以返回任意类型
没有return:None
return value: value
return val1,val2,val3 :(val1,val2,val3)
def func(x): return x**2 y=func(10) # 10**2 print(y) def foo(): return None res=foo() print(res) def foo(): return {'a':1} res=foo() print(res['a']) def foo(): return {'a':1},1,'a',[1,2] res=foo() print(res)
return的效果:只能返回一次值,终止函数的执行
def foo(): return 1 print('=====>') return 2 return 3 return 4 print(foo())
函数对象
函数是第一类对象: 指的是函数可以被当做数据传递
def func(): print('from func')
可被引用
f=func
可以当做函数的参数
def func(): print('from func') def foo(x): print(x) x() foo(func)
可以当做函数的返回值
def foo(): print('from foo') def bar(): return foo f=bar() print(f) print(foo) x=0 def f1(): x=1 def f2(): # 在内部当作返回值返回 # x=2 print(x) print(x) return f2 f=f1() print(f) f()
可以当做容器类型的元素
def select(): print('select function') func_dic = { 'select': select, } print(func_dic['select']) func_dic['select']()
函数的嵌套:调用和定义
函数的嵌套调用
def max2(x,y): if x > y: return x else: return y def max4(a,b,c,d): res1=max2(a,b) #23 res2=max2(res1,c) #23 res3=max2(res2,d) #31 return res3 print(max4(11,23,-7,31))
函数的嵌套定义
def f1(): def f2(): def f3(): print('from f3') print('from f2') f3() print('from f1') f2() print(f1) f1() ''' from f1 from f2 from f3 '''
函数参数的使用
参数:各类型
def foo(x):
print(x)
foo(1)
foo('a')
foo({'a':2})
形参与实参:
def foo(x,y): # 形参
return x+y
foo(1,2) # 实参
===================================part1
位置参数:按照从左到右的顺序依次定义的参数
def foo(x,y):
print(x)
print(y)
按位置定义的形参,必须被传值,多一个不行,少一个也不行
foo(1,2,3) # TypeError: foo() takes 2 positional arguments but 3 were given
按位置定义的实参,与形参一一对应
foo(2,10)
===================================part2
关键字参数:实参在定义时,按照key=value形式定义 #关键字参数是实参
def foo(x,y): print(x) print(y) # foo(y=10,x=1) foo(y=10,x=1) #关键字参数可以不用像位置实参一样与形参一一对应,指名道姓地传值 def foo(x,y,z): print(x) print(y) print(z) foo(1,z=20,10) foo(1,y=2,z=10)
注意的问题一:位置实参必须在关键字实参的前面
注意的问题二:实参的形式既可以用位置实参又可以是关键字实参,但是一个形参不能重复传值
===================================part3
默认参数:在定义函数阶段,就已经为形参赋值,定义阶段有值,调用阶段可以不用传值
def func(x,y=10): print(x) print(y) func(1,20) # 可以给y传值 func(1) # 也可以不给y传值
'''
#位置实参
#关键字实参
#位置形参
#默认参数(形参)
'''
形参的应用:值经常变化的需要定义成位置形参,
值大多数情况下都一样,需要定义成默认参数
def register(name,age,sex='male'): print(name,age,sex) register('alex',1000) register('wupeiqi',9000) register('yuanhao',10000) register('王铁蛋',10000,'female')
!!!!!!!
默认参数需要注意的问题一:必须放在位置形参后面
默认参数需要注意的问题二:默认参数通常要定义成不可变类型
默认参数需要注意的问题三:默认参数只在定义阶段被赋值一次
x=10 def func(name,age=x): print(name) print(age) x=20 func('egon')
默认参数定义,可传值也可不传
def func(name,age=10,sex='male',hobby=['play1','play2']): print(name) print(age) print(hobby) func('egon')
===================================part4
可变长参数:可变长指的是实参的个数不固定 # 实参
按位置定义的可变长度的实参:*
按关键字定义的可变长度的实参:**
def func(x,y,*args): #x=1,y=2,args=(3,4,5,6) print(x,y) print(args) func(1,2,3,4,5,6) def func(x,y,*args): #args=(3,4,5,6) print(x,y) print(args) func(1,2,*(3,4,5,6)) def func(x,y,z): print(x,y,z) func(1,*(2,3)) #func(1,2,3) # func(*(2,3)) #func(2,3) def func(x,y=2,z=1): print(x,y,z) func(*('a','b','c')) #func('a','b','c') def func(x,y,**kwargs): print(x,y) # x=1,y=2 print(kwargs) # kwargs={'a':1,'b':3,'z':3} func(1,y=2,z=3,a=1,b=3) !!!!!!!!!!!!!! def func(x,y,**kwargs): print(x,y) # x=1,y=2 print(kwargs) # **kwargs=**{'a':1,'b':3,'z':3} func(1,y=2,**{'a':1,'b':3,'z':3}) #func(1,y=2,z=3,b=3,a=1) def func(x,y=1,z=1): print(x,y,z) func(**{'y':2,'x':1,'z':3}) def wrapper(*args,**kwargs): # *args,**kwargs可以接受任意形式,任意长度的参数 print(args) print(kwargs) wrapper(1,2,3,3,3,3,3,x=1,y=2,z=3) def index(name,group): print('welcome %s to index page,group is: %s' %(name,group)) def wrapper(*args,**kwargs): #可以接受任意形式,任意长度的参数 # print(args) #args=(1,2,3) # print(kwargs) #kwargs={'x':1,'y':2,'z':3} index(*args,**kwargs) #index(*(1,2,3),**{'x':1,'y':2,'z':3}) #index(1,2,3,z=3,y=2,x=1) wrapper(name='egon',group='group1')
命名关键字参数:定义在*后的形参,这类形参,必须被传值,而且要求实参必须是以关键字的形式来传值 # 形参
def register(**kwargs): print(kwargs) if 'name' in kwargs: print(kwargs['name']) if 'age' in kwargs: print(kwargs['age']) register(name='egon',age=18) register() 省去判断,使name,age必须有值,怎么办? def register(*args,name='egon',age): # *args,后面的参数必须被传值 print(args) print(name) print(age) register(name='egon',age=18) register(1,2,2,3,age=10) def register(name,age,*args,group,**kwargs): print(name) print(age) print(kwargs) register('egon',18) # 命名关键字参数未被传值 register('egon1',18,hobby='paly1',group='group1') def func(x,y=1,*args,z,**kwargs): print(x) print(y) print(args) print(z) print(kwargs) func(1,2,3,4,5,z=10,a=1,b=2) # z=10必须被传值 def func(x,*args,z=1,**kwargs): print(x) print(args) print(z) print(kwargs) func(1,2,3,4,5,a=1,b=2,c=3) # z为默认参数,可不用实参传值
形参:位置形参,默认参数,*args,命名关键字参数,**kwargs