def f(a):
a=99
print(a)
b=88
f(b) #99
print(b) #88
#可变对象是通过"指针"进行传递的，如列表，字典
def changer(a,b):
a=2
b[0]='spam'
x=1
l=[1,2]
changer(x,l)
print(x,l) #1 ['spam',2]
#避免可变参数的修改
import copy
def changer2(b):
b=copy.deepcopy(b)
b[0]='spam'
l=[1,2]
changer2(l)
print(l) #[1,2]
位置：从左到右进行匹配
关键字茶树：通过参数名进行匹配
默认参数：为没有传入值的参数定义参数值
可变参数：收集任意多基于位置或关键字的参数:*形参，用于函数头
可变参数解包：传递任意多基于位置和关键字的参数:*实参，用于调用者
keyword-only参数：参数必须按照名称传递
函数参数匹配表
func(value) 调用者 常规参数：通过位置进行匹配
func(name=value) 调用者 关键字参数：通过变量名匹配
func(*sequence) 调用者 以name传递所有的对象，并作为独立的基于位置的参数
func(**dict) 调用者 以name成对的传递所有的关键字/值，并作为独立的关键字参数
def func(name) 函数 常规参数：通过位置或者变量名进行匹配
def func(name=value) 函数 默认参数值，如果没有在调用中传递的话
def func(*name) 函数 匹配并收集（在元祖中）所有包含位置的参数
def func(**name) 函数 匹配并收集（在字典中）所有包含位置的参数
def func(*args，name) 函数 参数必须在调用中按照关键字传递
def func(*, name=value) 函数 （python 3.0）
函数调用中，参数必须以此顺序出现：位置参数，关键字参数，*sequence，**dict
函数头部中，参数必须以此顺序出现：一般参数，默认参数，*，keyword-only，**
#关键字参数
def f(a,b,c):
print(a,b,c)
f(c=3,b=2,a=1)
#默认参数
def f2(a=1,b=2,c=3):
print(a,b,c)
f2() #1 2 3
f2(a=4) #4 2 3
f2(11,22) #11 22 3
f2(11,22,33) #11 22 33
f2(11,c=33) #11 2 33
#关键字参数和默认参数的混合
def func(spam, eggs, toast=0, ham=0):
print((spam, eggs, toast, ham))
func(1,2) #(1, 2, 0, 0)
func(1,ham=1, eggs=0) #(1, 0, 0, 1)
func(spam=1, eggs=0) #(1, 0, 0, 0)
func(1,2,3,4) #(1, 2, 3, 4)
#任意参数
#收集参数
def f(*args):
print(args)
f(1,2,3,4,5) #(1, 2, 3, 4, 5) 调用时，将所有位置相关的参数收集到一个元素中，并将一个元祖赋值给变量args
def f2(**args):
print(args)
f2(a=1,b=2) #{'a': 1, 'b': 2} **允许关键字阐述转换为字典
def f3(a, *pargs, **kargs):
print(a, pargs, kargs)
f3(1,2,3,x=1,y=2) #1 (2, 3) {'x': 1, 'y': 2} 混合
#解包参数
def f4(a,b,c,d):
print(a,b,c,d)
f4(*(1,2,3,4)) #1 2 3 4 解包参数的集合
f4(**{'a':1,'b':2,'c':3,'d':4}) #1 2 3 4 解包参数的集合
f4(*(1,2),**{'c':3,'d':4}) #1 2 3 4 解包参数的集合
f4(1, *(2,3),**{'d':4}) #1 2 3 4 解包参数的集合
f4(1, c=3, *(2,),**{'d':4}) #1 2 3 4 解包参数的集合
f4(1, *(2,3),d=4) #1 2 3 4 解包参数的集合
f4(1, *(2,),c=3, **{'d':4}) #1 2 3 4 解包参数的集合
#keyword-only参数
def kwonly(a,*b,c):
print(a,b,c)
kwonly(1,2,c=3) #1 (2,) 3
kwonly(a=1,c=3) #1 () 3
#kwonly(1,2,3) #报错，c必须要关键字传递
def kwonly2(a,*,b,c):
print(a,b,c)
kwonly2(1,c=3,b=2) #1 2 3
kwonly2(c=3,b=2,a=1) #1 2 3
#kwonly2(1,2,b=4,c=5) #报错，多了一个参数
def kwonly3(a,*,b='spam',c='ham'):
print(a,b,c)
kwonly3(1) #1 spam ham
kwonly3(1,c=3) #1 spam 3
kwonly3(a=1) #1 spam ham
kwonly3(c=3,b=2,a=1) #123
#kwonly3(1,2) #报错，b和c必须关键字传递
def kwonly4(a,*,b=1,c,d=2):
print(a,b,c,d)
kwonly4(3,c=4) #3 1 4 2
#函数定义中，**args必须在keyword-only之前，*args之后，函数调用中，keyword-only参数必须在**args之前或者包含在**args中，可以编写在*args之前或者之后
def f(a,*b,c=6,**d):
print(a,b,c,d)
f(1,3,4,x=4,y=5) #1 (3, 4) 6 {'x': 4, 'y': 5}
f(1,*(3,4),**dict(x=4,y=5)) #1 (3, 4) 6 {'x': 4, 'y': 5}
f(1,*(3,4),c=7,**dict(x=4,y=5)) #1 (3, 4) 7 {'x': 4, 'y': 5}
f(1,c=7,*(3,4),**dict(x=4,y=5)) #1 (3, 4) 7 {'x': 4, 'y': 5}
f(1,*(2,3),**dict(x=4,y=5,c=7)) #1 (2, 3) 7 {'x': 4, 'y': 5}