一、关键字参数

定义一个接受关键字参数的函数

def test_arg(**kargs):
    for key in kargs:
        print(f'{key}==={kargs[key]}')

这里的kargs是一个字典，但传入的参数是 '**kargs', 而非 'kargs'.

可以试试：

test_arg(A=30,B="Chinese")

但你直接传入一个字典，就会报错：

cc = {'C':'50','D':'Japan'}

 这样会报错：

test_arg(cc)

因为此时传入的cc作为一个对象，会被当成一个position argument

那么怎么传这个字典呢？

应该这样：

test_arg(**cc)

这样就是将这个字典cc拆散了，按每个键值对传入给kargs 

二、可变参数

定义一个函数，接受数量可变的参数

def test_positional_arg(*args):
    #args将是一个列表，但传入的是'*args', 而非'args'
    for i in args:
        print(i)

bb = ['A', 1, "China"]

错误的传参方式 

#错误传参方式
test_positional_arg(bb)

严格来说，test_positional_arg(bb) 不能算错。 

但其含义却是 bb作为一个对象传给了test_positional_arg()

bb作为一个整体，传给了test_positional_arg 函数中的args。

所以args中就一个元素， 就是bb。

也就是说： args[0] == bb == ['A', 1, "China"] #效果1

而不是：args[0] == bb[0]=='A'

              args[1] == bb[1]==1

              args[2] == bb[2]=='China'

              #效果2

显然，我们此处想要的是效果2. 所以应该这么写：

test_positional_arg('A', 1, "China")   

如果bb是一个很长的列表，那这样写是不现实的，应该这样写：

test_positional_arg(*bb)

结论：

无论是 '*', 还是'**', 其功能是为了“拆散”了传给函数里面的位置参数或关键字参数。

拆散了是作为多个对象传给函数。

这多个对象构成函数的可变参数列表（test_positional_arg(*args)中的args）中的元素，

或作为函数关键词参数字典（test_arg(**kargs)中的kargs）中的'key:value'。

其实按直接用位置参数也能实现那种效果

三、直接用位置参数

def test_arg3(kargs):
    for key in kargs:
        print(f'{key}==={kargs[key]}')
        

cc = {'C':'50','D':'Japan'}

test_arg3(cc)

def test_positional_arg4(args):
    for i in args:
        print(i)
        
bb = ['A', 1, "China"]
test_positional_arg4(bb)

 

四、参数默认值

定义一个有默认参数值的函数

def test_default_arg(aa,bb="China"):
    print(f'aa:\t{aa}')
    print(f'bb:\t{bb}')

 

 

关键字参数之间换个位置没关系

def test_default_arg2(aa,bb='China', cc='Japan'):
    print(f'aa:\t{aa}')
    print(f'bb:\t{bb}')
    print(f'cc:\t{cc}')

 

五、一个大坑 

def add_end(L=[]):
    L.append('END')
    return L

调用两次

lst = add_end()
lst = add_end()
print(lst)