函数的分类

• 形参   ：在函数定义（）中出现的从参数叫做形参

　　　　　　  形参就是拷贝实参的值，随着函数的调用才产生，随着函数调用结束而销毁

• • 位置形参 ：必须按照顺序
  • 关键字形参  ：
  • 默认形参  ：具有默认值，可以有 位置实参 与 关键字实参 来传值，还可以不传值（采用自身的值）
  • 可变长位置形参*args  用元组存 没有被 位置形参 默认形参 接收完对的位置实参

　　　　　　 　　只能有位置实参来传值  可变长形参只能接收位置实参的值，位置实参必须在关键字实参前， 导致默认形参只能由位置实参来传值 

def fn(a, b=10, *args):
    print(a, b)
    print(args)

fn(1, 20, 100, 200)

def fn(*args):
    print(args)

fn(1, 2, 3, 4, 5)  # (1, 2, 3, 4, 5)

a = 'ab'
b = [1, 2]
c = (1, 2)
d = {1, 2}
fn(a)  # ('ab', )
fn(b)  # ([1, 2], )
fn(c)  # ((1, 2), )
fn(d)  # ({1, 2}, )

def fn1(*args):
    print(args)
ls = [1, 2, 3, 4, 5]
fn1(ls)  # (ls, )

fn1(*ls)  # 将ls打散为1,2,3,4,5再进行传值=>(1,2,3,4,5) 只打散第一层
可以用占位符 *args 当做多个占位符，右边的相当于多个值，当做解压赋值来理解
调用时不带*只有args只会把转成元组里面的一个元素

　　　　　　！！！出现 * 后的都是关键字形参  *args也可以值用来做分隔

• • 可变长关键字形参**kwargs 用字典存 没有被关键字形参接收完的关键字形参

　　　　　　　　只能由关键字实参来传值

dd = {
    'k1': [1, 2, 3, 4, 5],
    'k2': {"name":"Bob"}
}
fn1(**dd)

{'k1': [1, 2, 3, 4, 5], 'k2': {'name': 'Bob'}}

def fn2(*args):
    print(args)
ll = [1, [1, 2], {"name":"Bob"}]
fn2(*ll)  

(1, [1, 2], {"name":"Bob"})

 

　　　　　　　　

　　　　　位置形参可以由位置实参与关键字实参来传值

　　　　　位置形参与默认形参同时存在，默认形参必须在后

实参  ： 在函数调用（）中出现的参数（外界实际存在的值）：实参  作用：为形参传值

    调用函数是实参可以由常量、变量、表达式或者三种的组合　　

• 位置实参 ：按照位置的顺序，从左到右为形参传值
• 关键字实参 ：可以不按照顺序，形参按名字取值 关键字形参必须由关键字实参来传值

　　　　　　　位置实参必须出现在关键字实参之前

#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}

此乃重点知识！！！