python

1)可变位置参数

在Python中，函数在定义时可以拥有任意数量的参数，这种参数称为可变参数。可以通过定义可变参数，来接收调用函数时多余的参数。可变参数又分为可变位置参数和可变关键字参数，它们的区别如下：

①可变位置参数用来接收调用函数时多余的位置参数;在函数体内，可变位置参数是一个元组。

②可变关键字参数用来接收调用函数时多余的关键字参数;在函数体内，可变关键字参数是一个字典。

可变位置参数是在普通的参数前面加一个星号“*”，一般命名为args(arguments的缩写)，但实际上它可以用任意合法的名称：

1. >>> def f(*args): # *args是可变位置参数
2. ... print(args) # 打印args
3. ... print(type(args)) # 打印args的类型
4. ... for i in args: # 迭代元组
5. ... print(i)
6. ...
7. >>> f('Python', 42, 3.14)
8. ('Python', 42, 3.14)
9. <class &#39;tuple&#39;>
10. Python
11. 42
12. 3.14

由运行结果可知，可变位置参数在函数体内是一个元组。另外，函数体内的args不需要加星号。

在定义函数时，如果不确定所需要的参数个数，那么可以使用可变参数。假设要写一个算术加法运算的程序，不使用可变参数时，只能将确定个数的数字相加：

1. >>> def add_numbers(a, b, c): # 这个函数只能让三个数字相加
2. ... print(a + b + c)
3. ...
4. >>> add_numbers(1, 2, 3)
5. 6

如果使用可变参数，那么可以实现让任意个数的数字相加：

1. >>> def add_numbers(*numbers): # 将可变位置参数命名为numbers
2. ... sum = 0
3. ... for i in numbers: # 由于numbers是元组，因此，可以使用for循环迭代
4. ... sum += i
5. ... print(sum)
6. ...
7. >>> add_numbers(1, 2, 3, 4, 5, 6)
8. 21
9. >>> add_numbers(42, 19, 25)
10. 86
11. >>> add_numbers() # 可变位置参数也可以传递0个参数
12. 0

可变位置参数可以与普通的参数混用。假设要打印一份水果店的公告，其中第一个参数是普通的参数，代表水果店的名字，第二个参数是可变位置参数，用来接收除了水果店名字之外的其他位置参数：

1. >>> def fruit_shop(shop_name, *fruits):
2. ... print(&#39;{0}水果店开业啦！&#39;.format(shop_name))
3. ... print(&#39;在售的水果有：&#39;)
4. ... for fruit in fruits:
5. ... print(fruit)
6. ...
7. >>> fruit_shop(&#39;小明&#39;, &#39;苹果&#39;, &#39;香蕉&#39;, &#39;西瓜&#39;)
8. 小明水果店开业啦！
9. 在售的水果有：
10. 苹果
11. 香蕉
12. 西瓜

函数调用时，&#39;小明&#39;被shop_name接收，剩余的值都被*fruits接收，并存储在fruits元组中。

2)可变关键字参数

可变关键字参数是在普通的参数前面加两个星号“**”，一般命名为kwargs(keyword arguments的缩写)，但实际上它可以用任意合法的名称：

1. >>> def f(**kwargs): # **kwargs是可变关键字参数
2. ... print(kwargs)
3. ... print(type(kwargs)) # 打印kwargs的类型
4. ... for k, w in kwargs.items(): # 迭代字典
5. ... print(&#39;{0}--{1}&#39;.format(k, w))
6. ...
7. >>> f(name=&#39;Ming&#39;, age=19) # 使用关键字参数才能将值存储到kwargs中
8. {&#39;name&#39;: &#39;Ming&#39;, &#39;age&#39;: 19}
9. <class &#39;dict&#39;>
10. name--Ming
11. age--19
12. >>> f() # 可变关键字参数也可以传递0个参数
13. {}

可变关键字参数可以与普通的参数混用。假设在前面的“水果店”程序中，不仅打印水果的名称，还打印水果的个数：

1. >>> def fruit_shop_v2(shop_name, **fruits):
2. ... print(&#39;{0}水果店开业啦！&#39;.format(shop_name))
3. ... print(&#39;在售的水果有：&#39;)
4. ... for fruit, count in fruits.items(): # 迭代字典
5. ... print(&#39;{0}{1}个&#39;.format(fruit, count))
6. ...
7. >>> fruit_shop_v2(shop_name=&#39;小明&#39;, 苹果=10, 香蕉=3, 橘子=201)
8. 小明水果店开业啦！
9. 在售的水果有：
10. 苹果10个
11. 香蕉3个
12. 橘子201个

下面是一个更复杂的“水果店”程序，四个参数中，shop_name代表商店名称，open_time代表开业时间，*fruits代表水果种类，**other_info代表水果店还想打印的额外信息：

1. >>> def fruit_shop_v3(shop_name, open_time=&#39;10月1日&#39;, *fruits, **other_info):
2. ... print(&#39;{0}水果店将在{1}开业！&#39;.format(shop_name, open_time))
3. ... if fruits:
4. ... print(&#39;在售的水果有：&#39;)
5. ... for fruit in fruits:
6. ... print(fruit)
7. ... if other_info:
8. ... print(&#39;以下是额外信息：&#39;)
9. ... for item, info in other_info.items():
10. ... print(&#39;{0}：{1}&#39;.format(item, info))
11. ...
12. >>> fruit_shop_v3(&#39;小明&#39;) # shop_name既没默认值，又不是可变参数，故不能缺省
13. 小明水果店将在10月1日开业！
14. >>> fruit_shop_v3(&#39;小明&#39;, &#39;1月1日&#39;) # 提供shop_name和open_time
15. 小明水果店将在1月1日开业！
16. >>> fruit_shop_v3(open_time=&#39;1月1日&#39;) # 如果不指定shop_name的值，会报错
17. Traceback (most recent call last):
18. File "<stdin>", line 1, in <module>
19. TypeError: fruit_shop_v3() missing 1 required positional argument: &#39;shop_name&#39;
20. >>> fruit_shop_v3(&#39;小明&#39;, &#39;苹果&#39;, &#39;香蕉&#39;, &#39;橘子&#39;)
21. 小明水果店将在苹果开业！
22. 在售的水果有：
23. 香蕉
24. 橘子
25. >>> fruit_shop_v3(&#39;小明&#39;, &#39;10月1日&#39;, &#39;苹果&#39;, &#39;香蕉&#39;, &#39;橘子&#39;)
26. 小明水果店将在10月1日开业！
27. 在售的水果有：
28. 苹果
29. 香蕉
30. 橘子
31. >>>
32. >>> fruit_shop_v3(&#39;小明&#39;, &#39;10月1日&#39;, &#39;苹果&#39;, &#39;香蕉&#39;, 地址=&#39;北京市&#39;, 开店折扣=&#39;八折&#39;) # 多余参数全部被**other_info接收
33. 小明水果店将在10月1日开业！
34. 在售的水果有：
35. 苹果
36. 香蕉
37. 以下是额外信息：
38. 地址：北京市
39. 开店折扣：八折