#1、位置参数：按照从左到右的顺序定义的参数

        位置形参：必选参数

        位置实参：按照位置给形参传值

#2、关键字参数：按照key=value的形式定义的实参

        无需按照位置为形参传值

        注意的问题：

                1. 关键字实参必须在位置实参右面

                2. 对同一个形参不能重复传值

#3、默认参数：形参在定义时就已经为其赋值

        可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）

        注意的问题：

                1. 只在定义时赋值一次

                2. 默认参数的定义应该在位置形参右面

                3. 默认参数通常应该定义成不可变类型

#4、可变长参数：

        可变长指的是实参值的个数不固定

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

#5、命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递

！

　　# x，y就是形式参数

　　　　def func(x,y):

　　　　pass

　　2. 实际参数：调用函数是，括号内由外部调用者传入的值，其实就是变量值，

'''

注意点

实参值（变量的值）和形参（变量名）的绑定关系只有在函数调用时才会生效

函数调用结束后，就会失效，解除绑定，释放资源

'''

def foo(x,y,z):

    print(x,y,z)

# 位置形参必须为其传值，有几个形参，必须传入几个值

#1,2,3都是位置实参

foo(1,2,3)

........

foo(1,2,3)

foo(y=2,x=1,z=3)

# 必须遵循形参的规则

foo(x,y,z)

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

# 不能为同一个形惨重复传值

foo(x,y,z)

foo(1,x=1,z=3,y=2)

# 注意在函数定义阶段已经有值，意味着调用阶段可以不用传值

# 如果传值，那就覆盖默认参数

def register(name, age, gender='male'):

    print(name, age, gender)

register('Archer, 20)

register('Bob, 22)

register('Carol‘, 27，'Female')

# 对于经常需要变化的值，需要将对应的形参定义为位置形参

# 对于大多数情况下，值都一样，可以将对应的形参定义为默认参数

# 错误参数放置

def func（y=1,x）:

    pass

#正确参数放置

def func(x, y=1):

    pass

# 函数定义阶段

m=10

def foo(x,y=m):

    print(x,y)

#函数调用阶段(即使这时候m变为11，但是函数调用后还是打印 1,10)

m=11

foo(1,m)

# 以上的打印结果

1 10

# 不会是 1 11

def register(name, hobboy, l=[]):

    l.append(hobby)

    print(name, l)

register('Archor', 'reading')

register('Alen','running')

register('Bob','playing')

#以上的打印结果

Archor reading

Alen reading  running

Bob reading running playing

# 不是很奇怪吗？我们要分别打印出姓名+爱好，但是结果来看，爱好被堆积起来传递下去了

# 这是因为默认参数的值我们定义为了一个空列表，列表是个可变类型（可以改变里面的值，列表的内存地址不变，这是可变类型的特点）

# 如果默认参数被传值的话，就会覆盖原值，可以通过每次都覆盖的方式来改进上面的程序

def register(name, hobby, l=[])

    l.append(hobby)

    print(name,l)

# 这里我们自带了空列表来覆盖每次产生的新值

register('Archor', 'reading', [])

register('Alen', 'running', [])

register('Bob', 'playing', [])

#以上的打印结果

Archor reading

Alen running

Bob playing

# 当然我们也可以通过把默认参数直接设置为None来改进

def register(name, hobby,l=None):

    if l is None:

        l=[]

        l.append(hobby)

    print(name,l)

register('Archor', 'reading')

register('Alen', 'running')

register('Bob', 'playing')

register('Archor', 'reading', [])

register('Alen', 'running', [])

register('Bob', 'playing', [])

# 上面的输出结果为

Archor ['reading']

Alen ['running']

Bob ['playing']

Archor []

Alen []

Bob []

#这里请多加对比思考

def foo(x,y,z,*args):

    print(x,y,z)

    print(args)

foo(1,2,3,4,5,6,7,8,)

# 以上的返回结果为

1 2 3

(4,5,6,7,8,)

def foo(x,y,z,**kwargs):

    print(x,y,z)

    print(kwargs)

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

#以上的返回结果为

1 2 3

｛'a':1,'b':2,'c':3｝

def foo(x,y,z,*args):

    print(x,y,z)

    print(args)

foo(*[1,2,3])

foo(*(1,2,3))
foo(1,2,3,*{'a':1,'b':2})
foo(1,2,3,*'canshu')

# 以上的输出结果

1 2 3

()

1 2 3

()

1 2 3

('a', 'b')

1 2 3

('c', 'a', 'n', 's', 'h', 'u')

        ===========**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)