python函数——形参中的：位置参数，关键字参数，默认参数，*args 和 **kwargs的关系

标签：log   bbb   http   除了   开头   二义性   定义   got   引用   

def foo(a,b,c):
    print("a:" + a)
    print("b:" + b)
    print("c:" + c)

foo("aaa","bbb","ccc")

运行结果：

a:aaa
b:bbb
c:ccc

关键字参数：用于函数调用，通过“键-值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。

#关键字参数传入时位置可以不一一对应，也可以与位置参数混合使用
#注意，关键字参数必须在位置参数之后，否则产生二义性，编译不通过
def foo(a,b,c):
    print("a:" + a)
    print("b:" + b)
    print("c:" + c)

foo("aaa",c="is c",b="is b")

运行结果：

a:aaa
b:is b
c:is c

如下编译不通过，会报错：

def foo(a,b,c):
    print("a:"+a)
    print("b:"+b)
    print("c:"+c)
#错误示范，这样调用编译不通过
foo("is c",a="is a",b="is b")

提示报错：foo()的参数a有多个值

TypeError: foo() got multiple values for argument ‘a‘

默认参数：用于定义函数，为参数提供默认值，调用函数时可传可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）

def foo(a,b,c="hello C"):
    print("a:"+a)
    print("b:"+b)
    print("c:"+c)

foo("hello A","hello B")
‘‘‘运行结果为：
a:hello A
b:hello B
c:hello C‘‘‘

foo("hello a",b="hello b",c="hello c")
‘‘‘运行结果为：
a:hello a
b:hello b
c:hello c‘‘‘

foo("a","b","c")
‘‘‘运行结果为：
a:a
b:b
c:c‘‘‘

多个实参，放到一个元组里面,以*开头，可以传多个参数；**是形参中按照关键字传值把多余的传值以字典的方式呈现

*args：（表示的就是将实参中按照位置传值，多出来的值都给args，且以元祖的方式呈现）

def foo(x,*args):
    print(x)
    print(args)
foo(1,2,3,4,5)#其中的2,3,4,5都给了args

运行结果：

1
(2, 3, 4, 5)

当args与位置参数和默认参数混用的情况下：（注意三者的顺序）

示例一、（三者顺序是:位置参数、默认参数、*args）

def foo(x,y=1,*args):
    print(x)
    print(y)
    print(args)

foo(1,2,3,4,5)#其中的x为1，y=1的值被2重置了，3,4,5都给了args

执行结果是：

1
2
(3, 4, 5)

　示例二、（三者顺序是:位置参数、*args、默认参数）

def foo(x,*args,y=999):
    print(x)
    print(args)
    print(y)

foo(1,2,3,4,5)#其中的x为1，2,3,4,5都给了args,y按照默认参数依旧为1

执行结果是：

1
(2, 3, 4, 5)
999

其中关于*，可以从2个角度来看（需要拆分来看）：

1、从形参的角度来看：

示例：

def foo(*args):#其实这一操作相当于def foo（a,b,c,d,e):
    print(args)
foo(1,2,3,4,5)#其中的1,2,3,4,5都按照位置传值分别传给了a,b,c,d,e

执行结果是：

(1, 2, 3, 4, 5)

2、从实参的角度来看：

示例：

def foo(x,y,z):
    print(x)
    print(y)
    print(z)
foo(*(1,2,3))#其中的*（1,2,3）拆开来看就是：foo（1,2,3），都按照位置传值分别传给了x,y,z

执行结果是：

1
2
3

**kwargs：（表示的就是形参中按照关键字传值把多余的传值以字典的方式呈现）

示例：

def foo(x,**kwargs):
    print(x)
    print(kwargs)
foo(1,y=1,a=2,b=3,c=4)#将y=1,a=2,b=3,c=4以字典的方式给了kwargs

执行结果是：

1
{‘y‘: 1, ‘a‘: 2, ‘b‘: 3, ‘c‘: 4}

关于*kwargs与位置参数、args、默认参数混着用的问题：（注意顺序）

位置参数、args、*kwargs三者的顺序必须是位置参数、args、**kwargs，不然就会报错：

示例：

def foo(x,*args,**kwargs):
    print(x)
    print(args)
    print(kwargs)
foo(1,2,3,4,y=1,a=2,b=3,c=4)
#释义：将1传给了x，将2,3,4以元组方式传给了args，y=1,a=2,b=3,c=4以字典的方式给了kwargs

执行结果是：

1
(2, 3, 4)
{‘y‘: 1, ‘a‘: 2, ‘b‘: 3, ‘c‘: 4}

错误示例：（由于顺序错误）

def foo(x,**kwargs,*args):
    print(x)
    print(args)
    print(kwargs)
foo(1,y=1,a=2,b=3,c=4,2,3,4)

执行结果就会报错：

SyntaxError: invalid syntax

* 位置参数、默认参数、kwargs三者的顺序必须是位置参数、默认参数、kwargs，不然就会报错：

示例：

def foo(x,y=1,**kwargs):
    print(x)
    print(y)
    print(kwargs)
foo(1,a=2,b=3,c=4)#将1按照位置传值给x，y按照默认参数为1，a=2,b=3,c=4以字典的方式给了kwargs

执行结果是：

1
1
{‘a‘: 2, ‘b‘: 3, ‘c‘: 4}

其中关于**，可以从2个角度来看（需要拆分来看）：

1、从形参的角度来看：

示例：

def foo(**kwargs):#其实就是相当于def foo(y,a,b,c)
    print(kwargs)
foo(y=1,a=2,b=3,c=4)

执行结果是：

{‘y‘: 1, ‘a‘: 2, ‘b‘: 3, ‘c‘: 4}

2、从实参的角度来看：

示例一：

def foo(a,b,c,d):
    print(a)
    print(b)
    print(c)
    print(d)
foo(**{"a":2,"b":3,"c":4,"d":5})
#释义：**{"a":2,"b":3,"c":4,"d":5}是将字典里的每个值按照关键字传值的方式传给a,b,c,d

执行结果是：

2
3
4
5

示例二：

def foo(a,b,c,d=1):
    print(a)
    print(b)
    print(c)
    print(d)
foo(**{"a":2,"b":3,"c":4})
#释义：**{"a":2,"b":3,"c":4}是将字典里的每个值按照关键字传值的方式传给a,b,c；d依旧按照默认参数

执行结果是：

2
3
4
1

上文中关于*args和**kwargs的例子是引用下面这位兄弟的，原文链接在下面
https://www.cnblogs.com/xuyuanyuan123/p/6674645.html

python函数——形参中的：位置参数，关键字参数，默认参数，*args 和 **kwargs的关系

标签：log   bbb   http   除了   开头   二义性   定义   got   引用   

原文地址：http://blog.51cto.com/13993319/2317427