参数传递：

1.不可变数据类型：数字number(含int、float、bool、complex)、字符串string、元组tuple。当不可变数据类型被当作函数的参数，传递的是值，函数体内改变值时实际是生成新的对象，不会影响函数体外原来的值。例如：

x=10
def print_add_ten(x):
    x+=10
    print(x)

print_add_ten(x)
print(x)

out:
20
10

2.可变数据类型：列表list、字典dict、集合set。当可变数据类型被当作函数的参数，传递的是引用，函数体内改变值时会影响函数体外的值。例如：

x=[1,2,3,4,5]
def print_change_list(x):
    x[0]=10
    print(x)

print_change_list(x)
print(x)


out:
[10, 2, 3, 4, 5]
[10, 2, 3, 4, 5] 

上述这个函数看起来没有问题，但在特殊场合会导致不可预料的bug。推荐的方式是对可变数据类型参数做copy(注意若存在嵌套结构需要用deepcopy)，然后做处理，并将处理结果返回给调用者。例如：

x=[1,2,3,4,5]
def print_change_list(x):
    x=x.copy()
    x[0]=10
    return x

print(print_change_list(x))
print(x)


out:
[10, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

参数类型

1.位置参数：即按照位置传入参数，参数的个数、位置、类型必须匹配。如：

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

print(power(2,3))

out:
8

2.默认值参数：是指该参数有默认值，默认值必须是不可变数据类型。如：

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

print(power(2))
print(power(2,3))


out:
4
8

3.可变参数：可变参数允许传入0个或任意个参数，这些参数在函数调用时被封装到一个元组，并将这个元组赋值给了args。如：

def calc(*args): # args是约定俗成的名字，可以自定义，但建议用args
    sum = 0
    for n in args:
        sum = sum + n * n
    return sum

print(calc(1,2,3))


out:
14

4.命名关键字参数：必须传入参数名，不指定名字传参会报错。另外命名关键字参数也可指定默认值，有默认值的可以不传参。如：

def person(*, name, age):
    print(name, age)

person(name='Mike', age=20)
#person('Mike',20) # 不指定名字传参会报错


out:
Mike 20

5.关键字参数：允许传入0个或任意个含参数名的参数，这些关键字参数在函数调用时被封装到一个字典中，并将这个字典赋值给了kwargs。但关键字参数不能指定哪些关键字必须有。如：

def person(**kwargs): # kwargs是约定俗成的名字，可以自定义，但建议用kwargs
    print(kwargs)

person(name='Mike',age=20)
person(gender='men',height=180)


out:
{'name': 'Mike', 'age': 20}
{'gender': 'men', 'height': 180} 

补充几点：

• 默认值参数是一种特殊的位置参数或者命名关键字参数，即该参数有默认值。如果不传参，那么该参数取值为默认值(必须是不可变数据类型)；如果传了参那么取值为传的参。
• 关键字参数实际是将参数名和参数值封装成字典传给函数。但是关键字参数的key不固定会导致写代码不方便。所以又有命名关键字参数，命名关键字参数是key固定而value不定的键值对，方便编写代码。
• 位置参数和命名关键字参数的区别：位置参数可按位置传参，也可用名字传参，位置参数必须定义在可变参数前面。命名关键字参数必须指定名字传参，命名关键字参数必须定义在可变参数后(如果没有可变参数时用*代替)，若同时存在关键字参数时命名关键字参数必须定义在关键字参数之前。
• *和**在函数定义时表示封装，在函数调用时代表拆包。

def func(*args, **kwargs):
    print(args)
    print(kwargs)
    print('-'*30)

func([1, 2, 3], [22, 33])  # 不拆包时函数接收的是2个列表
func(*[1, 2, 3], *[22, 33])  # 可迭代对象均可拆包，拆包后函数接收到的是一个元组。
func({'name': '张三'}, {'age': 20})  # 这样传参的2个字典被args接收,kwargs接收的是空字典
func(**{'name': '张三'}, **{'age': 20})  # 这样传参的2个字典被kwargs接收,args接收的是空元组


out:
([1, 2, 3], [22, 33])
{}
------------------------------
(1, 2, 3, 22, 33)
{}
------------------------------
({'name': '张三'}, {'age': 20})
{}
------------------------------
()
{'name': '张三', 'age': 20}
------------------------------