前面一章，我们已经把函数参数里最基础、也最常用的三件事讲清楚了：
位置参数 默认参数 关键字参数
学到这里，很多同学会觉得参数好像已经差不多了。 平时定义个函数，括号里写几个参数，调用时把值传进去，也基本能用了。
但你很快就会遇到一种特别真实的场景：
有时候，你根本不确定以后会传几个参数。
比如：
我想写一个函数，专门把任意多个数字加起来 我想写一个函数，专门打印很多名字 我想写一个函数，接收一堆配置信息，但每次传进来的字段都可能不完全一样 我想让函数更灵活一点，不要每次都把参数个数写死
这时候，如果你还只能靠普通参数去硬写，就会非常别扭。
比如你写：
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 像一组键值对 能明确写清楚的参数，尽量别滥用可变参数 只有在数量或字段真的不固定时，再考虑用它们
学会这一章以后，你对函数参数的理解就又往前走了一大步。 因为你已经不再只能处理那种参数个数固定、结构非常死板的函数了。
下一章我们继续讲 函数的作用域：局部变量和全局变量别再混了。 到那一章，你会发现，函数一旦开始真的写起来，很快就会碰到另一个经典大坑：
同样一个变量名，为什么有时候能用，有时候又突然不认。
10个月宝宝每天需要喝多少奶粉？