Python基础之函数的参数

一、函数的参数分类

1.1形参

在定义函数时，括号内指定的参数，称之为形式参数，简称形参，形参的本质就是变量名

1.2实参

在定义函数时，括号内传入的值，称之为实际参数，简称实参，形参的本质就是变量值

1.3 实参与形参的关系

在调用函数时，实参的值会绑定给形参，该绑定关系可以在函数内使用；
在函数调用结束后，会解除绑定关系

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

add(1,2)

二、位置形参

2.1 定义

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

2.2 特点

必须被传值，多一个不行，少一个也不行

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

func(1,2)
func(1,2,3)
func(1)

三、位置实参

3.1 定义

在调用函数时，按照从左到右的顺序依次传入的值，称之为位置实参

3.2 特点

按照位置与形参一一对应

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


func(1,2)
func(2,1)

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

4.1 定义

在定义函数时，就已经为某个形参赋值了，该形参就称之为默认参数

4.2 特点

在调用阶段可以不用给默认形参传值

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

func(1,2)
func(1)

def register(name,age,gender="male"):
    print(name,age,gender)

register("egon",18,)
register("lxx",38)
register("hxx",32,"female")
register("李建国",30)
register("alex",31)
register("xxx",18)

# 注意：位置形参与默认形参可以用混用，但是必须注意
# 1、位置形参应该跟在默认形参前
# def func(y=1111,x):
#     print(x,y)

# 注意：默认形参的使用，需要注意点
# 1、默认形参的值最好是不可变类型
m=222
def func(x,y=m):
    print(x,y)
m=666
func(111)


m=[222,]
def func(x,y=m):
    print(x,y)
m.append(666)
func(111)

# def register(name,hobby,hobbies=[]):
#     hobbies.append(hobby)
#     print('%s 的爱好们是 %s' %(name,hobbies))

def register(name,hobby,hobbies=None):
    if hobbies is None:
        hobbies=[]
    hobbies.append(hobby)
    print('%s 的爱好们是 %s' %(name,hobbies))

register("egon","smoke")
register("lxx","lang")
register("hxx","drink")

五、关键字实参

5.1 定义

在调用函数时，按照key=value的形式指定的实参，称之为关键字实参

5.2 特点

可以打乱顺序，但仍能指名道姓地为指定形参赋值

def func(x,y=22222):
    print(x,y)
    
func(y=2222,x=111)

func(x=111)

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

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

func(1,y=2)
func(y=2,1)
func(1,y=2,x=3)

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

6.1 定义

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

6.2 *与**可以用在形参中，专门用于应对溢出的实参

6.2.1 在形参中带*

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

def func(x,y,*z):  # x=1 y=2  z=(3,4,5)
    print(x,y,z)

func(1,2,3,4,5)
func(1,2)
func(1)


def my_sum(*args):
    res=0
    for i in args:
        res+=i
    print(res)

my_sum(1)
my_sum(1,2)
my_sum(1,2,3)

6.2.2 在形参中带**

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

def func(x,y,**kwargs):  # x=1 y=2  kwargs={"b":2,"c":3,"a":1}
    print(x,y,kwargs)

func(1,y=2,a=1,b=2,c=3)

6.3 *与**也可以用在实参中

6.3.1 在实参带*

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

def func(a,b,c,d):
    print(a,b,c,d)

func(*"hell")  # func("h","e","l","l")
func(*[11,22,33,44])  # func(11,22,33,44)
func(11,22,*[33,44])  # func(11,22,33,44)
func(11,22,*{"k1":333,"k2":4444})  # func(11,22,"k1","k2")

6.3.2 在实参带**

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

def func(a,b,c,d):
    print(a,b,c,d)

func(**{"k1":333,"k2":4444})  # func(k2=4444,k1=333)
func(**{"d":333,"b":4444,"a":1111,"c":2222})  # func(a=1111,c=2222,b=4444,d=333)
# func(**[("a",111),("b",111),("c",111),("d",111)])  # 错误

6.4 混用

在形参中，*必须放在**前
在实参中，*必须放在**前

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)


wrapper(1,2,3,4,a=1,b=2,c=3)
wrapper(1,2,3)
wrapper(z=3,y=2,x=1)

七、 命名关键字形参

7.1 定义

在*与**之间后定义的形参

7.2特点

必须按照key=value的形式传值

def func(x,y=1,*args,a=666,b,**kwargs):
    print(x)
    print(y)
    print(args)
    print(a)
    print(b)
    print(kwargs)

# func(1,2,3,4,5,6,7,a=111,b=222,c=333)
func(1,2,3,4,5,6,7,b=222,c=333)