11.26-day8-函数的参数和对象，函数嵌套

11.26-day8-函数的参数和对象，函数嵌套

一、函数参数

函数的参数可以分为两大类
形参：在定义函数时，括号内指定的参数，称之为形式参数，简称形参，形参的本质就是变量名
实参：在调用函数时，括号内传入的值，称之为实际参数，简称实参，实参的本质就是变量值
实参与形参的关系是：在调用函数时，实参的值会绑定给形参，该绑定关系可以在函数内使用
在函数调用结束后，会解除绑定关系

def add(x,y):
	return x+y 	
add(1,2)

1、位置形参

定义：在定义函数时，按照从左到右的顺序一次定义 的变量名，称之为位置形参

特点：必须被传值，多一个不行，少一个不行

def func(x,y,z):
	print(x,y,z)
func(1，2，3)

2、位置实参

定义：在调用函数时，按照从左到右的顺序依次传入的值，称之为位置实参
特点：按照位置与形参一一对应

def func(x,y):
	print(x,y)
func(1,2,3)

3、默认参数（具有默认值的形参）

定义：在定义函数时，就已经为某个形参赋值了，该形参就称之为默认参数
特点：在调用阶段可以不用给默认形参传值

def func(x,y=1):
	print(x,y)
func(1)

注意：位置形参与默认形参可以用混用，但位置形参应该跟在默认形参前
注意：默认形参的使用最好是不可变类型

4、关键字实参

定义：在调用函数时，按照key=value的形式指定的实参，称之为关键字实参
特点：可以打乱顺序，但仍能指名道姓地为指定形参赋值

def func(x,y)
	pritn(x,y)
func(y=2,x=3)

注意：位置实参与关键字实参可以用混用，但是必须注意
1、位置实参必须放在关键字实参的前面
2、不能为同一个形参重复赋值

5、可变长参数（*与**的应用）

可变长指的是在调用函数时，传入实参个数不固定，而实参是为形参赋值的，所以，必须必须对应格式的形参来接收溢出的实参

5.1在形参中带*args

*args会将溢出位置实参汇总成元组，然后赋值给其后变量名，通常应该是args

def func(x,y,*args)
	print(x,y,args):
func(1,23,4,4,5,6,7)

#累加
def l_sum(*args):
	res=0
	for i in args:
		res += i
	return res
l_sum(1,2,34,55)

5.2在形参中加**kwargs

定义：**会将溢出关键字实参汇总成字典，然后赋值给其后变量名，通常应该是kwargs

def func(x,y,**kwargs)
	print(x,y,kwargs)
func(1,2,a=1,b=2,c=4)

5.3在实参加*args

定义: 会将紧跟其后的实参打撒成位置实参,注意*后跟的应该是一个可以被for循环循环的类型

def func(a,b,c,d):
	print(a,b,c,d)
func(*"hell")
func(*[1,2,3,4])
func(11,22,*{"k1":33,"k2":44})  #func(11,22,k1,k2)

5.4在实参带**

定义：会将紧跟其后的实参打撒成关键字实参,注意后跟的必须是一个字典

def func(a,b,c,d)
	print(a,b,c,d)
func(**{"b":1,"c":2,"d":3,"a":4})   #func(a=4,b=1,c=2,d=3)

混用
1.在形参中，*必须放在前
2.在实参中，*必须放在前

def index(x, y, z):
    print('index======>', x, y, z)

def wrapper(*args, **kwargs):  # args=(1,2,3,4)  kwargs={"a":1,"b":2,"c":3}
    index(*args, **kwargs)  # index(*(1,2,3,4),**{"a":1,"b":2,"c":3})
    # index(1,2,3,4,a=1,b=2,c=3)

6、命名关键字形参

定义：在*与**之间后定义的形参
特点：必须按照key=value的形式传值

def func(x,y,*args,a=2,b,**kwargs):
	print(x)
	print(y)
	print(args)
	print(a)
	print(b)
	print(kwargs)
func(1,2,3,4,5,a=1,b=2,c=3)

二、函数对象

函数是第一等公民

def func(): #func=函数的内存地址
	print("hello world")

1.可以赋值

f=func
f()

2可以当作参数传给另一个函数

def bar(x)
	print(x)
bar(func)

3可以当做一个函数的返回值

def add(x): #x=func的内存地址
	return x #return 函数func内存的地址
res=add(func) #add(func的内存地址)
print(res)

4.可以当作容器类型的元素

ddef login():
    print("login")


def register():
    print("register")


def tranfer():
    print("tranfer")


def withdraw():
    print("withdraw")


func = {
    "1": [login, "登录"],
    "2": [register, "注册"],
    "3": [tranfer, "转账"],
    "4": [withdraw, "提现"]
}
while True:
	print("0 登出")
	for k in func:
		print(k, func[k][1])
	choice = input("请输入你要执行的操作  ").strip()
	if choice == "0":
		break
	if choice in func:
		func[choice][0]()
	else:
		print("请输入正确操作")

三函数嵌套

1.函数嵌套的定义

def f1():
	print("form f1")
	def f2():
		print("form f2")
	print(f2)
	f2()
f1()

2.函数嵌套调用

def max2(x,y):
	if x > y:
		return x
	if x < y:
		return y

def max4(a,b,c,d):
	res1=max2(a,b)
	res2=max2(res1,c)
	res3=max2(res2,d)
	return res3
max4(1,2,3,4)