《Python 从入门到精通》055|可变参数 *args 和 **kwargs 到底怎么理解

前面一章，我们已经把函数参数里最基础、也最常用的三件事讲清楚了：

位置参数 默认参数 关键字参数

学到这里，很多同学会觉得参数好像已经差不多了。 平时定义个函数，括号里写几个参数，调用时把值传进去，也基本能用了。

但你很快就会遇到一种特别真实的场景：

有时候，你根本不确定以后会传几个参数。

比如：

我想写一个函数，专门把任意多个数字加起来 我想写一个函数，专门打印很多名字 我想写一个函数，接收一堆配置信息，但每次传进来的字段都可能不完全一样 我想让函数更灵活一点，不要每次都把参数个数写死

这时候，如果你还只能靠普通参数去硬写，就会非常别扭。

比如你写：

defadd(a, b):return a + b

它只能接两个数。 可一旦你想算 3 个、5 个、10 个数的和，这个函数就不够用了。

这时候，*args 和 **kwargs 就要登场了。

很多人第一次看到这两个写法时，都会本能地觉得它们很唬人。 尤其是那两个星号，一看就像什么很高级、很抽象、很不好懂的东西。

其实你只要把背后的逻辑想明白，会发现它们比看起来简单得多。

这一章，我们就专门把这两个东西讲透。 不是只让你记语法，而是让你真正知道：

它们到底在解决什么问题 为什么一个前面是一个星号，一个前面是两个星号 为什么一个收的是位置参数，一个收的是关键字参数 它们在函数里到底长什么样 又该在什么场景下用

一、先别急着看星号，先看它们到底在解决什么问题

你先别把注意力放在符号上。 先看需求。

比如现在你想写一个函数，计算很多数字的总和。

前面你学过普通参数，可能会先写：

defadd(a, b):return a + b

这对两个数来说没问题。

print(add(3, 5))

输出：

8

可如果你现在想算三个数呢？

你就得改成：

defadd(a, b, c):return a + b + c

那四个数呢？

defadd(a, b, c, d):return a + b + c + d

五个数呢？

你会发现，这种写法根本没法优雅扩展。 参数个数一变，函数定义就得跟着改。

而现实里，很多函数本来就不是固定收 2 个、3 个参数。 它可能就是想接收 任意多个 同类输入。

这个问题，才是 *args 最核心要解决的。

再比如另一个场景。

你想写一个函数，接收用户信息。 可有时候只传姓名和年龄， 有时候再加城市， 有时候还加邮箱、手机号、职业。

也就是说，这些信息字段本身都可能变化。 这时候你如果把参数一个个写死，也会很别扭。

这个问题，才是 **kwargs 想解决的方向。

所以这一章真正的起点不是星号， 而是一个非常现实的需求：

参数个数和参数字段，不一定总能提前写死

二、什么是可变参数

可变参数，简单说就是：

函数能够接收数量不固定的参数

重点就在 数量不固定 这五个字。

普通参数更像是提前订好座位。 你有几个参数，函数定义时就写死几个位置。

可变参数不一样。 它更像是：

座位数量可以临时加 来了多少个参数，就收多少个

而 Python 里最常见的两种可变参数形式，就是：

*args**kwargs

你现在先不用急着区分细节。 先建立一个总印象：

它们都是为了让函数接收 不固定数量 的输入而存在的。

只不过：

*args 更偏向接收很多位置参数**kwargs 更偏向接收很多关键字参数

后面我们一层层拆开。

*三、先讲 args：它到底是什么

先看一个最简单的例子：

defadd(*args):    print(args)

调用：

add(1, 2, 3)

输出：

(1, 2, 3)

你会发现一个很关键的现象：

你明明传进去的是三个独立的值， 可函数内部收到的 args，却变成了一个元组。

这就是 *args 的核心机制：

它会把传进来的多个位置参数，自动打包成一个元组

再比如：

add(10, 20)

输出：

(10, 20)

再比如：

add(5, 6, 7, 8, 9)

输出：

(5, 6, 7, 8, 9)

也就是说：

你传多少个位置参数进去，*args 就帮你收多少个， 并统一打包成元组。

这就是 *args 最本质的功能。

四、为什么是元组，不是列表

这个问题你可以先简单理解。

因为传进来的这些位置参数，本质上更像一组已经收好的值。 函数只是负责接收，不一定要改它们。 所以 Python 这里用元组来装，更符合这种“收集一组参数”的感觉。

你现在不用深究得太底层。 入门阶段最重要的是记住这个现象：

*args 收到的内容，在函数内部会是一个元组

所以以后你在函数里用 args 时，就可以像操作元组一样去处理它。

比如：

defshow_args(*args):    print(type(args))    print(args)

调用：

show_args('张三', '李四', '王五')

输出：

<class 'tuple'>('张三', '李四', '王五')

这一步一定要自己敲一遍。 因为很多人对 *args 的模糊感，恰恰就来自没真正看到它收进来后到底变成了什么。

五、*args 最适合什么场景

最典型的，就是你根本不确定会传几个位置参数。

比如写一个求和函数：

defadd(*args):    total = 0for num in args:        total += numreturn total

调用：

print(add(1, 2))print(add(1, 2, 3))print(add(1, 2, 3, 4, 5))

输出：

3615

你会发现，这个函数一下就很灵活了。

传两个，能算。 传三个，能算。 传五个，也能算。

而如果不用 *args，你就得提前把参数个数写死。 那这个函数根本不可能这么自然地应对变化。

所以 *args 特别适合：

参数个数不固定 这些参数通常是同一类数据 函数内部会批量处理它们

比如：

很多数字求和 很多姓名打印 很多标签拼接 很多成绩计算平均值

这些都很适合。

六、为什么名字叫 args

其实 args 只是一个习惯写法。

它来自 argument 这个词的复数感觉。 但你完全可以写成别的名字，比如：

defadd(*nums):    print(nums)

这也是合法的。

调用：

add(1, 2, 3)

输出：

(1, 2, 3)

也就是说，真正起作用的是前面的星号 *， 不是 args 这几个字母本身。

不过，虽然名字可以改， 实际开发里大家还是非常习惯写成 *args。

原因很简单：

一看就知道你在写可变位置参数 别人也容易读懂

所以你现在可以先记住：

名字不是必须叫 args但最好沿用这个约定

这会让代码更有共识感。

七、*args 为什么前面一定要有星号

因为那个星号才是在告诉 Python：

后面这个参数，不是普通参数 它是用来收集多个位置参数的

比如：

defshow(a):    print(a)

这里的 a 就只是普通参数，只能收一个值。

而：

defshow(*a):    print(a)

这里的 a，就变成了可变位置参数。 可以收多个值，并打包成元组。

所以你一定要记住：

真正让它变特殊的，不是名字 而是前面的那个 *

没有星号，它就是普通参数。 有了星号，它才变成可变位置参数。

八、*args 在函数内部怎么用

因为它本质上是一个元组， 所以你可以像处理元组那样处理它。

比如遍历：

defprint_names(*args):for name in args:        print(name)

调用：

print_names('张三', '李四', '王五')

输出：

张三李四王五

再比如统计个数：

defcount_args(*args):return len(args)

调用：

print(count_args(1, 2, 3))print(count_args('a', 'b'))

输出：

32

再比如取第一个元素：

deffirst_arg(*args):    print(args[0])

调用：

first_arg('Python', 'Java', 'Go')

输出：

Python

你会发现，*args 真正难的不是使用， 而是第一次理解它为什么会把很多值打包成元组。

一旦这个点想通，后面其实非常顺。

**九、再来看 kwargs：它又是在解决什么问题

前面的 *args，解决的是：

位置参数数量不固定

而 **kwargs 更适合处理另一类场景：

关键字参数数量不固定

比如你想写一个函数，打印用户资料。

有时候只传：

姓名 年龄

有时候再传：

城市 邮箱 手机号

甚至有时候再多传几个别的字段。

如果你提前把所有参数都写死，会很麻烦。 因为未来到底会出现哪些字段，你可能根本不确定。

这时候，**kwargs 就特别适合。

先看最简单的例子：

defshow_info(**kwargs):    print(kwargs)

调用：

show_info(name='张三', age=18, city='北京')

输出：

{'name': '张三', 'age': 18, 'city': '北京'}

你会发现，和 *args 很像。 只不过这次函数内部收到的，不是元组，而是字典。

这就是 **kwargs 的核心机制：

它会把传进来的多个关键字参数，自动打包成一个字典

**十、为什么 kwargs 收到的是字典

因为关键字参数本来就是：

参数名=值

比如：

name='张三'age=18city='北京'

这本来就非常适合组成键值对结构。 所以 Python 干脆把它们都收进一个字典里。

也就是说：

键，就是参数名 值，就是你传进去的具体内容

比如：

defshow_info(**kwargs):    print(type(kwargs))    print(kwargs)

调用：

show_info(name='李四', age=20)

输出：

<class 'dict'>{'name':'李四', 'age': 20}

这一点一定也要自己敲一遍。 因为它会帮你把 **kwargs 的模糊感一下打散。

它不是玄学。 它就是：

很多关键字参数 自动装进一个字典里

十一、为什么名字叫 kwargs

和 args 一样，kwargs 也只是一个非常常见的习惯写法。

它大概可以理解成 keyword arguments 的缩写感觉。 但名字本身并不是强制的。

你完全可以写成：

defshow_info(**data):    print(data)

调用：

show_info(name='张三', age=18)

输出：

{'name': '张三', 'age': 18}

也一样成立。

不过，和 *args 一样， 实际开发里大家几乎都默认喜欢写 **kwargs。

因为你一看就知道它是在收关键字参数。 这会让代码更有共识感。

所以当前阶段最稳的习惯就是：

可变位置参数，优先写 *args可变关键字参数，优先写 **kwargs

十二、kwargs 在函数里怎么用**

因为它本质上是一个字典， 所以你就按字典的方式去处理它。

比如遍历：

defshow_info(**kwargs):for key, value in kwargs.items():        print(key, value)

调用：

show_info(name='张三', age=18, city='北京')

输出：

name 张三age 18city 北京

再比如判断某个字段在不在：

defcheck_info(**kwargs):if'name'in kwargs:        print('有姓名字段')

调用：

check_info(name='李四', age=20)

输出：

有姓名字段

再比如取某个值：

defshow_name(**kwargs):    print(kwargs.get('name'))

调用：

show_name(name='王五', city='上海')

输出：

王五

这时候你会发现，**kwargs 真的是非常适合处理那种 字段不固定、但又想打包收进来 的场景。

**十三、*args 和 kwargs 到底怎么区分

这应该是这一章最核心的问题之一。

你可以先记一个特别直白的版本：

*args 收的是很多位置参数**kwargs 收的是很多关键字参数

看这段：

defdemo(*args, **kwargs):    print(args)    print(kwargs)

调用：

demo(1, 2, 3, name='张三', age=18)

输出：

(1, 2, 3){'name': '张三', 'age': 18}

你看得非常清楚：

前面那些没有写参数名、纯按位置传的，都进了 args后面那些写了 参数名=值 的，都进了 kwargs

所以以后你一旦分不清，只要问自己：

它是按位置传进来的 还是按名字传进来的

答案立刻就出来了。

十四、为什么一个星号，一个双星号

这个问题很多人都会问。

你现在不用死记底层原理。 先记最实用的理解方式：

一个星号，对应一组位置参数 因为它们最终收成一个元组

两个星号，对应一组关键字参数 因为它们最终收成一个字典，带键和值

你可以把它理解成：

单星号更偏一列值 双星号更偏键值对集合

从结果形态上去理解，通常最容易记住。

所以：

*args → 元组**kwargs → 字典

这条线记稳了，基本就不会大乱。

十五、函数里可以同时写普通参数、默认参数、*args、kwargs 吗**

可以。 而且这恰恰是它们真正开始组合起来的时候。

比如：

defdemo(a, b=10, *args, **kwargs):    print('a =', a)    print('b =', b)    print('args =', args)    print('kwargs =', kwargs)

调用：

demo(1, 2, 3, 4, name='张三', age=18)

输出大概是：

a = 1b = 2args = (3, 4)kwargs = {'name': '张三', 'age': 18}

这里你会看到很有意思的一点：

第一个位置参数给了 a第二个位置参数给了 b剩下多出来的位置参数，进了 args关键字参数，进了 kwargs

这就是参数体系真正完整的样子。

所以前面几章你学的位置参数、默认参数、关键字参数，其实并没有被 *args 和 **kwargs 替代。 它们是在同一个体系里逐步展开的。

十六、参数顺序为什么不能乱

如果你同时写多种参数形式，顺序一般要比较规整。

当前阶段你先记最常见、最实用的顺序就够了：

普通位置参数 默认参数*args**kwargs

比如：

defdemo(a, b=10, *args, **kwargs):    ...

这种顺序就很自然。

为什么要这么排？

因为函数接收参数时，本来就有一个从明确到灵活、从固定到开放的过程。

先把最明确、最核心的参数收掉。 再把有默认值的收掉。 剩下多出来的位置参数，统统交给 args。 最后那些按名字传进来的零散字段，再交给 kwargs。

你把它理解成收纳顺序，就很好记。

十七、*args 什么时候特别值得用

当你处理的是一组数量不固定、而且通常是同类的输入时，*args 特别顺手。

比如：

求很多数字的和

defadd(*args):    total = 0for num in args:        total += numreturn total

打印很多名字

defprint_names(*args):for name in args:        print(name)

拼接很多标签

defjoin_tags(*args):return'-'.join(args)

这类场景有个共同点：

输入通常是一串同类值 顺序往往有意义 不需要参数名，只需要一组内容

这时候，*args 就非常合适。

十八、kwargs 什么时候特别值得用**

当你处理的是一组字段不固定、而且更像配置信息或对象属性的输入时，**kwargs 很适合。

比如打印用户资料：

defshow_user(**kwargs):for key, value in kwargs.items():        print(key, value)

生成配置信息：

defshow_config(**kwargs):    print(kwargs)

接收一堆可选字段：

defcreate_profile(**kwargs):return kwargs

这类场景的共同点是：

字段不一定固定 字段名本身很重要 更适合键值对表达 调用时希望一眼看清谁对谁

这就是 **kwargs 特别擅长的地方。

十九、一个特别像实战的小例子：打印学生资料

比如：

defshow_student(name, age, *args, **kwargs):    print(f'姓名：{name}')    print(f'年龄：{age}')    print(f'其他位置参数：{args}')    print(f'其他关键字参数：{kwargs}')

调用：

show_student('张三', 18, '高一', '一班', city='北京', score=95)

输出大概是：

姓名：张三年龄：18其他位置参数：('高一', '一班')其他关键字参数：{'city': '北京', 'score': 95}

这个例子特别适合理解它们的边界。

核心信息，用普通参数接。 多出来的一些零散位置内容，用 args 收。 更像字段属性的扩展信息，用 kwargs 收。

你会发现，这样的函数一下就很灵活了。 它既有明确骨架，又保留了扩展空间。

二十、一个特别像工具函数的小例子：拼接消息

比如我们写一个消息函数：

defbuild_message(title, *args, **kwargs):    print('标题：', title)    print('内容片段：', args)    print('附加信息：', kwargs)

调用：

build_message('系统通知', '今天停电', '请提前保存文件', level='high', sender='管理员')

输出：

标题： 系统通知内容片段： ('今天停电', '请提前保存文件')附加信息： {'level': 'high', 'sender': '管理员'}

你会发现，*args 和 **kwargs 其实特别适合这种“主干明确，扩展弹性大”的函数。

这也是它们在真实项目里经常出现的原因。

二十一、最容易犯的几个错

这一章的坑也不少。

第一个错，是以为 args 和 kwargs 这两个名字有魔法。 其实真正起作用的是星号，不是名字本身。

第二个错，是分不清 *args 收元组，**kwargs 收字典。 这个一定要反复记。

第三个错，是传参方式和接收方式不匹配。 比如 *args 是收位置参数的，你却总想着往里传 name='张三' 这种关键字形式。

第四个错，是把所有函数都滥用成 *args、**kwargs。 这也是很多初学者容易走偏的地方。

能明确写清楚参数时，就别为了显得灵活而全塞进可变参数。 函数不是越花越高级，清楚才最重要。

第五个错，是一看到星号就紧张。 其实你只要记住：

单星号收一串位置值 双星号收一组键值对

很多迷糊感就会立刻下降。

**二十二、为什么不是所有函数都该用 *args 和 kwargs

这个点一定要说透。

有些同学学到这里会觉得：

哇，那以后我是不是都可以不写普通参数了，直接全用 *args 和 **kwargs 不就行了

理论上有些场景当然也能跑。 但这往往会让函数变得非常难读。

比如：

defadd(*args):    ...

这很合理，因为本来就是任意多个数字求和。

但如果你明明知道函数就是要收 姓名、年龄、城市， 却还非要写成：

defshow_info(*args):    ...

那阅读体验就很差。

别人看到函数定义时，根本不知道你期待什么输入。 还得进函数内部猜第一个参数代表什么、第二个参数代表什么。

所以一个特别实用的原则是：

能明确写清楚的参数，就尽量明确写 只有真的不确定数量或字段时，再考虑 *args 和 **kwargs

这才是更稳的函数设计思路。

二十三、这一章最该建立的，不是语法记忆，而是使用边界感

你现在最重要的，不是背下所有星号写法。 而是慢慢形成一种边界感。

这个函数核心输入明确吗 如果明确，就优先普通参数

这个函数的某个参数大多数时候固定吗 那就考虑默认参数

这个函数接收的是一串数量不固定的位置值吗 那就考虑 *args

这个函数接收的是字段不固定的关键字信息吗 那就考虑 **kwargs

这才是这一章真正重要的地方。

因为以后你写函数时，真正难的从来不是语法， 而是怎么把参数设计得既清楚，又灵活。

二十四、练习题：这一章一定要手敲

下面这些练习非常建议你自己写。

1. 定义一个函数，接收任意多个数字，返回它们的和

defadd(*args):    total = 0for num in args:        total += numreturn totalprint(add(1, 2))print(add(1, 2, 3, 4))

2. 定义一个函数，接收任意多个名字，并逐个打印

defprint_names(*args):for name in args:        print(name)print_names('张三', '李四', '王五')

3. 定义一个函数，接收任意多个关键字参数，并打印字典

defshow_info(**kwargs):    print(kwargs)show_info(name='张三', age=18, city='北京')

4. 遍历 **kwargs，把每个键和值打印出来

defshow_info(**kwargs):for key, value in kwargs.items():        print(key, value)show_info(name='李四', age=20, city='上海')

5. 定义一个函数，同时接收普通参数、*args、**kwargs

defdemo(a, *args, **kwargs):    print('a =', a)    print('args =', args)    print('kwargs =', kwargs)demo(1, 2, 3, name='张三', age=18)

你把这几题敲顺，*args 和 **kwargs 这两个看起来很唬人的东西，马上就会顺很多。

二十五、本章小结

这一章最重要的，不是两个星号本身，而是它们背后的用途。

*args 用来接收任意多个位置参数，函数内部会把它们收成元组。**kwargs 用来接收任意多个关键字参数，函数内部会把它们收成字典。

你要记住几句最实用的话：

单星号收位置参数 双星号收关键字参数*args 像一串值**kwargs 像一组键值对 能明确写清楚的参数，尽量别滥用可变参数 只有在数量或字段真的不固定时，再考虑用它们

学会这一章以后，你对函数参数的理解就又往前走了一大步。 因为你已经不再只能处理那种参数个数固定、结构非常死板的函数了。

下一章我们继续讲 函数的作用域：局部变量和全局变量别再混了。 到那一章，你会发现，函数一旦开始真的写起来，很快就会碰到另一个经典大坑：

同样一个变量名，为什么有时候能用，有时候又突然不认。