函数的使用必须遵循：先定义后使用的原则
函数的定义，与变量的定义是相似的,如果没有事先定义函数而直接引用
就相当于在引用一个不存在变量名
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