函数 形参实参

一、定义

形式一：无参函数

def func():
	print('哈哈哈')
func()

# 定义函数发生的事情
# 1、申请内存空间保存函数体代码
# 2、将上述内存地址绑定函数名
# 3、定义函数不会执行函数体代码，但是会检测函数体语法

# 调用函数发生的事情
# 1、通过函数名找到函数的内存地址
# 2、然后加口号就是在出发函数体的执行
print(func)
func()

示例

def bar():
	print('from bar')

def foo():
	# print(bar)
	bar()
	print('from foo')

foo()

形式二：有参函数

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

形式三：空函数，函数代码为pass

def func(x,y):
	pass

三种定义方式各用在何处

1、无参函数的应用场景

def interactive():
	name=input('username>>: ')
	age=input('age>>: ')
	gender=input('gender>>: ')
	msg='名字:{} 年龄:{} 性别:{}'.format(name,age,gender)
	print(msg)
interactive()
interactive()
interactive()

2、有参函数的应用场景

def add(x,y):	# 参数
	# x=20
	# y=35
	res=x + y
	# print(res)
	return res   # 返回值

        # add(10,23)
        res=add(20,30)
        print(res)

3、空函数的应用场景

def auth_user():
	"""user suthentication function"""
	pass

4、调用函数

# 1、语句的形式
# interactive
add(1,2)

# 2、表达式形式：
def add(x,y):
	res=x+y
	return res
# # 赋值表达式
res=add(1,2)
print(res)
# # 数字表达式
res=add(1,2)*10
print(res)

二、 形参与实参介绍

# 形参：在定义函数阶段定义的参数称之为形式参数，简称形参，相当于变量名
def func(x,y):	# x=1,y=2
	print(x,y)

# 实参：在调用函数阶段传入的值称之为实际参数，简称实参，相当于变量值
func(1,2)

# 形参与实参的关系：
# 1、在调用阶段，实参（变量值）会绑定给形参（变量名））
# 2、这种绑定关系只能在函数体内使用
# 3、实参与形参的绑定关系在函数调用时生效，函数调用结束后解除绑定关系

1、实参是传入的值，但值可以是一下形式：

# 形式一
func(1,2)

# 形式二
a=1
b=2
func(a,b)

# 形式三
func(int('1'),2)

2、形参与实参的具体使用

# 2.1 位置参数；按照从左到右的顺序依次定义的参数成为位置参数
# 位置形参：在函数定义阶段，按照从左到右的顺序直接定义的"变量名"
# 		特点：必须被传值，多一个不行，少一个也不行
def func(x,y):	
	print(x,y)

# 位置实参:在函数调用阶段，按照从左到右的顺序依次传入的值
		# 特点：按照顺序与形参一一对应

2.2 关键字参数

# 关键字实参：在函数调用阶段，按照key==value的形式传入的值
# 		特点：指名道姓的给某个形参传值
func(y=3,x=1)
func(1,3)

# 混合使用，强调
# 1、位置实参必须放在关键字实参前
func(1,y=3)
func(y=3,1)错

# 2、不能为同一个形参重复传值
func(1,y=2,x=3)
func(1,2,y=2,x=3)


# 2.3 默认参数
# 默认形参：在定义函数阶段，就已经被赋值的形参，称之为默认参数
# 		特点：在定义阶段就已经被赋值，意味着在调用阶段可以不用为其赋值
def func(x,y=3):
	print(x,y)
func(1)
func(x=1,y=4)
# 位置形参与默认形参混用，强调：
# 1、位置形参必须在默认形参的左边
def func(y=2,x):
	pass

# 2、默认参数的值是在函数定义阶段被赋值的,准确的说被赋予的是值的内存地址

示范

# 示范1
m=2
def func(x,y=m):  # y=>2的内存地址
	print(x,y)
m=2222
func(1)

# 示范二
m=[2,]
def func(x,y=m):  # y=>[2,]的内存地址
	print(x,y)
m.append(233432)
func(1)

3、虽然默认值可以被指定为任意数据类型，但是不推荐使用可变类型

# 函数理想状态，函数的调用只跟函数本身有关系，不受外界代码的迎影响

def func(x,y,z,l=None):
	if l is None:
		l=[]
	l.append(x)
	l.append(y)
	l.append(z)
	print(x,y)

func(1,2,3)

new_l = [111,222]
func(1,2,3,new_l)

4 、可变长度的参数（*与**的用法）

可变长度指的是在调用函数时，传入的值（实参）的个数不固定

# 而实参是用来为形参赋值的，所以对应着，针对一处的实参必须有对应的形参来接收

4.1 可变长度的位置参数
# I：*形参名：用来接收溢出的位置实参,溢出的位置实参会被*保存成元组的格式然后赋值紧跟其后的形参名
# 			*后跟的可以是任意名字，但是约定俗成应该是args
def func(x,y,*z):	# z= (3, 4, 5, 5)
	print(x,y,z)
func(1,2,3,4,5)

def my_sun(*args):
	res=0
	for item in args:
		res+=item
	return res
res = my_sun(1,2,3,4,5,6,)
print(res)

# II：*可以用在实参中，实参中带*，先将*后的值打散成位置实参
def func(x,y,z):
	print(x,y,z)
func(*[11,22,3])	# func(11,22,3)

# III：形参与实参中都带*
def func(x,y,*args):	# args=(1,2,3,4)
	print(x,y,args)

func(1,2,[1,2,3,4])
func(1,2,*[1,2,3,4])	#func(1,2,1,2,3,4)

func(*'hello')	# func('h','e','l','l','o')

# 2.4.2 可变长度的关键字参数
# I:**形参名 用来接收溢出的关键字实参，**会将溢出的关键字实参保存成字典格式，然后赋值给紧跟其后的形参名
# 			**后跟的可以是任意名字，但是约定俗成应该是kwargs
def func(x,y,**kwargs):
	print(x,y,kwargs)
func(1,y=2,a=1,b=3)

# II：**可以用在实参中(**后跟的只能是字典)，实参中带**，先将**后的值打散关键字实参
def func(x,y,z):
	print(x,y,z)

func(*{'x':1,'y':2,'z':3})   # func('x','y','z')
func(**{'x':1,'y':2,'z':3})    # func(x=1,y=2,z=3)

# III：形参与实参中都带**
def func(x,y,**kwargs):
	print(x,y,kwargs)
func(**{'y':222,'x':333,'a':233,'b':222})

# 混用*与**：*args必须在**kwargs之前
def func(*args,**kwargs):
	print(args)
	print(kwargs)

func(1,2,3,4,5,6,7,x=1,y=2,z=3)

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

def wrapper(a,b,c):  # a=1 b=2 c=3
	index(a,b,c)  # index(1,2,3)

wrapper(1,2,3) # 为wrapper传递的参数是给index用的


def index(x,y,z):
	print(x,y,z)

def wrapper(*args,**kwargs):	# args=(1,)  kwargs{'y':2,'z':3}
	index(*args,**kwargs)
	index(*(1,),**{'y':2,'z':3})
	index(1,z=3,y=2)

wrapper(1,z=2,y=3)

5 、命名关键字参数

# 在定义函数时，*后定义的参数，如下所示，称之为命名关键字
# 特点：
# 1、命名关键字参数必须按照key=value的形式为其传值
def func(x,y,*,a,b):	# 其中，a和b称之为命名关键字参数
	print(x,y)
	print(a,b)

func(1,2,a=3,b=33)
示例

def func(x,y,*,a=111,b):
	print(x,y)
	print(a,b)

func(1,2,b=233)