Python不定长参数列表
用星号*实现不定长参数列表，单个*表示将参数以tuple的形式传入，两个*表示将参数以dict的形式传入，前者传参不能指定参数，后者传参必须指定参数，且参数会被处理成str类型。
def f(*args, **kwargs):
    print "args:"
    for x in args:
        print x, type(x)
    print "kwargs:"
    for k,v in kwargs.iteritems():
        print k, type(k), v, type(v)

f(1,'A',[], a=2,b=3)

文章目录
1、简介
2、必须参数
3、默认值函数
4、可变参数函数
5、可变关键字参数函数

1、简介
python  常见参数函数类型
2、必须参数
也就是我们常见的参数
def  fun (name ,age):
    print(name + " "+ str(age) )

fun ("lum",27)

log:

lum 27
3、默认值函数
def fun_1(name,country = "CN",sex = "Man"):
    print(name +" " +  country + " " + sex)

fun_1("lum")
fun_1("lum","China")
fun_1("lum",sex = "Boy")

打印：

lum CN Man

lum China Man

lum CN Boy
4、可变参数函数
可以传入任意个参数
def fun_3(*args):
    print(args)

fun_3(1)
fun_3("hello",1)
fun_3(1,[1,"Hello",False])
fun_3("hello",134,True)

打印：

(1,)

(‘hello’, 1)

(1, [1, ‘Hello’, False])

(‘hello’, 134, True)
我们看到 可变参将传进去的参数都放在了元组里，变成了数组对象

def fun_3(*args):
    print(args)
    
fun_3([1,"Hello"])
fun_3(*[1,"Hello"])


打印:
([1, ‘Hello’],)

(1, ‘Hello’)
def fun_3(*args):
    print(args)
    
fun_3("Hello")
fun_3(*"Hello")

打印：

(‘Hello’,)

(‘H’, ‘e’, ‘l’, ‘l’, ‘o’)
def fun_3(*args):
    print(args)
fun_3((1,"Hello"))
fun_3(*(1,"Hello"))

打印：

((1, ‘Hello’),)

(1, ‘Hello’)
我们可以看到，可变参数也可以传递 字符串，列表、元组，但是在传递之前添加一个 * 就出 序列解包，也就是把他们里面的元素拿出来 ，依次传递

示例：

def fun3(*args):
    string = ""
    for i in  args:
        string += str(i)
    print(string)

fun3(1,"SB",True)
fun3(*[1,"SB",True])
fun3([1,"SB",True])

打印：

1SBTrue

1SBTrue

[1, ‘SB’, True]
5、可变关键字参数函数
#fun4(1)  
#fun4(1,2)
#fun4({"name:1"})
#fun4(**[[1,"Hello"]])   以上出错

fun4(name = 1)
fun4(name=1,age=2)
fun4(**{"sex":3})      #3 可传入字典

打印：

{‘name’: 1}

{‘name’: 1, ‘age’: 2}

{‘sex’: 3}
我们看到可变关键字函数，传入之后被封装成了 字典
实例：
def fun4(**args):
    print(args)
    for i in args.keys():
        print(str(i)) # 将键打印出来

#fun4(1)
#fun4(1,2)
#fun4({"name:1"})
#fun4(**[[1,"Hello"]])
fun4(name = 1)
fun4(name=1,age=2)
fun4(**{"sex":3})    


打印：

{‘name’: 1}

name

{‘name’: 1, ‘age’: 2}

name

age

{‘sex’: 3}

sex

python参数传递：对象的引用
        大家都知道在python中，一切皆对象，变量也不再具有类型，变量仅仅是对象的一个引用，我们通常用变量来测类型，通常测得就是被这个变量引用得对象的类型。

例如：



这里的类型就是123这个对象的类型。变量的作用就相当于c中的指针，指向特定的内存空间，有了这个基础，我们就可以来聊一聊python中的参数传递了。

接触过c或c++的朋友都知道，一般我们常说的传参方式有两种：传引用、传值

但是python和他们都不一样。python采用的是传递对象的引用，为了方便说明，我们来看一个例子：
test = [1]
def change1(a):
	a = [2]

def change2(a):
	a.append(3)

change1(test)
change2(test)
print test

我们来看一下最后的输出：

[1,3]

是不是有人误以为是[2,3]?那你可得好好看接下来的内容。

传参传的是对象的引用！！！！！！

所以在change1(a)函数中，我们知道形参a与test引用了同一块内存空间，然后a在函数内部被修改了，它执行了另一块内存空间，也就是存放[2]的地方，但是只是a的指向改变了，test的指向还是存放[1]的内存空间。所以，接下来change2()对这块内存空间上放的值进行了修改，就得到了我们最后看到的结果。

为了加深理解，我觉得有必要再举一个类继承的例子：
class Parent(object): 

  x = 1

​class Child1(Parent): 

  pass

​class Child2(Parent): 

  pass

​print Parent.x, Child1.x, Child2.x 

Child1.x = 2

​print Parent.x, Child1.x, Child2.x 

Parent.x = 3

​print Parent.x, Child1.x, Child2.x​

输出结果为：

1 1 1

1 2 1

3 2 3

在继承中，所有子类中的x原本都是引用的父类中x对象的存储空间，但是child1中的x单独指向了另一块存储空间。这样以来，的到这个结果也就不意外了

定义默认参数要牢记一点：默认参数必须指向不变对象！ 否则会掉进坑里面的
参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
比如定义一个函数，包含上述若干种参数：
def f1(a, b, c=0, *args, **kw):

print(‘a =’, a, ‘b =’, b, ‘c =’, c, ‘args =’, args, ‘kw =’, kw)
def f2(a, b, c=0, *, d, **kw):

print(‘a =’, a, ‘b =’, b, ‘c =’, c, ‘d =’, d, ‘kw =’, kw)

在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。



f1(1, 2)

a = 1 b = 2 c = 0 args = () kw = {}




f1(1, 2, c=3)

a = 1 b = 2 c = 3 args = () kw = {}




f1(1, 2, 3, ‘a’, ‘b’)

a = 1 b = 2 c = 3 args = (‘a’, ‘b’) kw = {}




f1(1, 2, 3, ‘a’, ‘b’, x=99)

a = 1 b = 2 c = 3 args = (‘a’, ‘b’) kw = {‘x’: 99}




f2(1, 2, d=99, ext=None)

a = 1 b = 2 c = 0 d = 99 kw = {‘ext’: None}

最神奇的是通过一个tuple和dict，你也可以调用上述函数：






args = (1, 2, 3, 4)

kw = {‘d’: 99, ‘x’: ‘#’}

f1(*args, **kw)

a = 1 b = 2 c = 3 args = (4,) kw = {‘d’: 99, ‘x’: ‘#’}




args = (1, 2, 3)

kw = {‘d’: 88, ‘x’: ‘#’}

f2(*args, **kw)

a = 1 b = 2 c = 3 d = 88 kw = {‘x’: ‘#’}

所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。



虽然可以组合多达5种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。
小结

Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
要注意定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
以及调用函数时如何传入可变参数和关键字参数的语法：
可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过args传入：func((1, 2, 3))；
关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过kw传入：func({‘a’: 1, ‘b’: 2})。
使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。
定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。