函数的参数

一,函数的参数分为两大类;

　　1,形参:在定义函数时括号内指定的参数(变量名),称之为形参

　　2,实参:在调用函数时括号内传入的值(变量值),称之为实参

　　二者的关系:在调用函数时,实参值(变量值)会传给形参(变量名),这种绑定关系在调用函数时生效,调用结束后解除绑定

二,函数参数详解

1,形参:

　　位置形参:　　在定义阶段,按照从左到右的顺序依次定义的形参　　
　　　　　　　　特点:必须被传值

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


func(1,2,3)
func(1,2,3,4)   #报错
func(1,2,)      #报错

　　默认参数:　　在定义阶段,就已经为某个形参赋值,该形参称之为默认形参
　　　　　　　　特点: 在定义阶段就已经有值,意味着调用阶段可以不用为其传值
　　　　　　　　注意点: 位置形参必须放在默认形参的前面

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

func(1)
func(1,3333333)

def register(name,age,sex='male'):
    print(name,age,sex)

register('靓仔',18,)
register('小红',28,)
register('小黑',38,)
register('花姑娘',16,'female')

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

 　　形参中*与**的用法:

　　　　形参中带*  :  *将溢出的位置实参存成元组的形式然后赋值其后变量名

　　　　形参中带**  :  **将溢出的关键字实参存成字典的格式然后赋值其后变量名

2.实参

　　位置实参:  在调用阶段,按照从左到右的顺序依次传入的值
　　　　　　　　特点:  这种传值方式会与形参一一对应

　　关键字实参: 在调用阶段,按照key=value的格式传值
　　　　　　　　特点: 可以完全打乱位置,但仍然能为指定的形参传值

　　　　注意:     可与混用关键字实参与位置实参,但是
　　　　　　　　　　1,同一个形参只能被赋值一次

　　　　　　　　　　2,位置实参必须跟在关键字实参的前面

　　

　　实参中*与**的用法:

　　　　　　1,实参中带* : 先将实参打散成位置实参,然后再与形参做对应

　　　　　　2,实参中带**  :  先将实参打散成关键字实参,然后再与形参做对应

#1、位置参数：按照从左到右的顺序定义的参数
        位置形参：必选参数
        位置实参：按照位置给形参传值

#2、关键字参数：按照key=value的形式定义的实参
        无需按照位置为形参传值
        注意的问题：
                1. 关键字实参必须在位置实参右面
                2. 对同一个形参不能重复传值

#3、默认参数：形参在定义时就已经为其赋值
        可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）
        注意的问题：
                1. 只在定义时赋值一次
                2. 默认参数的定义应该在位置形参右面
                3. 默认参数通常应该定义成不可变类型


#4、可变长参数：
        可变长指的是实参值的个数不固定
        而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs

        ===========*args===========
        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,3,4,5)

        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,*[3,4,5])


        def foo(x,y,z):
            print(x,y,z)
        foo(*[1,2,3])

        ===========**kwargs===========
        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,a=1,b=2,c=3)

        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,**{'a':1,'b':2,'c':3})


        def foo(x,y,z):
            print(x,y,z)
        foo(**{'z':1,'x':2,'y':3})

        ===========*args+**kwargs===========

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

        def wrapper(*args,**kwargs):
            print('====>')
            foo(*args,**kwargs)

#5、命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递
可以保证，传入的参数中一定包含某些关键字
        def foo(x,y,*args,a=1,b,**kwargs):
            print(x,y)
            print(args)
            print(a)
            print(b)
            print(kwargs)

        foo(1,2,3,4,5,b=3,c=4,d=5)
        结果：
            2
            (3, 4, 5)
            3
            {'c': 4, 'd': 5}

此乃重点知识！！！