在使用python的过程中，常常需要自定义函数，一个函数实现一个功能，这样可以使得代码逻辑更清晰，别人更容易看懂！
今天我们就来分享一下在函数定义过程中的一个知识点：可变参数。
这里默认，你已经知晓最基本的python函数定义关键字是：def
什么是可变参数？
可变参数，就是在调用函数的时候，传入的参数个数可变！举个例子，print函数
>>> print "apple"
apple
>>> print "apple","banana","orange"
apple banana orange
我们在打印的时候，传入一个变量可以得到结果，传入2个变量就可以打印2个变量的结果，这就是带可变参数的函数。我们可以看一下print的源码：
def print(*args, **kwargs): # known special case of print
"""
print(value, ..., sep=' ', end='\n', file=sys.stdout)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
"""
pass
我们可以看到，这里面出现了两个关键字：*args和 **kwargs，分别是“参数”和“关键字参数”的意思，并且参数args前带了一个*号，关键字参数kwargs前面带了2个*号，下面，我们就分别讲解一下。
*args
想要讲清楚他们，不防先做个试验，那就是我们自己定义一个这样的函数
def my_func(*args):
# 打印出这个可变参数，看看它到底什么样？
print type(args)
print args
现在我们来调用这个函数
>>> my_func(1)
<type 'tuple'>
(1,)
>>> my_func(1, 2, 3)
<type 'tuple'>
(1, 2, 3)
>>> my_func("a", 1, None)
<type 'tuple'>
('a', 1, None)
这样我们就清楚的知道了，原来这个可变参数是以元组tupel的形式存在的，并且，把传进来的参数依次放到元组中。
**kwargs
我们用同样的方法来揭开可变关键字参数**kwargs的面纱：
def my_func2(**kwargs):
print type(kwargs)
print kwargs
现在来调用
>>> my_func2(1)
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: my_func2() takes exactly 0 arguments (1 given)
>>> my_func2(1,2,3)
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: my_func2() takes exactly 0 arguments (3 given)
但是，出错了，看来kwargs不能这样调用啊！那该是怎么样调用才对呢？既然他们是不同的参数类型，那肯定是有区别的。
原来，我们调用函数的时候，参数的传递除了直接丢进去，还可以键值对的方式给出，就是讲参数的名字一并传进来。如下这样：
>>> my_func2(a=1)
<type 'dict'>
{'a': 1}
>>> my_func2(a=1, b=2, c=3)
<type 'dict'>
{'a': 1, 'c': 3, 'b': 2}
O啦，可变关键字参数**kwargs的调用方式便是以键值对的方式传进去，然后以字典的形式存在kwargs中。
需要注意的细节
好，到这里，python可变参数的基本知识已经了解了，但是在实际应用的过程中，肯定还会遇到各种问题。
比如：
def my_func3(a, b, c=1, d=2, *args, **kwargs):
print "a: ", a
print "b: ", b
print "c: ", c
print "d: ", d
print "args: ", args
print "kwargs: ", kwargs
像上面这样的函数，参数a，b没有默认值，在调用的时候必须要给出来, 而c和d可以不用给，后面如果还有新的参数，就可以通过args和kwargs来传递
>>> my_func3(11, 22, 33, 44, 55, 66, 77)
a: 11
b: 22
c: 33
d: 44
args: (55, 66, 77)
kwargs: {}
我们全部传递一系列单个值进去，前面4个固定参数依次得到前4个参数值，后面剩下的都给可变参数args了，kwargs是空的。
如果我们全部传递键值对进去，那么args则不会得到值
>>> my_func3(a=11, b=22, c=33, d=44, e=55, f=66, g=77)
a: 11
b: 22
c: 33
d: 44
args: ()
kwargs: {'e': 55, 'g': 77, 'f': 66}
如果我们要a和b获得新值，c和d保持默认的值，然后args和kwargs都要得到值，那怎么做呢？
>>> my_func3(a=11, b=22, 33, e=55, f=66, g=77) # 语法不允许
>>> my_func3(11, 22, 33, e=55, f=66, g=77)
a: 11
b: 22
c: 33
d: 2
args: ()
kwargs: {'e': 55, 'g': 77, 'f': 66}
第一种语法不允许，第二种调用方式，c把第三个参数拿去了，args是空的。
唯一的方式，是把前4个参数的值依次安排好（非键值对的方式），一个都不能漏，然后才能赋给args，接下来的（键值对）赋给kwargs
>>> my_func3(11, 22, 1, 2, 333, 444, "args", e=55, f=66, g=77)
a: 11
b: 22
c: 1
d: 2
args: (333, 444, 'args')
kwargs: {'e': 55, 'g': 77, 'f': 66}
sys.argv
这里还给大家分享一个跟可变参数逻辑上有共通之处的参数传递方式：命令行参数
顾名思义，我们在命令行执行python脚本的时候，也可以传递参数到脚本内部
$ python test.py 1 2 3
以上的代码是我们在命令行执行test.py脚本，并在后面传了三个参数1,2,3，那么在脚本内部，怎么获取到这三个传进来的参数呢？其中一种方式就是通过sys.argv变量。
# -*- coding: UTF-8 -*-
import sys
print type(sys.argv)
print sys.argv
执行的结果如下：
$ python test.py 1 2 3
<type 'list'>
['usr/test.py', 1,2,3]
没错，sys.argv是一个列表，第一个元素脚本的位置，后面依次就是传进来的命令行参数！
还要注意的是，传入的时候，这些参数要用空格隔开，字符串不需要加引号。
另外，这种来自命令行的参数，python还提供了一个模块getopt来获取，功能更强大，支持短选项模式（-）和长选项模式（--），有兴趣的可以了解一下。
