【Python】函数参数总结（位置参数|默认参数|可变参数|关键字参数|命名关键字参数|参数组合）

最新推荐文章于 2021-08-17 12:30:41 发布

原创最新推荐文章于 2021-08-17 12:30:41 发布 · 538 阅读

0 ·

CC 4.0 BY-SA版权

Python 专栏收录该内容

3 篇文章

订阅专栏

本文总结了Python函数参数的五种类型：位置参数、默认参数、可变参数、关键字参数和命名关键字参数。重点讨论了默认参数必须指向不变对象的原因，以及可变参数如何通过*操作符处理。此外，还解释了关键字参数和命名关键字参数的区别，以及参数组合使用的原则。最后，阐述了Python函数参数匹配的内部过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

位置参数

（从左至右进行匹配）是最普遍最常见的类型。

def posFx(a,b):
    print("a =",a,"b =",b)

posFx(1,2) #a = 1 b = 2
posFx(2,1) #a = 2 b = 1

默认参数

（默认参数允许创建函数可选的参数）如果没有传入值的话，在函数运行前，参数就被赋予了默认值。

def defFx(a,b):
    print("a =",a,"b =",b)

defFx(2)
#TypeError: posFx() missing 1 required positional argument: 'b'

----------------------------------------------------------------

def defFx(a,b=4):
    print("a =",a,"b =",b)

defFx(5) #a = 5 b = 4

默认参数可以简化函数的调用，在某一或某些参数变化不大的情况下，如果将其设置为默认参数，会让函数调用变得更简单。

#如果登记信息的学生年龄大多数都是18岁，只有参数不符才需要覆盖默认值
def defFx(name,age=18):
    print("name =",name,"age =",age)

defFx("Sally") #name = Sally age = 18
defFx("Rose",20) #name = Rose age = 20

但是，默认参数必须指向不变对象！

def test(tmp=[]):
    tmp.append('test')
    return tmp

print(test([1,2,3])) # [1, 2, 3, 'test']
print(test([1,2,3])) # [1, 2, 3, 'test']
print(test()) # ['test']
print(test()) # ['test', 'test']

上面这个例子，可以发现当连续两次使用默认参数时，结果变得有些不可控...而正常传参则不会有这样的问题。这是为什么呢？让我们在函数中输出，看看默认参数在传参的过程会发生什么样的变化。

def test(tmp=[]):
    global cnt
    print("次数:",cnt,"默认参数:",tmp)
    cnt = cnt+1
    tmp.append('test')
    return tmp

cnt = 1
print(test([1,2,3])) 
print(test([1,2,3])) 
cnt = 1
print(test()) 
print(test()) 

'''
次数: 1 默认参数: [1, 2, 3]
[1, 2, 3, 'test']
次数: 2 默认参数: [1, 2, 3]
[1, 2, 3, 'test']
次数: 1 默认参数: []
['test']
次数: 2 默认参数: ['test']
['test', 'test']
'''

正常调用时默认参数并没有发生改变，一直都是传入的'[1,2,3]'，而默认调用在第二次时，默认参数由[]变成了['test']！这是因为默认参数tmp是一个可变对象，初始时指向[]，每次调用时由于append函数改变了tmp的内容，所以在下一次调用时，默认参数便不再是[]而是上一次调用的返回值。正常调用则会因传入参数覆盖了之前的值，而不受影响。

可变参数

（收集任意多基于位置或关键字的参数）任意，即传入参数的个数是可变的。

基于这一思想，我们会联想到C语言的数组。在函数调用时，如果传入的参数个数太多或者无法确定，那么通常会使用数组来存储它们。当数组作为形参时，其中一种办法是类型名+*+变量名。可变参数的使用和这有些相似。

def test(*tmp):
    print(type(tmp)) # <class 'tuple'>
    sum = 0
    for i in range(len(tmp)):
        sum += i
    return sum

print(test(1,2,3,4,5)) # 10
print(test()) # 0

从函数的输出可见，参数tmp接收到的是一个元组。

那么问题来了，如果我传入的参数本身就是一个元组或者列表类型会发生什么呢？让我们试试看~

def test(*tmp):
    print(type(tmp)) # <class 'tuple'>
    print(tmp) # ([1, 2, 3],)
    sum = 0
    for i in range(len(tmp)):
        sum += i
    return sum

print(test([1,2,3])) # 0

啊哦，行不通，列表作为整体传进去，无法和sum相加。那应该如何拆解呢——那还得靠万能的*号了！

形参的*将传入的众多数字打包到一个元组里保存，实参的*则将传入元组/列表拆分成一个个的元素。

def test(*tmp):
    print(type(tmp)) # <class 'tuple'>
    print(tmp) # ([1, 2, 3],)
    sum = 0
    for i in range(len(tmp)):
        sum += i
    return sum

print(test(*[1,2,3])) # 3

关键字参数

（通过参数名进行匹配）可变参数允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个元组。而关键字参数允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个字典。这里的万能符号是**。

def test(name,age,**kw):
    print('name:',name,'age:',age,'other:',kw)

# 可以只传入必选参数name和age
# name: xiaoming age: 18 other: {}
test('xiaoming',18)
# 也可以传入任意个额外的参数
# name: xiaohong age: 18 other: {'city': 'hangzhou', 'job': 'programmer'}
test('xiaohong',20,city='hangzhou',job='programmer')
# 还可以传入字典类型
# name: xiaohuang age: 22 other: {'hobby': 'shudu'}
test(**{'name':'xiaohuang','age':22,'hobby':'shudu'})

默认参数简化了某个传入参数基本一致的调用，而关键字函数可以扩展函数的功能，在用户输入必选项之后，可以选择性地填入其他内容。

命名关键字参数（Keyword-Only）

（参数必须按照名称传递）和上边的关键字参数感觉差不多，但是实际上差别还是很大的~

比如说位置上，关键字参数是使用**keyword来定义，而命名关键字则是在位置参数和命名关键字参数之间使用*隔开，*后面的就是命名关键字参数啦。

def test(a,*,b,c):
    print('a =',a,'b =',b)

test(1,b=2,c=3)

△命名关键字参数要求必须传入参数名，否则会报错。

def test(a,*,b,c):
    print('a =',a,'b =',b,'c =',c)

# a = 1 b = 2 c = 3
test(c=3,b=2,a=1)
# TypeError: test() takes 1 positional argument but 3 were given
test(1,2,3)

再比如说用法上，命名关键字的特点让我们可以限制只接受哪些参数作为关键字参数。也可以说是关键字参数的功能扩展了~

除了,*,的格式外，命名关键字参数还能这么用。（将*换成可变参数）

def test(a,*x,b,c):
    print('a =',a,'x =',x,'b =',b,'c =',c)

# a = 1 x = (2, 3, 4) b = 3 c = 4
test(1,2,3,4,b=3,c=4)
# a = 1 x = () b = 3 c = 4
test(1,b=3,c=4)

除此之外，命名关键字参数也是可以有默认值的。

def test(a,*x,b=1,c='aaa'):
    print('a =',a,'x =',x,'b =',b,'c =',c)

# a = 1 x = (2, 3, 4) b = 1 c = aaa
test(1,2,3,4)
# a = 1 x = (2, 3, 4) b = hhh c = aaa
test(1,2,3,4,b='hhh')

参数组合使用

参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

Python内部是使用以下的步骤来在赋值前进行参数匹配的：

1.通过位置分配非关键字参数。

2.通过匹配变量名分配关键字参数。

3.其他额外的非关键字参数分配到*name元组中。

4.其他额外的关键字参数分配到**name字典中。

5.用默认值分配给在头部未得到分配的参数。

def test1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def test2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)


# a = 1 b = 2 c = 0 args = () kw = {}
test1(1, 2)
# a = 1 b = 2 c = 3 args = () kw = {}
test1(1, 2, c=3)
# a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
test1(1, 2, 3, 'a', 'b')
# a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 54}
test1(1, 2, 3, 'a', 'b', x=54)
# a = 1 b = 2 c = 0 d = 87 kw = {'test': 'hhhhhh'}
test2(1, 2, d=87, test='hhhhhh')

参考资料：1.廖雪峰的官方网站 2.《Python学习手册》(美)MarkLutz