Python 的四种共享传参详解

Python 唯一支持的参数传递方式为共享传参（call by sharing），传递参数一共有四种传递方式，分别为：位置参数，默关键字参数和可变参数，其中可变参数分为两种（*args 和 **kargs）。

一、位置参数

函数调用时，参数会根据函数定义的参数位置而自动传递。

1. def func(a, b):

2. print(a)

3. print(b)

4. return a+b

5.  

6. >>func("A", "B")

7. A

8. B

9. 'AB'

10.  

11. >>func("B", "A")

12. B

13. A

14. 'BA'

在上述实例中，我们发现参数的传递必须严格按照参数的定义位置进行传递的，而且函数的参数与调用函数所传递的参数数量不一致时，就会引发TypeError。

二、默认参数

函数调用时，为函数的某个参数提供默认值，调用函数时可选择不传入改参数的值。

1. def func(a="B", b):

2. print(a)

3. print(b)

4. return a+b

5.  

6. SyntaxError: non-default argument follows default argument

1. def func(a, b="A"):

2. print(a)

3. print(b)

4. return a+b

5.  

6. >>func("A")

7. A

8. A

9. 'AA'

10.  

11. >>func("A", "B"):

12. A

13. B

14. "AB"

从上述实例中，我们发现默认参数必须在位置参数的后面。个人认为默认参数是位置参数的一种缺省形式。这也可以解释为何默认参数必须在位置参数的后面。

三、关键字参数

在进行函数调用时，使用 "参数名"="值" 的形式进行参数指定。清除位置参数在调用时的顺序要求。

1. def func(a, b):

2. print(a)

3. print(b)

4. return a+b

5.  

6. >>func(b="B", a="A")

7. A

8. B

9. "AB"

10.  

11. def func(a, b="B"):

12. print(a)

13. print(b)

14. return a+b

15.  

16. >>func(a="A")

17. A

18. B

19. 'AB'

20.  

21. >>func(a="A", b="C"):

22. A

23. B

24. 'AC'

从上述实例可以看出，虽然函数定义时按照位置参的形式定义的，但是依然可以在调用的时候可以使用关键字参数来进行指定，如果函数定义时有默认参数，则依然可以选择缺省或者传入。

四、可变参数

可变参数是指在函数定义时使用 *args (*加参数名)和 **kargs (**加参数名)的形式作为参数，在函数调用时就可以传入多个参数，会在实际工程中更加灵活，其中 *args 对应着传入多个位置参数，**kargs 对应传入多个关键字参数。

1. def func(*args):

2. print(type(args))

3. print(args)

4. for i in args:

5. print(i)

6.  

7. >>func("A", "B")

8. <class 'tuple'>

9. ('A', 'B')

10. A

11. B

12.  

13. >>> func()

14. <class 'tuple'>

15. ()

从上述实例中可以看出，可变参数 *args 在使用时可以自由选择位置参数个数，在函数使用时，函数会自动生成一个元组 (tuple) 来放置位置参数，我们在定义函数的时候只需要操作对应的元组即可，注意一个小细节，为何要使用元组？这实际上也对应了位置参数的位置不可变性。

1. def func(**kargs):

2. print(type(kargs))

3. print(args)

4. for key, value in kargs.items():

5. print("%s : %s" % (key,value) )

6.  

7. >>> func(a="A", b="B")

8. <class 'dict'>

9. {'a': 'A', 'b': 'B'}

10. a : A

11. b : B

12.  

13. >>> func(b="B", a="A")

14. <class 'dict'>

15. {'b': 'B', 'a': 'A'}

16. b : B

17. a : A

18.  

19. >>> func()

20. <class 'dict'>

21. {}

从上述实例可以看出，可变参数 **kargs 使用时也可以自由选择关键字参数的个数，在函数使用时，函数会生成一个字典(dict)来放置关键字参数，我们在定义函数时只需要操作对应的字典字典即可，同样注意一个小细节，为何是使用字典？这同样也对应了关键字参数的位置可变性。

五、四种参数的混用

我们在实际应用中，经常会用到这几种参数的搭配使用，下面通过一个例子来解释这四种参数的混用情况。

1. def func(a, b="B", *args, c,**kargs):

2. print(a)

3. print(b)

4. print(*args)

5. print(c)

6. print(kargs)

7.  

8. >>> func("A", "X", "Z", c="CC", d="DD", f="FF")

9. A

10. X

11. Z

12. CC

13. {'d': 'DD', 'f': 'FF'}

14.  

15. >>> func("A",c="CC")

16. A

17. B

18.  

19. CC

20. {}

从上述实例中可以看出，我们在混用时主要遵循两个原则

1.在函数定义时，顺序为（位置参数，默认参数，*args 可变参数，关键字参数， **kargs 可变参数）。

2.在调用时，位置参数和关键参数一定要有，不可缺省，可变参数可以缺省。特别注意，如果定义了默认参数，又定义了 *args 可变参数，需注意位置参数的个数，因为函数调用默认会先识别默认参数。上述实例中就有这种情况。