<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="description" content="深入讲解参数类型位置参数默认参数可变参数关键字参数的核心内容与关键技术，属于Python编程基础的函数与模块方向">
<title>参数类型：位置参数、默认参数、可变参数、关键字参数 函数与模块 Python编程基础-AI全栈-AIQZ.CC</title>
<link rel="icon" type="image/svg+xml" href="/favicon.svg">
<link rel="stylesheet" href="/css/chapter.css?v=20260612e">
<link rel="stylesheet" href="/vendor/katex/katex.min.css">
<script src="/vendor/katex/katex.min.js"></script>
<script src="/vendor/katex/auto-render.min.js"></script>
</head>
<body>
<div class="app-container">
  <aside class="left-sidebar" id="leftSidebar">
    <div class="sidebar-content">
      <nav class="nav-section">
        <div class="nav-header">课程目录</div>
        <!--#include virtual="/ssi/nav/course-nav.html" -->
      </nav>
    </div>
  </aside>
  <main class="main-content">
    <article class="content-area">
      <h1>参数类型：位置参数、默认参数、可变参数、关键字参数</h1><div class="divider"></div>

<h2>一句话概述</h2>
<p>Python 函数的参数系统极其灵活——你可以按<strong>位置</strong>一个个传参，也可以给参数设<strong>默认值</strong>省去重复输入，还可以用 <code>*args</code> 接收<strong>任意数量</strong>的位置参数、用 <code>**kwargs</code> 接收<strong>任意数量</strong>的关键字参数。这套参数体系就像点菜系统：位置参数是&quot;必须点的菜&quot;（不点就饿着），默认参数是&quot;套餐里的标配&quot;（你可以换、也可以不换），<code>*args</code> 是&quot;加菜&quot;（任意加多少个都行），<code>**kwargs</code> 是&quot;备注&quot;（少辣、多加葱、不要香菜）。掌握这四种参数类型，你就能写出既简洁又强大的函数接口——这在 AI 框架的 API 设计中随处可见。</p>
<blockquote class="highlight-box"><strong>💡 核心要点：</strong>①位置参数按声明顺序对应传值，调用时必须提供且顺序要正确 ②默认参数在定义时用 <code>=</code> 赋默认值，调用时可省略，必须放在位置参数后面 ③<code>*args</code> 接收任意多个位置参数，打包成元组，用星号语法解包 ④<code>**kwargs</code> 接收任意多个关键字参数，打包成字典，用双星号语法解包 ⑤参数顺序固定：位置参数 → <code>*args</code> → 关键字参数 → <code>**kwargs</code></blockquote>


<h2>教学与演示</h2>
<h3>一、位置参数——按座次入座</h3>
<p><strong>是什么</strong>：位置参数（Positional Argument）是最基本、最常用的参数类型。定义时在括号里写变量名，调用时按<strong>顺序</strong>传入对应的值——第一个实参给第一个形参，第二个实参给第二个形参，一一对应，分毫不差。位置参数就像电影院的对号入座——1 号票坐 1 号位，2 号票坐 2 号位，不能乱坐。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 位置参数就像排队买票——你站第一个，你就是第一个买；你站第二个，你就是第二个买。调用 <code>greet(&quot;张三&quot;, 25)</code> ——&quot;张三&quot;自动给第一个参数 <code>name</code>，25 自动给第二个参数 <code>age</code>。Python 不会因为你把&quot;张三&quot;给了 <code>age</code> 就报类型错——它只看位置，不看内容。</blockquote>


<p><strong>为什么</strong>：位置参数是最直观的传参方式——定义和调用的逻辑完全一致，读代码时从上到下、从左到右就能理解。大多数简单函数只有 1-2 个参数时，位置参数足够了。它的缺点是参数多了容易混淆顺序——<code>draw_rect(x1, y1, x2, y2, color, width)</code> 调用到第 5 个参数时已经记不清谁是谁了，这就是为什么需要关键字参数（见第四节）。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 两三个参数用位置参数很舒服。五个以上？你大概率会把 <code>username</code> 和 <code>password</code> 的位置搞反——然后 debug 一小时。这就是为什么复杂函数要用关键字参数或默认参数来&quot;防呆&quot;。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-1"><code class="language-python">import numpy as np

# ====== 1. 位置参数的基本用法 ======

def describe_person(name, age, city):
    &quot;&quot;&quot;三个位置参数：name、age、city&quot;&quot;&quot;
    print(f&quot;{name} 今年 {age} 岁，来自 {city}。&quot;)

# 按位置一一对应传参
describe_person(&quot;张三&quot;, 25, &quot;北京&quot;)           # 张三→name, 25→age, &quot;北京&quot;→city
describe_person(&quot;李四&quot;, 30, &quot;上海&quot;)           # 顺序绝对不能乱！

# ====== 2. 位置参数必须完整提供 ======

# 少传参数会报错
try:
    describe_person(&quot;王五&quot;)                   # 只传了 1 个，缺少 age 和 city
except TypeError as e:
    print(f&quot;错误: {e}&quot;)                       # missing 2 required positional arguments

# ====== 3. AI 场景：计算两个向量的欧几里得距离 ======

def euclidean_distance(v1, v2):
    &quot;&quot;&quot;计算两个等长向量的欧几里得距离（L2 范数）&quot;&quot;&quot;
    # v1 和 v2 是位置参数，调用时必须按顺序传入
    if len(v1) != len(v2):
        return None                            # 长度不同无法计算
    sum_sq = sum((a - b) ** 2 for a, b in zip(v1, v2))
    return sum_sq ** 0.5                      # 开平方根

# 模拟：两个词向量（word embeddings 简化版）
word_vec_猫 = [0.5, 0.8, 0.1, 0.3]           # &quot;猫&quot; 的 4 维向量
word_vec_狗 = [0.6, 0.7, 0.2, 0.4]           # &quot;狗&quot; 的 4 维向量
word_vec_鸟 = [0.1, 0.2, 0.9, 0.7]           # &quot;鸟&quot; 的 4 维向量

dist_cat_dog = euclidean_distance(word_vec_猫, word_vec_狗)
dist_cat_bird = euclidean_distance(word_vec_猫, word_vec_鸟)
dist_dog_bird = euclidean_distance(word_vec_狗, word_vec_鸟)

print(f&quot;\n猫与狗的距离: {dist_cat_dog:.3f}&quot;)   # 语义相近，距离应该小
print(f&quot;猫与鸟的距离: {dist_cat_bird:.3f}&quot;)   # 语义相差大，距离应该大
print(f&quot;狗与鸟的距离: {dist_dog_bird:.3f}&quot;)   # 语义相差大，距离应该大&quot;)

# 在 AI 中，向量距离用于语义相似度计算、KNN 分类、聚类等

# ====== 4. 位置参数调换顺序的陷阱 ======

def divide(a, b):
    &quot;&quot;&quot;a ÷ b&quot;&quot;&quot;
    return a / b

print(f&quot;\n10 ÷ 2 = {divide(10, 2)}&quot;)          # 5.0 — 正确
print(f&quot;2 ÷ 10 = {divide(2, 10)}&quot;)            # 0.2 — 顺序错了，结果完全不同！
# 这就是为什么复杂函数需要关键字参数</code></pre><p><strong>什么用</strong>：在 AI 中，位置参数广泛用于简单函数。激活函数 <code>relu(x)</code> 只有一个参数，用位置参数最自然。大多数数学函数（<code>sqrt(x)</code>、<code>log(x)</code>、<code>exp(x)</code>）也是单参数。当函数有 2-3 个语义明确的参数时，位置参数依然清晰——<code>loss_fn(predictions, targets)</code> 一看就知道含义。不过 AI 框架的设计者非常清楚：参数多了位置参数就是地雷，所以 PyTorch 的 <code>nn.Conv2d(in_channels, out_channels, kernel_size, ...)</code> 用到了大量默认参数和关键字参数。</p>
<h3>二、默认参数——自带备选方案</h3>
<p><strong>是什么</strong>：默认参数（Default Parameter）在定义时用 <code>=</code> 给参数赋一个默认值。调用函数时，如果给这个参数传了值就用传的值，没传就用默认值。默认参数必须放在所有位置参数的<strong>后面</strong>——Python 规定&quot;有默认值的参数必须在没有默认值的参数之后&quot;，这是铁律。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 默认参数就像饭店的套餐——套餐里的米饭是默认配置（<code>rice=True</code>）。你啥也不说，端上来的就是米饭。但你可以说&quot;米饭换成馒头&quot;（<code>rice=False</code>），饭店就给你换。默认参数让你既能享受&quot;不说的便利&quot;（大多数场景），又能保留&quot;说的自由&quot;（特殊情况）。</blockquote>


<p><strong>为什么</strong>：默认参数解决了两大痛点。①<strong>简化常见调用</strong>：一个函数 10 个参数，但 90% 的情况下只有 2 个需要用户指定，其他用默认值就行了。②<strong>向后兼容</strong>：给函数加新参数时，如果给它设默认值，旧的调用代码不会报错。AI 框架中几乎每个复杂函数都有默认参数——<code>Adam(lr=0.001, betas=(0.9, 0.999))</code> 大部分人只改 lr，其他用默认。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 想象你要配置一台新电脑。如果没有默认参数，你得指定所有部件：CPU 型号、内存大小、硬盘容量、显卡型号、电源功率……累死你。有了默认参数，你只需要说&quot;我要 16G 内存&quot;，其他都用默认配置——电脑店自动选最主流的 CPU、512G 硬盘、集显。这就是默认参数在 AI 框架中的角色。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-2"><code class="language-python">import numpy as np

# ====== 1. 默认参数的基本用法 ======

def greet(name, greeting=&quot;你好&quot;):
    &quot;&quot;&quot;greeting 有默认值 '你好'&quot;&quot;&quot;
    print(f&quot;{greeting}，{name}！&quot;)

# 不传 greeting——用默认值
greet(&quot;张三&quot;)                                  # 你好，张三！

# 传了 greeting——覆盖默认值
greet(&quot;李四&quot;, &quot;早上好&quot;)                        # 早上好，李四！
greet(&quot;外国人&quot;, &quot;Hello&quot;)                       # Hello，外国人！

# ====== 2. 默认参数必须放在末尾——铁律！ ======

# ✅ 正确：默认参数在位置参数之后
def power(base, exponent=2):
    &quot;&quot;&quot;计算 base 的 exponent 次方，默认平方&quot;&quot;&quot;
    return base ** exponent

# ❌ 错误：默认参数不能放在位置参数之前
# def wrong(option=True, name):  ← SyntaxError! 默认参数必须在后面

print(f&quot;\n5² = {power(5)}&quot;)                    # 25 — 默认平方
print(f&quot;5³ = {power(5, 3)}&quot;)                   # 125 — 覆盖默认值
print(f&quot;5¹ = {power(5, 1)}&quot;)                   # 5

# ====== 3. 多个默认参数的组合 ======

def configure_training(
    epochs=100,                                # 默认训练 100 轮
    batch_size=32,                             # 默认批大小 32
    learning_rate=0.001,                       # 默认学习率 0.001
    optimizer=&quot;adam&quot;,                          # 默认优化器 Adam
    early_stop=True,                           # 默认开启早停
    verbose=True                               # 默认打印日志
):
    &quot;&quot;&quot;配置模型训练参数——大量默认值省去重复输入&quot;&quot;&quot;
    config = {
        &quot;epochs&quot;: epochs,
        &quot;batch_size&quot;: batch_size,
        &quot;lr&quot;: learning_rate,
        &quot;optimizer&quot;: optimizer,
        &quot;early_stop&quot;: early_stop,
        &quot;verbose&quot;: verbose
    }
    return config

# 使用默认配置（最常见）
config1 = configure_training()
print(f&quot;\n默认配置: {config1}&quot;)

# 只改学习率，其他用默认
config2 = configure_training(learning_rate=0.0001, epochs=200)
print(f&quot;自定义配置: {config2}&quot;)

# ====== 4. 默认参数的&quot;陷阱&quot;：可变默认值 ======

# ⚠️ 陷阱！千万不要用可变对象（列表、字典）做默认参数！
def bad_append(item, target_list=[]):          # ❌ 默认值是空列表！
    &quot;&quot;&quot;这是有 bug 的写法！默认值列表只会创建一次&quot;&quot;&quot;
    target_list.append(item)
    return target_list

print(&quot;\n=== 默认参数陷阱 ===&quot;)
print(bad_append(1))                           # [1] — 第一次正常
print(bad_append(2))                           # [1, 2] — 咦？怎么还有 1？！
print(bad_append(3))                           # [1, 2, 3] — 默认列表在&quot;累积&quot;！

# 为什么？因为默认值 [] 只在函数定义时创建一次，后续调用共享同一个列表对象

# ✅ 正确做法：默认值用 None，函数内检查
def good_append(item, target_list=None):
    &quot;&quot;&quot;正确的写法：None + 函数内部初始化&quot;&quot;&quot;
    if target_list is None:                    # 如果没传列表
        target_list = []                       # 创建新列表
    target_list.append(item)
    return target_list

print(&quot;\n=== 正确的写法 ===&quot;)
print(good_append(1))                          # [1]
print(good_append(2))                          # [2] — 正常！每次都是新列表
print(good_append(3))                          # [3]

# ====== 5. AI 场景：自定义数据增强函数 ======

def augment_image(
    img,                                       # 必须的参数：输入图像（numpy 数组）
    rotation=0.0,                              # 默认不旋转
    flip_horizontal=False,                     # 默认不水平翻转
    brightness=1.0,                            # 默认不调亮度
    noise_std=0.0                              # 默认不加噪
):
    &quot;&quot;&quot;数据增强函数——只为需要的增强方式传参&quot;&quot;&quot;
    # 用 numpy 模拟图像增强效果
    result = np.array(img, dtype=float)

    if rotation != 0:
        # 模拟旋转：对于简化的情况，乘以旋转因子
        result = result * (1 + rotation * 0.01)
    if flip_horizontal:
        result = result[::-1]                  # 水平翻转 = 反转数组
    if brightness != 1.0:
        result = result * brightness           # 调整亮度 = 乘因子
    if noise_std &gt; 0:
        noise = np.random.normal(0, noise_std, result.shape)
        result = result + noise                # 添加高斯噪声

    return result

# 模拟一个 5 像素的&quot;图像&quot;
image = np.array([10, 20, 30, 40, 50])

original = augment_image(image)               # 不增强——原样输出
flipped = augment_image(image, flip_horizontal=True)  # 只水平翻转
bright = augment_image(image, brightness=1.5)         # 只调亮
noisy = augment_image(image, noise_std=2.0, flip_horizontal=True)  # 加噪+翻转

print(f&quot;\n原始: {original}&quot;)
print(f&quot;翻转: {flipped}&quot;)
print(f&quot;调亮: {bright}&quot;)
print(f&quot;加噪+翻转: {[round(x, 1) for x in noisy]}&quot;)</code></pre><p><strong>什么用</strong>：默认参数在 AI 框架设计中是标配。<code>nn.Conv2d</code> 有十几个参数，但 <code>in_channels</code>、<code>out_channels</code>、<code>kernel_size</code> 这三个是位置参数（必须提供），其他如 <code>stride=1</code>、<code>padding=0</code>、<code>dilation=1</code> 全是默认参数——初学者不需要理解每个参数就能跑起来。这种&quot;渐进式学习曲线&quot;完全依赖默认参数机制。你自己写训练脚本时，用默认参数封装配置，既简洁又专业。</p>
<h3>三、可变参数 *args——来多少接多少</h3>
<p><strong>是什么</strong>：<code>*args</code>（Arbitrary Positional Arguments）让函数可以接收<strong>任意数量</strong>的位置参数。在函数内部，<code>args</code> 是一个<strong>元组（tuple）</strong>，包含了所有被传进来的额外位置参数。星号 <code>*</code> 是&quot;打包&quot;操作符——把零散的多个参数打包成一个元组。</p>
<blockquote class="plain-explain"><strong>大白话</strong> <code>*args</code> 就像食堂的&quot;随到随吃&quot;窗口——不管你来 3 个人、5 个人还是 20 个人，窗口都能接待。<code>sum(1, 2, 3, 4, 5)</code> 为什么能传任意多个参数？因为 <code>sum</code> 的定义就是 <code>sum(*args)</code>——它不管你传几个数，全打包成一个元组，然后在函数里遍历求和。<code>*args</code> 让函数从&quot;固定模式&quot;变成&quot;弹性模式&quot;。</blockquote>


<p><strong>为什么</strong>：有些场景下你无法提前知道会传多少个参数——比如 <code>print()</code> 可以接任意多个值，<code>max()</code> 可以接任意多个数。<code>*args</code> 让函数接口极其灵活。在 AI 中，当你需要处理不定长的数据（如变长序列、不同数量特征），<code>*args</code> 让代码保持简洁。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 没有 <code>*args</code> 的世界：你想写一个求平均值的函数，但不知道用户会传 2 个数还是 100 个数。你只能让用户传一个列表——<code>avg([1,2,3])</code>。有了 <code>*args</code>，你可以直接 <code>avg(1,2,3)</code>——干净利落。注意 <code>*args</code> 只是一个命名惯例，<code>*</code> 才是关键——<code>*numbers</code>、<code>*items</code> 完全合法。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-3"><code class="language-python">import numpy as np

# ====== 1. *args 的基本用法 ======

def collect_numbers(*args):
    &quot;&quot;&quot;接收任意数量的位置参数&quot;&quot;&quot;
    print(f&quot;收到了 {len(args)} 个参数&quot;)
    print(f&quot;args 的类型: {type(args)}&quot;)        # &lt;class 'tuple'&gt;
    print(f&quot;args 的内容: {args}&quot;)
    print(f&quot;args 的和: {sum(args)}&quot;)

collect_numbers(1, 2, 3)                       # 3 个参数
print(&quot;---&quot;)
collect_numbers(10, 20, 30, 40, 50)            # 5 个参数

# ====== 2. *args 与普通参数混用 ======

def my_max(first, *rest):
    &quot;&quot;&quot;自定义 max：第一个参数单独拿，其余放 *args&quot;&quot;&quot;
    # first 是必须的，rest 是可选的（可以 0 个）
    max_val = first
    for num in rest:                           # 遍历 rest 元组
        if num &gt; max_val:
            max_val = num
    return max_val

print(f&quot;\nmy_max(5, 2, 8, 1) = {my_max(5, 2, 8, 1)}&quot;)  # 8
print(f&quot;my_max(3) = {my_max(3)}&quot;)              # 3 — rest 是空元组

# ====== 3. 解包：用 * 把列表/元组拆成位置参数 ======

# * 有双重身份：定义时是&quot;打包&quot;，调用时是&quot;解包&quot;
def multiply(a, b, c):
    &quot;&quot;&quot;计算三个数的乘积&quot;&quot;&quot;
    return a * b * c

nums = [2, 3, 4]                               # 一个列表
# multiply(nums) ❌ 报错——nums 是一个参数（列表），但函数需要 3 个参数
result = multiply(*nums)                       # *nums 把列表解包成 2, 3, 4 三个独立参数
print(f&quot;\nmultiply(*[2,3,4]) = {result}&quot;)      # 24

# 解包在 AI 中常用：把超参数列表传给函数
hyperparams = [128, 64, 0.01]                  # [hidden_size, batch_size, lr]
# 传给训练函数: train(*hyperparams)  ← 一行解包，不用写三个变量

# ====== 4. *args 用于构建灵活的汇总函数 ======

def aggregate(operation, *values):
    &quot;&quot;&quot;灵活的数据聚合函数——operation 指定运算，*values 接收数据&quot;&quot;&quot;
    if not values:
        return None
    if operation == &quot;sum&quot;:
        return sum(values)
    elif operation == &quot;mean&quot;:
        return sum(values) / len(values)
    elif operation == &quot;product&quot;:
        result = 1
        for v in values:
            result *= v
        return result
    elif operation == &quot;min&quot;:
        return min(values)
    elif operation == &quot;max&quot;:
        return max(values)
    else:
        return f&quot;未知操作: {operation}&quot;

scores = [85, 92, 78, 95, 88]
print(f&quot;\n总和:     {aggregate('sum', *scores)}&quot;)     # 438 — *scores 解包传参
print(f&quot;平均分:   {aggregate('mean', *scores)}&quot;)     # 87.6
print(f&quot;连乘积:   {aggregate('product', 2, 3, 4)}&quot;) # 24
print(f&quot;最小值:   {aggregate('min', *scores)}&quot;)      # 78
print(f&quot;最大值:   {aggregate('max', *scores)}&quot;)      # 95

# ====== 5. AI 场景：构建可拼接的神经网络层 ======

def sequential_layers(*layers):
    &quot;&quot;&quot;模拟 PyTorch 的 nn.Sequential：按顺序叠加层&quot;&quot;&quot;
    print(f&quot;\n构建 Sequential 模型，共 {len(layers)} 层:&quot;)
    for i, layer in enumerate(layers):
        print(f&quot;  第 {i} 层: {layer}&quot;)
    return layers                                # 返回层列表

# 随便加多少层都行——*layers 自动接收
model1 = sequential_layers(&quot;Conv2D(3→64)&quot;, &quot;ReLU&quot;, &quot;MaxPool(2×2)&quot;)
model2 = sequential_layers(
    &quot;Conv2D(3→64)&quot;, &quot;BatchNorm&quot;, &quot;ReLU&quot;,
    &quot;Conv2D(64→128)&quot;, &quot;BatchNorm&quot;, &quot;ReLU&quot;,
    &quot;Flatten&quot;, &quot;Dense(128→10)&quot;, &quot;Softmax&quot;
)

# 模拟：用 *args 拼接特征向量
def concat_features(*feature_vectors):
    &quot;&quot;&quot;拼接多个特征向量（类似 np.concatenate）&quot;&quot;&quot;
    result = []
    for vec in feature_vectors:
        result.extend(vec)                      # 展开每个向量
    return result

feat1 = [0.5, 0.8]                              # 颜色特征
feat2 = [0.1, 0.3, 0.9]                        # 纹理特征
feat3 = [0.7]                                   # 形状特征
combined = concat_features(feat1, feat2, feat3)
print(f&quot;\n拼接特征: {combined}&quot;)                # [0.5, 0.8, 0.1, 0.3, 0.9, 0.7]</code></pre><p><strong>什么用</strong>：<code>*args</code> 在 AI 框架中大量使用。<code>tf.keras.layers.concatenate([a, b, c])</code> 接收任意数量的层进行拼接；<code>torch.cat([tensor1, tensor2, ...])</code> 拼接任意数量的张量；自定义损失函数中 <code>def custom_loss(*outputs)</code> 接收多任务学习的多个输出。数据预处理中，<code>*args</code> 用于接收任意数量的特征列进行合并或交叉。</p>
<h3>四、关键字参数 **kwargs——指名道姓地传参</h3>
<p><strong>是什么</strong>：<code>**kwargs</code>（Keyword Arguments）让函数接收<strong>任意数量的关键字参数</strong>（以 <code>key=value</code> 形式传入）。在函数内部，<code>kwargs</code> 是一个<strong>字典（dict）</strong>，键是参数名（字符串），值是对应的值。双星号 <code>**</code> 是字典的&quot;打包/解包&quot;操作符。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 如果说位置参数是&quot;按座次入座&quot;，那关键字参数就是&quot;按名牌入座&quot;——你不关心座位顺序，直接喊名字就行。<code>**kwargs</code> 更进一步——你可以传任意数量的&quot;名牌+人名&quot;组合，函数全收到一个字典里。这就像订酒店时填&quot;特殊需求&quot;——不限制你能填多少条，每一条都是&quot;需求类型=具体要求&quot;的格式。</blockquote>


<p><strong>为什么</strong>：关键字参数解决了位置参数的三个致命问题：①参数太多记不住顺序；②可读性差（<code>rect(10, 20, 50, 60, &quot;red&quot;, 2)</code> 鬼知道每个数字什么意思）；③部分参数可选时调用很痛苦。<code>**kwargs</code> 让函数可以接收&quot;任意额外的配置&quot;——这在 AI 框架的超参数传递中至关重要。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 调用 <code>train(data, lr=0.01, epochs=200, batch_size=64, optimizer=&quot;adam&quot;)</code> 和 <code>train(data, optimizer=&quot;adam&quot;, batch_size=64, epochs=200, lr=0.01)</code> 是完全等价的——因为每个参数都带名字，顺序不重要。这就是 Python 为&quot;代码可读性&quot;设计的优雅机制。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-4"><code class="language-python">import numpy as np

# ====== 1. **kwargs 的基本用法 ======

def show_details(**kwargs):
    &quot;&quot;&quot;接收任意数量的关键字参数&quot;&quot;&quot;
    print(f&quot;kwargs 类型: {type(kwargs)}&quot;)       # &lt;class 'dict'&gt;
    print(f&quot;kwargs 内容: {kwargs}&quot;)
    for key, value in kwargs.items():
        print(f&quot;  {key} = {value} ({type(value).__name__})&quot;)  # 打印键值对和类型

show_details(name=&quot;张三&quot;, age=25, city=&quot;北京&quot;, is_vip=True)

# ====== 2. 四类参数混合使用（完整形态） ======

def full_demo(pos1, pos2, *args, kw1=&quot;默认&quot;, kw2=&quot;默认&quot;, **kwargs):
    &quot;&quot;&quot;展示四种参数类型的完整组合——这是 Python 函数参数的终极形态&quot;&quot;&quot;
    print(f&quot;位置参数: pos1={pos1}, pos2={pos2}&quot;)
    print(f&quot;可变位置: *args={args}&quot;)
    print(f&quot;默认参数: kw1={kw1}, kw2={kw2}&quot;)
    print(f&quot;可变关键字: **kwargs={kwargs}&quot;)

print(&quot;\n=== 四种参数混合调用 ===&quot;)
full_demo(
    &quot;必传1&quot;, &quot;必传2&quot;,                          # 两个位置参数（必须）
    &quot;额外1&quot;, &quot;额外2&quot;, &quot;额外3&quot;,                 # *args 接收（可选）
    kw1=&quot;覆盖默认1&quot;,                           # 关键字参数（可选）
    extra1=&quot;额外配置A&quot;,                         # **kwargs 接收
    extra2=&quot;额外配置B&quot;,                         # **kwargs 接收
    mode=&quot;fast&quot;                                 # **kwargs 接收
)

# ====== 3. 解包字典：用 ** 把字典拆成关键字参数 ======

def create_user(name, age, role=&quot;user&quot;):
    &quot;&quot;&quot;创建用户——接收关键字参数&quot;&quot;&quot;
    return {
        &quot;name&quot;: name,
        &quot;age&quot;: age,
        &quot;role&quot;: role
    }

# 解包字典传参——字典的键就是参数名，值就是参数值
user_data = {&quot;name&quot;: &quot;张三&quot;, &quot;age&quot;: 25, &quot;role&quot;: &quot;admin&quot;}
user = create_user(**user_data)                # ** 解包字典
print(f&quot;\n解包创建用户: {user}&quot;)

# 这在 AI 中非常常用——从配置文件（dict）加载超参数
def train_model(model, **hyperparams):
    &quot;&quot;&quot;接收任意超参数配置&quot;&quot;&quot;
    print(f&quot;\n训练模型: {model}&quot;)
    print(f&quot;超参数: {hyperparams}&quot;)
    # 实际训练代码...
    return hyperparams

# 从 YAML/JSON 配置文件读取的超参数字典
config = {
    &quot;lr&quot;: 0.001,
    &quot;epochs&quot;: 100,
    &quot;batch_size&quot;: 32,
    &quot;optimizer&quot;: &quot;adam&quot;,
    &quot;weight_decay&quot;: 1e-4
}
train_model(&quot;SimpleCNN&quot;, **config)             # 解包传入所有超参数

# ====== 4. 参数顺序的&quot;铁律&quot; ======

# Python 的参数顺序规则（必须严格遵守）：
# 位置参数 → *args → 只限关键字的默认参数 → **kwargs
# 定义示例：
def correct_order(a, b, *args, c=1, d=2, **kwargs):
    &quot;&quot;&quot;正确的参数顺序示范&quot;&quot;&quot;
    print(f&quot;a={a}, b={b}, args={args}, c={c}, d={d}, kwargs={kwargs}&quot;)

correct_order(1, 2, 3, 4, 5, c=99, e=&quot;extra&quot;)
# a=1, b=2, args=(3, 4, 5), c=99, d=2, kwargs={'e': 'extra'}

# ====== 5. AI 场景：灵活的模型工厂函数 ======

def build_layer(layer_type, **layer_params):
    &quot;&quot;&quot;模拟层构建工厂——用 **kwargs 接收各种层参数&quot;&quot;&quot;
    print(f&quot;\n构建层: {layer_type}&quot;)
    if layer_type == &quot;dense&quot;:
        units = layer_params.get(&quot;units&quot;, 128)
        activation = layer_params.get(&quot;activation&quot;, &quot;relu&quot;)
        return f&quot;Dense(units={units}, activation='{activation}')&quot;
    elif layer_type == &quot;conv2d&quot;:
        filters = layer_params.get(&quot;filters&quot;, 32)
        kernel = layer_params.get(&quot;kernel_size&quot;, 3)
        return f&quot;Conv2D(filters={filters}, kernel={kernel}×{kernel})&quot;
    elif layer_type == &quot;dropout&quot;:
        rate = layer_params.get(&quot;rate&quot;, 0.5)
        return f&quot;Dropout(rate={rate})&quot;
    else:
        return f&quot;未知层类型: {layer_type}&quot;

# 不同的层用不同的参数——**kwargs 都能接收
print(build_layer(&quot;dense&quot;, units=64, activation=&quot;sigmoid&quot;))
print(build_layer(&quot;conv2d&quot;, filters=128, kernel_size=5, padding=&quot;same&quot;))
print(build_layer(&quot;dropout&quot;, rate=0.3))
print(build_layer(&quot;dense&quot;, units=10, activation=&quot;softmax&quot;))</code></pre><p><strong>什么用</strong>：<code>**kwargs</code> 在 AI 框架设计中堪称神器。PyTorch Lightning 的 <code>Trainer(**kwargs)</code> 几乎所有参数都是关键字参数——因为可能有 50+ 个配置项；<code>matplotlib</code> 的 <code>plot(x, y, **kwargs)</code> 让用户指定颜色、线型、标签等任意样式；自定义训练循环中 <code>run_experiment(**config)</code> 从配置文件解包所有超参数。掌握 <code>**kwargs</code> 后，你会发现很多库的 API 设计突然变得清晰了。</p>
<div class="demo-embed" data-demo-src="/demos/parameters-types-demo1.html"><a href="/demos/parameters-types-demo1.html">参数游乐园——玩转 Python 四种参数类型（动画演示）</a></div>


<h2>概念关系图谱</h2>
<div class="table-wrapper"><table class="concept-map-table"><thead><tr><th>概念</th><th>核心含义</th><th>与AI的关系</th><th>关联概念</th></tr></thead><tbody><tr><td>位置参数</td><td>按顺序对应传值</td><td>简单函数的最常用参数形式</td><td>关键字参数、默认参数</td></tr><tr><td>默认参数</td><td>定义时赋默认值，调用时可省略</td><td>框架 API 中大量可选配置项</td><td>位置参数、可变参数</td></tr><tr><td>*args</td><td>接收任意多个位置参数，打包成元组</td><td>变长序列处理、数据拼接</td><td>**kwargs、解包</td></tr><tr><td>**kwargs</td><td>接收任意多个关键字参数，打包成字典</td><td>超参数配置、模型构建工厂</td><td>*args、字典解包</td></tr><tr><td>解包 * / **</td><td>调用时把容器拆成独立参数</td><td>从配置文件注入参数</td><td>打包、序列</td></tr><tr><td>参数顺序</td><td>位置→args→关键字→kwargs</td><td>框架 API 设计规范</td><td>函数签名、PEP 8</td></tr><tr><td>可变默认陷阱</td><td>默认值用可变对象会导致意外共享</td><td>训练指标收集器的初始化</td><td>None、is 判断</td></tr><tr><td>关键字传参</td><td>用 <code>key=value</code> 指名传参</td><td>提升超参可读性，跳过不需要的参数</td><td>位置传参、可读性</td></tr></tbody></table></div>
<h2>重点答疑</h2>
<h3>Q1: <code>*args</code> 和 <code>**kwargs</code> 的变量名 <code>args</code> 和 <code>kwargs</code> 是固定的吗？</h3>
<p><strong>不是！这只是一个约定俗成的命名习惯。</strong> 真正起作用的是星号——一个 <code>*</code> 表示打包位置参数为元组，两个 <code>**</code> 表示打包关键字参数为字典。你可以用任何合法的变量名：<code>*numbers</code>、<code>*items</code>、<code>**options</code>、<code>**config</code> 都是合法的。但社区约定用 <code>args</code> 和 <code>kwargs</code> 有两个好处：①任何人看到 <code>*args</code> 就知道这是可变位置参数；②代码审查和协作时不需要额外解释。除非有更好的理由（比如 <code>*scores</code> 让语义更清晰），否则建议遵守约定。</p>
<h3>Q2: 参数顺序为什么必须严格遵循？能不能把 <code>*args</code> 放在位置参数前面？</h3>
<p><strong>不能，这是 Python 语法的硬性规定。</strong> 想象一下：如果 <code>*args</code> 在前面，<code>def f(*args, a, b)</code>——当你调用 <code>f(1, 2, 3, 4, 5)</code> 时，<code>*args</code> 会把所有 5 个参数都&quot;吃掉&quot;，<code>a</code> 和 <code>b</code> 永远分不到值。所以 Python 强制规定：所有<strong>没有默认值的普通参数</strong>必须排在 <code>*args</code> 前面。完整顺序是：① 普通位置参数 ② <code>*args</code>（如果存在）③ 只限关键字参数（<code>*</code> 之后或带默认值的）④ <code>**kwargs</code>（如果存在）。</p>
<h3>Q3: 调用时用 <code>*</code> 和 <code>**</code> 解包是什么意思？和定义时有什么不同？</h3>
<p>星号有&quot;双重身份&quot;。<strong>定义时</strong>：<code>def f(*args)</code>——<code>*</code> 是&quot;打包&quot;操作符，把零散参数打包成元组。<strong>调用时</strong>：<code>f(*my_list)</code>——<code>*</code> 是&quot;解包&quot;操作符，把列表/元组拆成独立的参数。双星号同理——<strong>定义时</strong>打包成字典，<strong>调用时</strong>拆解字典。一个实用记忆法：定义时&quot;收拢&quot;，调用时&quot;展开&quot;。这在 AI 中非常实用：你可以把训练配置存在字典里（从 YAML 读取），调用时 <code>train(**config)</code> 一行解包。</p>
<h3>Q4: 默认参数的可变对象陷阱到底是怎么回事？为什么会累积？</h3>
<p>Python 的默认参数值在<strong>函数定义时只求值一次</strong>，而不是每次调用都重新求值。当默认值是可变对象（如 <code>[]</code>、<code>{}</code>）时，所有调用共享的是<strong>同一个对象</strong>。第一次调用 <code>append</code> 修改了这个共享对象，第二次调用时看到的已经是修改后的对象了——这就是&quot;累积&quot;效应的原因。解决方案：默认值用 <code>None</code>，函数体内检查 <code>if arg is None: arg = []</code>。不可变对象（<code>None</code>、<code>0</code>、<code>&quot;&quot;</code>、<code>False</code>）没有这个问题，因为对它们的&quot;修改&quot;实际是创建新对象。</p>
<h3>Q5: 什么是&quot;只限关键字参数&quot;（keyword-only argument）？</h3>
<p>Python 3 引入了&quot;裸星号&quot;语法：<code>def f(a, b, *, c, d)</code>——<code>*</code> 后面的 <code>c</code> 和 <code>d</code> 只能通过关键字方式传入，不能通过位置方式传入。这在你不想让用户靠位置猜参数含义时非常有用。比如 <code>def send_email(to, *, subject, body)</code>——<code>to</code> 用位置传（因为只有 1 个），<code>subject</code> 和 <code>body</code> 必须用关键字传（防止 <code>send_email(&quot;a@b.com&quot;, &quot;你好&quot;, &quot;正文内容&quot;)</code> 混淆 subject 和 body）。</p>

<h2>章节单词汇总</h2>
<div class="vocab-table-wrapper"><table class="vocab-table"><thead><tr><th>英文</th><th>音标</th><th>术语/释义</th></tr></thead><tbody><tr><td>positional</td><td>/pəˈzɪʃənəl/</td><td>位置的；按顺序对应传参</td></tr><tr><td>default</td><td>/dɪˈfɔːlt/</td><td>默认的；参数预设的备选值</td></tr><tr><td>argument</td><td>/ˈɑːrɡjumənt/</td><td>实参；调用时传入的具体值</td></tr><tr><td>variable-length</td><td>/ˈveəriəbl leŋθ/</td><td>可变长度的；<code>*args</code> 接收任意数量参数</td></tr><tr><td>keyword</td><td>/ˈkiːwɜːrd/</td><td>关键字；<code>key=value</code> 形式的传参方式</td></tr><tr><td>unpack</td><td>/ʌnˈpæk/</td><td>解包；用 <code>*</code> 或 <code>**</code> 拆解容器为独立参数</td></tr><tr><td>None</td><td>/nʌn/</td><td>空值；默认参数最佳安全初始值</td></tr><tr><td>tuple</td><td>/ˈtʌpl/</td><td>元组；<code>*args</code> 在函数内部的存储形式</td></tr></tbody></table></div>
<div class="quiz-raw"><h2>面试练习</h2>
<h3>Q1 [单选] 以下函数调用哪个是正确的？<code>def f(a, b=2, c=3):</code></h3>
<ul>
<li>A. <code>f(1, 2, 3, 4)</code></li><li>B. <code>f(1, c=5)</code></li><li>C. <code>f(b=2, 1)</code></li><li>D. <code>f()</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。<code>a=1</code>（位置），<code>b</code> 用默认值 2，<code>c=5</code>（关键字覆盖）。A 参数太多（只有 3 个），C 位置参数不能在关键字参数后面，D 缺少必传参数 <code>a</code>。</blockquote>


<h3>Q2 [单选] <code>def f(*args): print(len(args))</code> 执行 <code>f([1,2,3])</code> 输出什么？</h3>
<ul>
<li>A. 3</li><li>B. 1</li><li>C. 0</li><li>D. 报错</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。<code>f([1,2,3])</code> 只传了一个参数——这个参数本身是一个列表 <code>[1,2,3]</code>。<code>*args</code> 把它打包成 <code>([1,2,3],)</code>，长度为 1。如果要传 3 个独立参数，应该用 <code>f(*[1,2,3])</code> 解包。</blockquote>


<h3>Q3 [单选] 关于默认参数的可变对象陷阱，以下哪种写法是安全的？</h3>
<ul>
<li>A. <code>def f(lst=[]): pass</code></li><li>B. <code>def f(lst=None): if lst is None: lst = []</code></li><li>C. <code>def f(lst=list()): pass</code></li><li>D. <code>def f(lst={}): pass</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确——用 <code>None</code> 做默认值、函数内检查并新建，是解决可变默认参数陷阱的标准模式。A、C（<code>list()</code> 同样每次都是同一个对象）、D 都有问题。</blockquote>


<h3>Q4 [多选] 以下关于 <code>**kwargs</code> 的说法正确的是？</h3>
<ul>
<li>A. 在函数内部 <code>kwargs</code> 是一个字典</li><li>B. 调用时可以用 <code>**dict_var</code> 解包字典传参</li><li>C. <code>**kwargs</code> 必须放在参数列表的末尾</li><li>D. 调用时 <code>**kwargs</code> 的参数顺序很重要</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 正确。D 错误——关键字参数不关心顺序，<code>f(a=1, b=2)</code> 和 <code>f(b=2, a=1)</code> 完全等价。</blockquote>


<h3>Q5 [单选] 以下哪个是正确的参数顺序？</h3>
<ul>
<li>A. <code>def f(**kwargs, *args, a, b):</code></li><li>B. <code>def f(*args, a, b, **kwargs):</code></li><li>C. <code>def f(a, b, *args, **kwargs):</code></li><li>D. <code>def f(**kwargs, a, b, *args):</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 正确。参数顺序铁律：普通位置参数 → <code>*args</code> → <code>**kwargs</code>。A 和 D 把 <code>**kwargs</code> 放在开头，B 把位置参数放在 <code>*args</code> 后面（位置参数必须在 <code>*args</code> 前面）。</blockquote>


<h3>Q6 [多选] 以下哪些调用方式是合法的？<code>def f(a, b=0, *args, **kwargs):</code></h3>
<ul>
<li>A. <code>f(1)</code></li><li>B. <code>f(1, 2)</code></li><li>C. <code>f(1, 2, 3, 4, x=5)</code></li><li>D. <code>f(a=1, 2)</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 合法。A：<code>a=1, b=0</code>（默认）。B：<code>a=1, b=2</code>。C：<code>a=1, b=2, args=(3,4), kwargs={&#39;x&#39;:5}</code>。D 不合法——<code>2</code> 是位置参数，不能在关键字参数 <code>a=1</code> 之后。</blockquote>


<h3>Q7 [单选] <code>nums = [1,2,3]; print(*nums)</code> 输出什么？</h3>
<ul>
<li>A. <code>1 2 3</code></li><li>B. <code>[1, 2, 3]</code></li><li>C. <code>(1, 2, 3)</code></li><li>D. 报错</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A 正确。<code>print(*nums)</code> 等价于 <code>print(1, 2, 3)</code>——<code>*</code> 解包把列表拆成三个独立参数，<code>print</code> 用空格分隔输出它们。注意输出中间有空格是因为 <code>print</code> 的 <code>sep=&#39; &#39;</code> 默认行为。</blockquote>


<h3>Q8 [多选] 关于 <code>*args</code> 和 <code>**kwargs</code> 的命名，以下正确的是？</h3>
<ul>
<li>A. 可以改成 <code>*numbers</code> 和 <code>**config</code></li><li>B. <code>args</code> 和 <code>kwargs</code> 只是社区约定</li><li>C. Python 强制要求用 <code>args</code> 和 <code>kwargs</code></li><li>D. 实际起作用的是 <code>*</code> 和 <code>**</code> 符号，不是后面的变量名</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 正确。C 错误——Python 只要求 <code>*</code> 和 <code>**</code> 符号，变量名随意。但社区约定用 <code>args/kwargs</code> 以提高可读性。</blockquote>


<h3>Q9 [单选] <code>def f(a, b): return a, b</code> 和 <code>def f(*args): return args</code> 的区别是什么？</h3>
<ul>
<li>A. 第一个固定 2 参数，第二个任意数量参数</li><li>B. 完全一样，只是写法不同</li><li>C. 第一个返回元组，第二个返回列表</li><li>D. 第一个不能接收列表，第二个只能接收列表</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A 正确。<code>def f(a, b)</code> 只能接收恰好 2 个参数；<code>def f(*args)</code> 接收任意数量（0 到 n 个）。另外 <code>return a, b</code> 返回元组 <code>(a, b)</code>，<code>return args</code> 返回元组 <code>args</code>——都是元组。</blockquote>


<h3>Q10 [多选] 要在函数中同时接收「必须的参数 name」和「任意关键字参数」，以下哪些定义正确？</h3>
<ul>
<li>A. <code>def f(name, **kwargs):</code></li><li>B. <code>def f(name, **config):</code></li><li>C. <code>def f(**kwargs, name):</code></li><li>D. <code>def f(**kwargs, name=):</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B 正确（变量名随便取）。C 错误——<code>**kwargs</code> 必须在最后，它后面的参数拿不到值。D 语法错误。正确写法就是 <code>def 函数名(普通参数, **任意名):</code>。</blockquote>


</div>

      <div class="content-actions">
        <button class="action-btn" onclick="sharePage()" title="分享">
          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8"/><polyline points="16 6 12 2 8 6"/><line x1="12" y1="2" x2="12" y2="15"/></svg><span>分享</span>
        </button>
        <button class="action-btn" onclick="printPage()" title="打印">
          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><polyline points="6 9 6 2 18 2 18 9"/><path d="M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"/><rect x="6" y="14" width="12" height="8"/></svg><span>打印</span>
        </button>
        <button class="action-btn" onclick="showFeedback()" title="反馈">
          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"/></svg><span>反馈</span>
        </button>
      </div>
    </article>
  </main>
</div>

<script type="application/json" id="formula-data">{}</script>
<script type="application/json" id="quiz-data">[
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。`a=1`（位置），`b` 用默认值 2，`c=5`（关键字覆盖）。A 参数太多（只有 3 个），C 位置参数不能在关键字参数后面，D 缺少必传参数 `a`。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。`f([1,2,3])` 只传了一个参数——这个参数本身是一个列表 `[1,2,3]`。`*args` 把它打包成 `([1,2,3],)`，长度为 1。如果要传 3 个独立参数，应该用 `f(*[1,2,3])` 解包。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确——用 `None` 做默认值、函数内检查并新建，是解决可变默认参数陷阱的标准模式。A、C（`list()` 同样每次都是同一个对象）、D 都有问题。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 正确。D 错误——关键字参数不关心顺序，`f(a=1, b=2)` 和 `f(b=2, a=1)` 完全等价。"
  },
  {
    "type": "single",
    "answer": 2,
    "explanation": "C 正确。参数顺序铁律：普通位置参数 → `*args` → `**kwargs`。A 和 D 把 `**kwargs` 放在开头，B 把位置参数放在 `*args` 后面（位置参数必须在 `*args` 前面）。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 合法。A：`a=1, b=0`（默认）。B：`a=1, b=2`。C：`a=1, b=2, args=(3,4), kwargs={'x':5}`。D 不合法——`2` 是位置参数，不能在关键字参数 `a=1` 之后。"
  },
  {
    "type": "single",
    "answer": 0,
    "explanation": "A 正确。`print(*nums)` 等价于 `print(1, 2, 3)`——`*` 解包把列表拆成三个独立参数，`print` 用空格分隔输出它们。注意输出中间有空格是因为 `print` 的 `sep=' '` 默认行为。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 正确。C 错误——Python 只要求 `*` 和 `**` 符号，变量名随意。但社区约定用 `args/kwargs` 以提高可读性。"
  },
  {
    "type": "single",
    "answer": 0,
    "explanation": "A 正确。`def f(a, b)` 只能接收恰好 2 个参数；`def f(*args)` 接收任意数量（0 到 n 个）。另外 `return a, b` 返回元组 `(a, b)`，`return args` 返回元组 `args`——都是元组。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1
    ],
    "explanation": "A、B 正确（变量名随便取）。C 错误——`**kwargs` 必须在最后，它后面的参数拿不到值。D 语法错误。正确写法就是 `def 函数名(普通参数, **任意名):`。"
  }
]</script>

<script src="/js/chapter-enhance.js"></script>
<script src="/js/pay-modal.js?v=20260606e"></script>
<script src="/js/chapter-common.js"></script>
<script src="/js/chapter-learn.js"></script>
<script src="/js/chapter-nav.js"></script>
<script src="/js/chapter-voice.js"></script>
<script src="/js/chapter-quiz.js"></script>
<script src="/js/chapter-presence.js"></script>
<script src="/js/chapter-auth.js"></script>
<script src="/js/chapter-code.js"></script>
<script src="/js/chapter-annotation.js"></script>
<script src="/js/chapter-comments.js"></script>
<script src="/js/chapter-social.js"></script>
<script src="/js/chapter-ui.js?v=20260612c"></script>
<script src="/js/chapter-init.js?v=20260612b"></script>
</body>
</html>