<!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="深入讲解内置函数len/range/enumerate/zip等常用函数的核心内容与关键技术，属于Python编程基础的函数与模块方向">
<title>内置函数：len/range/enumerate/zip等常用函数 函数与模块 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>内置函数：len/range/enumerate/zip等常用函数</h1><div class="divider"></div>

<h2>一句话概述</h2>
<p>Python 自带一套&quot;内置函数&quot;（Built-in Functions）——不需要 <code>import</code> 任何模块就能直接使用的函数，大约 70 多个。其中最常用的有：<code>len()</code> 量长度、<code>range()</code> 生成整数序列、<code>enumerate()</code> 遍历带索引、<code>zip()</code> 并行迭代多序列、<code>map()</code> / <code>filter()</code> 批量转换和筛选、<code>sorted()</code> 排序、<code>sum()</code> / <code>min()</code> / <code>max()</code> 聚合计算。这些函数就像 Python 语言自带的&quot;瑞士军刀&quot;——用 C 语言实现、性能极高、语法简洁。在 AI 开发中，从加载数据到构建 batch，从遍历词表到并行计算特征，内置函数无处不在。</p>
<blockquote class="highlight-box"><strong>💡 核心要点：</strong>①<code>len()</code> 返回容器中元素的个数，适用于所有内置容器类型 ②<code>range(start, stop, step)</code> 生成整数序列，惰性求值，不占内存 ③<code>enumerate(seq)</code> 同时获取索引和值，是最 Pythonic 的遍历方式 ④<code>zip(a, b)</code> 将多个序列&quot;拉链&quot;成元组迭代器，<code>*</code> 解包可实现 <code>unzip</code> ⑤<code>map(func, seq)</code> 对每个元素应用函数，<code>filter(func, seq)</code> 按条件筛选</blockquote>


<h2>教学与演示</h2>
<h3>一、len() 与 range()——测量与生成</h3>
<p><strong>是什么</strong>：<code>len()</code> 返回容器中元素的个数（字符串返回字符数，列表/元组/字典/集合返回元素数）。<code>range(start, stop, step)</code> 生成一个等差数列（整数），它不直接创建列表，而是返回一个&quot;惰性&quot;的 range 对象——只有在需要时（如 for 循环中）才逐个产生值，因此即使 <code>range(1000000000)</code> 也几乎不占内存。</p>
<blockquote class="plain-explain"><strong>大白话</strong> <code>len()</code> 就像点人数——你站在讲台上看一眼就知道教室里有几个人，不用一个个数。<code>range()</code> 像自动报数器——你说&quot;从 1 报到 100&quot;，它不会真的把 1 到 100 全写纸上（所以不费纸），而是你问&quot;下一个是几&quot;，它才说&quot;下一个是 X&quot;——所以 <code>range(1000000)</code> 也不会占内存。</blockquote>


<p><strong>为什么</strong>：<code>len()</code> 是 Python 中最频繁调用的函数之一——检查列表是否为空、判断数据量、设置循环次数，处处需要它。<code>range()</code> 是 for 循环的标配——<code>for i in range(10)</code> 几乎出现在每一段 Python 代码中。在 AI 中，<code>len(dataset)</code> 获取数据集大小，<code>range(num_epochs)</code> 控制训练轮数，<code>range(0, len(data), batch_size)</code> 生成批数据的起止索引。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 没有 <code>len()</code> 的世界：每次想知道列表有几个元素，你得写循环一个个数。没有 <code>range()</code> 的世界：每次要循环 10 次，你得写 <code>i = 0; while i &lt; 10: ... i += 1</code>——丑陋且容易忘记 <code>i += 1</code> 导致死循环。内置函数把这些&quot;每个人都需要的操作&quot;变成了一个词。</blockquote>


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

# ====== 1. len() 的基本用法 ======

# len() 适用于所有内置容器类型
print(&quot;=== len() 示例 ===&quot;)
print(f&quot;列表 [1,2,3,4,5] 长度: {len([1,2,3,4,5])}&quot;)       # 5
print(f&quot;元组 (1,2,3) 长度:     {len((1,2,3))}&quot;)           # 3
print(f&quot;字符串 'hello' 长度:   {len('hello')}&quot;)            # 5
print(f&quot;字典 {{'a':1,'b':2}}:    {len({'a':1,'b':2})}&quot;)   # 2
print(f&quot;集合 {{1,2,3,3}}:        {len({1,2,3,3})}&quot;)       # 3（集合去重）

# len() 检查是否为空（Pythonic 做法）
data = []
if len(data) == 0:                             # 明确：长度等于 0
    print(&quot;\n数据为空&quot;)
# 更 Pythonic 的做法：利用空容器为 False
if not data:                                   # 推荐：更简洁
    print(&quot;数据也为空（Pythonic 写法）&quot;)

# ====== 2. range() 的三种参数形式 ======

print(&quot;\n=== range() 的三种形式 ===&quot;)

# range(stop)：从 0 到 stop-1
print(f&quot;range(5):    {list(range(5))}&quot;)        # [0, 1, 2, 3, 4]

# range(start, stop)：从 start 到 stop-1
print(f&quot;range(2, 7): {list(range(2, 7))}&quot;)     # [2, 3, 4, 5, 6]

# range(start, stop, step)：步长为 step
print(f&quot;range(1, 10, 2): {list(range(1, 10, 2))}&quot;)  # [1, 3, 5, 7, 9] — 奇数
print(f&quot;range(10, 0, -1): {list(range(10, 0, -1))}&quot;)  # [10,9,8,7,6,5,4,3,2,1] — 倒序

# ====== 3. range() 是惰性的——对比占用内存 ======

import sys

r = range(1000000)                             # 创建一个百万级别的 range
lst = list(range(1000000))                     # 创建百万级别的列表

print(f&quot;\n=== 内存对比 ===&quot;)
# range 对象只存 start, stop, step 三个值，内存极小
print(f&quot;range(1000000) 内存: {sys.getsizeof(r):,} 字节&quot;)
# list 存每个元素，内存大得多
print(f&quot;list(range(1000000)) 内存: {sys.getsizeof(lst):,} 字节&quot;)
print(f&quot;内存差距: {sys.getsizeof(lst) / sys.getsizeof(r):.0f} 倍！&quot;)

# range 支持成员检查（O(1)！比列表的 O(n) 快得多）
print(f&quot;500000 in range(1000000): {500000 in r}&quot;)   # True — 瞬间完成

# ====== 4. len + range 的经典组合 ======

# 遍历索引
fruits = [&quot;苹果&quot;, &quot;香蕉&quot;, &quot;橘子&quot;, &quot;西瓜&quot;, &quot;葡萄&quot;]
print(f&quot;\n=== 索引遍历 ===&quot;)
for i in range(len(fruits)):                   # range(len(seq)) 是最常见模式
    print(f&quot;  索引 {i}: {fruits[i]}&quot;)

# 反向遍历
print(&quot;\n=== 反向遍历 ===&quot;)
for i in range(len(fruits)-1, -1, -1):         # 从最后一个索引到 0
    print(f&quot;  索引 {i}: {fruits[i]}&quot;)

# ====== 5. AI 场景：用 range 批量生成数据索引 ======

dataset_size = 1000                            # 模拟数据集大小
batch_size = 128                               # 批大小

print(f&quot;\n=== 批数据索引生成 ===&quot;)
print(f&quot;数据集大小: {dataset_size}, 批大小: {batch_size}&quot;)

batch_indices = []
for start in range(0, dataset_size, batch_size):
    end = min(start + batch_size, dataset_size)  # 最后一批可能不够 batch_size
    batch_indices.append((start, end))

print(f&quot;批次数量: {len(batch_indices)}&quot;)
print(f&quot;前 3 批索引: {batch_indices[:3]}&quot;)
print(f&quot;最后一批: {batch_indices[-1]}&quot;)         # (896, 1000) — 只有 104 条</code></pre><p><strong>什么用</strong>：在 AI 中，<code>len()</code> 和 <code>range()</code> 是&quot;呼吸级别&quot;的基础操作。<code>len(dataloader)</code> 返回总批次数；<code>range(num_epochs)</code> 控制外层训练循环；<code>range(0, len(X), batch_size)</code> 切片取批数据；<code>len(vocab)</code> 获取词表大小作为嵌入层维度。PyTorch 的 <code>DataLoader</code> 内部重度依赖 <code>range()</code> 和 <code>len()</code> 来判断何时结束一个 epoch。</p>
<h3>二、enumerate()——索引和值一把抓</h3>
<p><strong>是什么</strong>：<code>enumerate(iterable, start=0)</code> 把一个可迭代对象（列表、元组、字符串等）包装成一个&quot;索引-值&quot;对迭代器。每次迭代返回一个 <code>(index, value)</code> 元组。<code>start</code> 参数控制索引起始值（默认 0，可设为 1）。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 常规的 <code>for item in list:</code> 只能拿到值，不知道它是第几个。<code>enumerate</code> 解决了这个问题——它自动给每个值贴上一个&quot;序号标签&quot;。就像给排队的人发号牌——&quot;1 号张三，2 号李四，3 号王五&quot;。比起手动维护一个 <code>i = 0; i += 1</code> 的计数器，<code>enumerate</code> 更 Pythonic、更安全（不会忘了 <code>i += 1</code>）。</blockquote>


<p><strong>为什么</strong>：大多数遍历场景你其实都需要知道索引——&quot;第几个元素出错了？&quot;、&quot;找到目标值的索引&quot;、&quot;给每个样本标注它在 batch 中的位置&quot;。没有 <code>enumerate</code> 时，你需要手动维护索引变量，代码冗长且容易出错。在 AI 中，<code>enumerate(epoch_losses)</code> 画损失曲线时需要 epoch 编号作为 x 轴，<code>enumerate(dataloader)</code> 打印训练进度时需要 batch 编号。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 你遍历一个 100 人的名单，想找到&quot;王五&quot;是第几个人。不用 <code>enumerate</code>：你一只手翻名单（for each），另一只手在纸上打草稿记第几个（i += 1）。手忙脚乱还容易记串。用 <code>enumerate</code>：名单自动带编号，你两只手都不用动——Python 替你数好了。</blockquote>


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

# ====== 1. enumerate 的基本用法 ======

colors = [&quot;红&quot;, &quot;橙&quot;, &quot;黄&quot;, &quot;绿&quot;, &quot;蓝&quot;, &quot;靛&quot;, &quot;紫&quot;]

print(&quot;=== enumerate 基本用法 ===&quot;)
for index, color in enumerate(colors):         # 解包：(索引, 值)
    print(f&quot;  第 {index} 种颜色是 {color}&quot;)

# ====== 2. start 参数——从 1 开始编号 ======

print(&quot;\n=== start 参数（从 1 开始） ===&quot;)
for rank, color in enumerate(colors, start=1): # 排名从 1 开始，更符合人类习惯
    print(f&quot;  第 {rank} 名: {color}&quot;)

# ====== 3. enumerate 替代手动计数器 ======

# ❌ 不推荐的手动计数方式
i = 0
for color in colors:
    print(f&quot;  [{i}] {color}&quot;, end=&quot;; &quot;)        # 手动维护索引
    i += 1                                     # 容易忘记
print()

# ✅ 推荐的 enumerate 方式
for i, color in enumerate(colors):
    print(f&quot;  [{i}] {color}&quot;, end=&quot;; &quot;)        # Python 自动管理索引
print()

# ====== 4. 在 AI 开发中的实际应用 ======

# 场景一：训练日志——记录每个 epoch 的指标
epoch_losses = [0.85, 0.62, 0.48, 0.38, 0.32, 0.28]

print(&quot;\n=== 训练日志 ===&quot;)
for epoch, loss in enumerate(epoch_losses, start=1):
    # 计算改善率（和上一轮比）
    if epoch == 1:
        improvement = &quot;—&quot;
    else:
        improvement = f&quot;{(epoch_losses[epoch-2] - loss) / epoch_losses[epoch-2] * 100:.1f}%&quot;
    print(f&quot;  Epoch {epoch:2d}: Loss={loss:.3f} (改善: {improvement})&quot;)

# 场景二：在数据中搜索目标值
labels = [&quot;猫&quot;, &quot;狗&quot;, &quot;鸟&quot;, &quot;猫&quot;, &quot;鱼&quot;, &quot;猫&quot;, &quot;狗&quot;]
target = &quot;猫&quot;

print(f&quot;\n=== 搜索 '{target}' 出现的位置 ===&quot;)
positions = [idx for idx, label in enumerate(labels) if label == target]
print(f&quot;  '{target}' 出现在索引: {positions}&quot;)  # [0, 3, 5]

# 场景三：批量打印预测结果（带序号和置信度）
predictions = [
    {&quot;label&quot;: &quot;猫&quot;, &quot;confidence&quot;: 0.92},
    {&quot;label&quot;: &quot;狗&quot;, &quot;confidence&quot;: 0.78},
    {&quot;label&quot;: &quot;鸟&quot;, &quot;confidence&quot;: 0.55},
    {&quot;label&quot;: &quot;猫&quot;, &quot;confidence&quot;: 0.99},
]

print(&quot;\n=== Top-K 预测结果 ===&quot;)
for rank, pred in enumerate(predictions, start=1):
    bar = &quot;█&quot; * int(pred[&quot;confidence&quot;] * 20)   # 可视化置信度
    print(f&quot;  Top-{rank}: {pred['label']:4s} |{bar:20s}| {pred['confidence']:.0%}&quot;)

# ====== 5. enumerate 也适用于 numpy 数组遍历 ======

features = np.array([[0.5, 0.8, 0.1],
                      [0.2, 0.3, 0.9],
                      [0.7, 0.4, 0.6]])

print(&quot;\n=== 遍历特征向量 ===&quot;)
for i, vec in enumerate(features):
    print(f&quot;  样本 {i}: {np.round(vec, 2)}&quot;)</code></pre><p><strong>什么用</strong>：<code>enumerate</code> 是 AI 数据处理中最常用的内置函数之一。遍历训练数据时记录样本编号；画图时用 <code>enumerate(epoch_losses)</code> 生成 x 轴数据；打印 Top-K 预测结果时用 rank 表示置信度排名；查看词表时用 <code>enumerate(vocab, start=1)</code> 显示词频排名。PyTorch 的 <code>enumerate(train_loader)</code> 在训练循环中打印 <code>Batch {batch_idx}/{total_batches}</code> 是一种标准写法。</p>
<h3>三、zip()——并行迭代的&quot;拉链&quot;</h3>
<p><strong>是什么</strong>：<code>zip(iterable1, iterable2, ...)</code> 将多个可迭代对象&quot;拉链&quot;在一起——每次迭代返回一个元组，元组的第 i 个元素来自第 i 个输入迭代器的当前值。当最短的输入耗尽时，<code>zip()</code> 自动停止。想严格匹配长度可用 <code>zip_longest</code>（来自 <code>itertools</code> 模块）。<code>zip(*zipped)</code> 可以实现&quot;解压&quot;。</p>
<blockquote class="plain-explain"><strong>大白话</strong> <code>zip</code> 就像拉链——把两排牙齿（两个列表）一对一对扣在一起。<code>zip([&quot;张三&quot;, &quot;李四&quot;, &quot;王五&quot;], [85, 92, 78])</code> 产生 <code>(&quot;张三&quot;, 85), (&quot;李四&quot;, 92), (&quot;王五&quot;, 78)</code>。如果两排牙齿不一样长，拉链拉到短的那排尽头就停了——多出来的被忽略。还有一个&quot;反向拉链&quot;技巧：<code>zip(*拉链结果)</code> 能把拉好的链子再拆开。</blockquote>


<p><strong>为什么</strong>：在数据科学中，你几乎总是在同时处理多个相关联的列表——特征 X 和标签 y、预测值和真实值、键和值。<code>zip()</code> 让并行遍历变得优雅自然。在最需要效率的 AI 训练循环中，<code>zip(features, labels)</code> 同时取出一个 batch 的输入和目标，比用索引 <code>features[i]</code> 和 <code>labels[i]</code> 更直观。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 不用 zip 的话，你同时遍历两个列表得这样写：<code>for i in range(len(names)): print(names[i], scores[i])</code>——啰嗦。用 zip：<code>for name, score in zip(names, scores): print(name, score)</code>——简洁。而且 zip 自动处理了长度不等的情况（按短的那个停止），防止索引越界。</blockquote>


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

# ====== 1. zip 的基本用法 ======

names = [&quot;张三&quot;, &quot;李四&quot;, &quot;王五&quot;, &quot;赵六&quot;]
scores = [85, 92, 78, 88]
cities = [&quot;北京&quot;, &quot;上海&quot;, &quot;深圳&quot;, &quot;杭州&quot;]

print(&quot;=== zip 基本用法 ===&quot;)
for name, score, city in zip(names, scores, cities):
    print(f&quot;  {name} ({city}): {score} 分&quot;)

# ====== 2. zip 按最短停止——不等长时截断 ======

short = [1, 2, 3]                              # 只有 3 个元素
long = [10, 20, 30, 40, 50]                    # 有 5 个元素

print(&quot;\n=== 不等长 zip ===&quot;)
print(&quot;短序列:&quot;, short)
print(&quot;长序列:&quot;, long)
print(&quot;zip 结果:&quot;, list(zip(short, long)))    # [(1,10), (2,20), (3,30)] — 按短的停止！

# 4 和 5 对应的 40 和 50 被截断了！

# ====== 3. 解压：用 zip(*zipped) 反向操作 ======

pairs = list(zip(names, scores))               # 先拉上：[(姓名, 分数), ...]
print(f&quot;\n拉链结果: {pairs}&quot;)

# 解压：* 解包后传给 zip
unzipped_names, unzipped_scores = zip(*pairs)
print(f&quot;解压名字: {list(unzipped_names)}&quot;)     # ['张三', '李四', '王五', '赵六']
print(f&quot;解压分数: {list(unzipped_scores)}&quot;)    # [85, 92, 78, 88]

# ====== 4. zip 构建字典——一行创建映射 ======

# 最快速创建字典的方式：zip + dict
student_dict = dict(zip(names, scores))
print(f&quot;\nzip 创建字典: {student_dict}&quot;)       # {'张三': 85, '李四': 92, ...}

# ====== 5. AI 实战场景 ======

# 场景一：配对训练数据（特征 + 标签）
features = np.array([[0.5, 0.8], [0.2, 0.3], [0.7, 0.4], [0.1, 0.9]])
labels = np.array([1, 0, 1, 0])

print(&quot;\n=== 训练数据配对 ===&quot;)
for feat, label in zip(features, labels):
    cls_name = &quot;正类&quot; if label == 1 else &quot;负类&quot;
    print(f&quot;  特征={np.round(feat, 2)} → 标签={label}({cls_name})&quot;)

# 场景二：批量计算——预测值和真实值的误差
predictions = [0.9, 0.3, 0.8, 0.2]            # 模型预测
targets = [1.0, 0.0, 1.0, 0.0]                # 真实值

print(&quot;\n=== 预测误差分析 ===&quot;)
for i, (pred, target) in enumerate(zip(predictions, targets)):
    error = abs(pred - target)                 # 绝对误差
    correct = (pred &gt; 0.5) == (target &gt; 0.5)  # 是否正确分类
    status = &quot;✅&quot; if correct else &quot;❌&quot;
    print(f&quot;  样本 {i}: 预测={pred:.2f}, 真实={target:.0f}, 误差={error:.2f} {status}&quot;)

# 场景三：并行遍历多个指标
epoch_nums = [1, 2, 3, 4, 5]
train_loss = [0.85, 0.62, 0.48, 0.38, 0.32]
val_loss =   [0.90, 0.68, 0.55, 0.50, 0.45]  # 验证损失

print(&quot;\n=== 训练 vs 验证损失 ===&quot;)
for ep, t_loss, v_loss in zip(epoch_nums, train_loss, val_loss):
    gap = v_loss - t_loss                      # 过拟合指标
    print(f&quot;  Epoch {ep}: 训练={t_loss:.3f}, 验证={v_loss:.3f}, 泛化差距={gap:.3f}&quot;)</code></pre><p><strong>什么用</strong>：<code>zip</code> 在 AI 中到处出现。<code>zip(X_batch, y_batch)</code> 遍历 mini-batch 数据；<code>zip(labels, predictions)</code> 计算逐样本的准确率；<code>zip(keys, values)</code> 快速构建词表映射字典；<code>zip(*batches)</code> 把按样本组织的数据重组为按特征组织。PyTorch 的 <code>enumerate(zip(train_loader, val_loader))</code> 可以同时遍历训练和验证数据加载器进行对比评估。掌握 <code>zip</code>，你就掌握了并行数据处理的钥匙。</p>
<h3>四、map()、filter() 与 sorted()——批量加工与排序</h3>
<p><strong>是什么</strong>：<code>map(function, iterable)</code> 对可迭代对象中的每个元素应用同一个函数，返回一个迭代器（Python 3）。<code>filter(function, iterable)</code> 用一个返回布尔值的函数筛选元素——只保留函数返回 True 的元素。<code>sorted(iterable, key=None, reverse=False)</code> 返回一个<strong>新的排序列表</strong>（与 <code>list.sort()</code> 原地排序不同），<code>key</code> 参数可以指定一个函数来自定义排序依据。</p>
<blockquote class="plain-explain"><strong>大白话</strong> <code>map</code> 就像流水线工人——每个产品（元素）经过他时，他都做同一个操作（比如贴标签），然后传给下一个。<code>filter</code> 就像质检员——每个产品经过时，他检查是否合格，合格的放行，不合格的扔掉。<code>sorted</code> 就像整理员——把所有产品按某个标准（大小、颜色、价格）排列整齐，交给你一份全新的清单。</blockquote>


<p><strong>为什么</strong>：这三个函数代表了数据处理中最核心的三种操作：<strong>变换</strong>（map）、<strong>筛选</strong>（filter）、<strong>排序</strong>（sorted）。在实际工作中，你的数据很少&quot;开箱即用&quot;——字符串需要转成数字（map）、异常值需要剔除（filter）、结果需要按置信度排名（sorted）。在 AI 中，特征工程、数据清洗、结果排序大量依赖这些函数。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 原始数据就像刚从菜市场买回来的菜——有泥（需要清洗 = filter），没切（需要加工 = map），乱堆着（需要分类排序 = sorted）。内置函数就是帮你快速把&quot;毛料数据&quot;变成&quot;精加工数据&quot;的厨房工具。</blockquote>


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

# ====== 1. map() 的基本用法——批量变换 ======

# map 返回迭代器，用 list() 转换为列表查看
numbers = [1, 2, 3, 4, 5]

# 每个数平方
squared = list(map(lambda x: x ** 2, numbers))
print(f&quot;平方: {squared}&quot;)                      # [1, 4, 9, 16, 25]

# 也可以用时定义好的函数
def to_percent(x):
    return f&quot;{x * 100:.1f}%&quot;

probs = [0.92, 0.78, 0.55, 0.99]
percents = list(map(to_percent, probs))
print(f&quot;百分比: {percents}&quot;)                   # ['92.0%', '78.0%', '55.0%', '99.0%']

# map 可以接受多个可迭代对象——并行传参
a = [1, 2, 3]
b = [10, 20, 30]
summed = list(map(lambda x, y: x + y, a, b))
print(f&quot;逐元素相加: {summed}&quot;)                # [11, 22, 33]

# ====== 2. filter() 的基本用法——批量筛选 ======

# 筛选正数
all_nums = [-3, 5, 0, 8, -2, 10, -1]
positives = list(filter(lambda x: x &gt; 0, all_nums))
print(f&quot;\n正数: {positives}&quot;)                  # [5, 8, 10]

# 筛选非空字符串
words = [&quot;hello&quot;, &quot;&quot;, &quot;world&quot;, &quot;&quot;, &quot;python&quot;, None]
# 注意：filter(None, iterable) 是一个特殊用法——过滤掉&quot;假值&quot;（False、0、&quot;&quot;、None）
valid_words = list(filter(None, words))
print(f&quot;有效词: {valid_words}&quot;)                # ['hello', 'world', 'python']

# filter 配合自定义函数
def is_high_confidence(pred):
    &quot;&quot;&quot;置信度高于 0.7 才算可靠&quot;&quot;&quot;
    return pred[&quot;confidence&quot;] &gt; 0.7

predictions = [
    {&quot;label&quot;: &quot;猫&quot;, &quot;confidence&quot;: 0.92},
    {&quot;label&quot;: &quot;狗&quot;, &quot;confidence&quot;: 0.45},
    {&quot;label&quot;: &quot;鸟&quot;, &quot;confidence&quot;: 0.78},
    {&quot;label&quot;: &quot;鱼&quot;, &quot;confidence&quot;: 0.55},
]

reliable = list(filter(is_high_confidence, predictions))
print(f&quot;\n高置信度预测: {reliable}&quot;)

# ====== 3. sorted() 的基本用法——排序 ======

# 基本排序
nums = [3, 1, 4, 1, 5, 9, 2, 6]
print(f&quot;\n升序: {sorted(nums)}&quot;)               # [1, 1, 2, 3, 4, 5, 6, 9]
print(f&quot;降序: {sorted(nums, reverse=True)}&quot;)   # [9, 6, 5, 4, 3, 2, 1, 1]

# key 参数——按自定义标准排序
fruits = [&quot;watermelon&quot;, &quot;apple&quot;, &quot;banana&quot;, &quot;pear&quot;, &quot;kiwi&quot;]
# 按长度排序
by_length = sorted(fruits, key=len)
print(f&quot;\n按长度排序: {by_length}&quot;)            # ['pear', 'kiwi', 'apple', 'banana', 'watermelon']

# 按最后一个字母排序
by_last = sorted(fruits, key=lambda s: s[-1])
print(f&quot;按尾字母排序: {by_last}&quot;)

# ====== 4. AI 场景中的实际应用 ======

# 场景一：数据清洗——过滤异常值
features = np.array([0.5, 1.2, 100.0, 0.8, -50.0, 0.3, 2.1])
# 用 filter 保留正常范围的值（0 到 10 之间）
clean = list(filter(lambda x: 0 &lt;= x &lt;= 10, features))
print(f&quot;\n数据清洗前: {features}&quot;)
print(f&quot;数据清洗后: {clean}&quot;)

# 场景二：特征标准化——map 批量处理
raw = [10, 50, 200, 500, 1000]
# Min-Max 标准化：需要先知道 min 和 max
d_min, d_max = min(raw), max(raw)
normalized = list(map(lambda x: round((x - d_min) / (d_max - d_min), 3), raw))
print(f&quot;\nMin-Max 标准化: {normalized}&quot;)

# 场景三：按置信度排序预测结果
detections = [
    (&quot;猫&quot;, 0.92), (&quot;背景&quot;, 0.15), (&quot;狗&quot;, 0.88),
    (&quot;鸟&quot;, 0.55), (&quot;猫&quot;, 0.97)
]
# 按置信度降序排列
ranked = sorted(detections, key=lambda x: x[1], reverse=True)
print(f&quot;\nTop-3 检测结果:&quot;)
for rank, (label, conf) in enumerate(ranked[:3], start=1):
    print(f&quot;  {rank}. {label} — 置信度 {conf:.0%}&quot;)

# 场景四：复合操作——filter + map + sorted 流水线
# 需求：从分数列表中筛选及格的，算出百分制，从高到低排列
scores = [45, 78, 92, 33, 60, 55, 85, 40]
passing = filter(lambda x: x &gt;= 60, scores)    # ① 筛选及格
scaled = map(lambda x: round(x / 100 * 100), passing)  # ② 转换（保持原样）
ranked = sorted(scaled, reverse=True)          # ③ 降序排列

print(f&quot;\n原始分数: {scores}&quot;)
print(f&quot;及格分数(降序): {list(ranked)}&quot;)       # [92, 85, 78, 60]</code></pre><p><strong>什么用</strong>：<code>map</code>、<code>filter</code>、<code>sorted</code> 是 AI 数据处理的&quot;三剑客&quot;。<code>map</code> 用于批量特征变换——<code>map(normalize, feature_columns)</code> 或数据增强 <code>map(augment, images)</code>。<code>filter</code> 用于数据清洗——过滤掉空标签、NaN 值、异常置信度。<code>sorted</code> 用于结果排名——Top-K 预测、beam search 中的候选排序、以及按指标对实验结果的排名。PyTorch 的 <code>Dataset</code> 类配合 <code>map</code> 风格的 <code>transform</code> 参数是标准范式。</p>
<h3>五、sum()、min()、max() 与聚合函数</h3>
<p><strong>是什么</strong>：<code>sum(iterable, start=0)</code> 计算数值序列的总和；<code>min(iterable)</code> 和 <code>max(iterable)</code> 找最小/最大值。这些是 Python 中最常用的聚合函数——把一个序列&quot;压缩&quot;成一个值。<code>any(iterable)</code> 检查是否有任一元素为 True，<code>all(iterable)</code> 检查是否所有元素都为 True。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 聚合函数就像结账——你把一车商品（数据）推过去，收银员把它们汇总成一个数字（总价）。<code>sum</code> 是算总价，<code>min</code> 是最便宜的那件，<code>max</code> 是最贵的那件，<code>any</code> 是&quot;有没有过期商品？&quot;，<code>all</code> 是&quot;全都是进口商品吗？&quot;。</blockquote>


<p><strong>为什么</strong>：AI 中的计算核心就是聚合——损失函数 <code>sum((pred - target)^2)</code>、准确率 <code>sum(pred == target) / len(target)</code>、模型输出 <code>max(logits)</code> 找预测类别。这些看似不同的操作，在 Python 中都被聚合函数优雅地表达。它们还有一个共同优点——用 C 语言实现，比你自己写 for 循环快几倍。</p>
<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-5"><code class="language-python">import numpy as np

# ====== 1. sum()、min()、max() 的基本用法 ======

scores = [85, 92, 78, 95, 88, 70, 83]

print(&quot;=== 聚合函数 ===&quot;)
print(f&quot;总分:   {sum(scores)}&quot;)               # 591
print(f&quot;平均:   {sum(scores) / len(scores):.1f}&quot;)  # 84.4
print(f&quot;最高分: {max(scores)}&quot;)               # 95
print(f&quot;最低分: {min(scores)}&quot;)               # 70

# sum 的 start 参数：从指定初始值开始加
print(f&quot;sum + 1000: {sum(scores, 1000)}&quot;)      # 1591 — 初始值+总分

# ====== 2. max/min 的 key 参数——按自定义标准找 ======

words = [&quot;apple&quot;, &quot;banana&quot;, &quot;pear&quot;, &quot;watermelon&quot;, &quot;kiwi&quot;]
longest = max(words, key=len)                  # 按长度找最长
shortest = min(words, key=len)                 # 按长度找最短
print(f&quot;\n最长单词: {longest}&quot;)                # watermelon
print(f&quot;最短单词: {shortest}&quot;)                 # pear

# 结合 lambda 实现复杂查找
students = [
    {&quot;name&quot;: &quot;张三&quot;, &quot;score&quot;: 85},
    {&quot;name&quot;: &quot;李四&quot;, &quot;score&quot;: 92},
    {&quot;name&quot;: &quot;王五&quot;, &quot;score&quot;: 78},
    {&quot;name&quot;: &quot;赵六&quot;, &quot;score&quot;: 95},
]
top_student = max(students, key=lambda s: s[&quot;score&quot;])
print(f&quot;\n最高分学生: {top_student['name']} ({top_student['score']}分)&quot;)

# ====== 3. any() 和 all()——批量逻辑判断 ======

# any(): 至少有一个为 True → True（&quot;有吗？&quot;）
# all(): 全部为 True → True（&quot;全都是吗？&quot;）

conditions = [True, False, True, True]
print(f&quot;\nany(): {any(conditions)}&quot;)            # True — 至少有一个 True
print(f&quot;all(): {all(conditions)}&quot;)             # False — 不全是 True

# AI 实际场景
# 检测是否有异常损失
losses = [0.05, 0.03, 0.12, 0.08, 1.5, 0.04]
has_anomaly = any(l &gt; 1.0 for l in losses)     # 有无损失 &gt; 1.0？
print(f&quot;存在异常损失: {has_anomaly}&quot;)          # True

# 检查所有预测是否都是高置信度
confs = [0.92, 0.88, 0.95, 0.78]
all_high = all(c &gt; 0.7 for c in confs)         # 全部 &gt; 0.7？
print(f&quot;全部高置信度: {all_high}&quot;)             # True

# ====== 4. round()——四舍五入 ======

# round(number, ndigits) 保留 ndigits 位小数
pi = 3.1415926535
print(f&quot;\nround(π, 2): {round(pi, 2)}&quot;)        # 3.14
print(f&quot;round(π, 4): {round(pi, 4)}&quot;)          # 3.1416
# 注意：round(2.5) → 2（Python 的银行家舍入，四舍六入五留双）
print(f&quot;round(2.5): {round(2.5)}, round(3.5): {round(3.5)}&quot;)  # 2, 4

# ====== 5. abs()——绝对值 ======

print(f&quot;\nabs(-10): {abs(-10)}&quot;)               # 10
print(f&quot;abs(3.14): {abs(3.14)}&quot;)               # 3.14

# 误差计算中绝对值的典型用法
pred = [0.9, 0.1, 0.8, 0.3]
true = [1.0, 0.0, 1.0, 0.0]
mae = sum(abs(p - t) for p, t in zip(pred, true)) / len(pred)
print(f&quot;平均绝对误差 (MAE): {mae:.2f}&quot;)

# ====== 6. pow() 和 divmod() ======

# pow(base, exp)：求幂
print(f&quot;\npow(2, 10) = {pow(2, 10)}&quot;)          # 1024

# divmod(a, b)：同时返回商和余数
q, r = divmod(17, 5)                           # 17 ÷ 5
print(f&quot;17 ÷ 5: 商={q}, 余数={r}&quot;)            # 商=3, 余数=2

# AI 场景：epoch/batch 计数
total_samples = 1000
batch_size = 128
num_full_batches, remainder = divmod(total_samples, batch_size)
print(f&quot;\n{total_samples} 个样本 / {batch_size} 批大小:&quot;)
print(f&quot;  完整批次: {num_full_batches}, 剩余: {remainder} 个&quot;)

# ====== 7. type() 和 isinstance()——类型检查 ======

x = 42
print(f&quot;\ntype(42): {type(x)}&quot;)                # &lt;class 'int'&gt;
print(f&quot;isinstance(42, int): {isinstance(x, int)}&quot;)    # True
print(f&quot;isinstance(42, str): {isinstance(x, str)}&quot;)    # False
print(f&quot;isinstance(42, (int, float)): {isinstance(x, (int, float))}&quot;)  # True — 元组多类型

# isinstance 支持多类型检查——AI 中验证输入类型
def safe_normalize(data):
    if not isinstance(data, (list, np.ndarray)):
        raise TypeError(&quot;data 必须是 list 或 numpy 数组&quot;)
    return (data - min(data)) / (max(data) - min(data))

# ====== 8. input() 和 print()——输入输出 ======

# print 的高级用法——sep 和 end 参数
print(&quot;\n=== print 高级用法 ===&quot;)
print(&quot;苹果&quot;, &quot;香蕉&quot;, &quot;橘子&quot;, sep=&quot; | &quot;)      # 苹果 | 香蕉 | 橘子
print(&quot;加载中&quot;, end=&quot;...&quot;)                     # 不换行
print(&quot;完成！&quot;)</code></pre><p><strong>什么用</strong>：聚合函数在 AI 中无处不在。<code>sum((pred - target)^2)</code> 计算 MSE 损失；<code>max(logits)</code> 找预测类别（argmax）；<code>min(losses)</code> 找最优模型；<code>all(grad != 0 for grad in gradients)</code> 检查梯度是否消失；<code>any(torch.isnan(loss))</code> 检测训练是否出现 NaN。这些操作在每个训练步骤中都会执行，理解它们的高效用法能让你写出更干净、更快的训练代码。</p>
<div class="demo-embed" data-demo-src="/demos/function-demo1.html"><a href="/demos/function-demo1.html">内置函数实验室——瑞士军刀实战手册（动画演示）</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>len()</td><td>返回容器元素个数</td><td>数据集大小、词表大小、批次数量</td><td>range()、size</td></tr><tr><td>range()</td><td>生成整数序列，惰性求值</td><td>循环计数器、批量索引生成</td><td>for、迭代器</td></tr><tr><td>enumerate()</td><td>索引+值同步迭代</td><td>训练进度日志、Top-K排名</td><td>zip()、解包</td></tr><tr><td>zip()</td><td>多序列并行拉链</td><td>特征/标签配对、批数据并行遍历</td><td>enumerate()、解压</td></tr><tr><td>map()</td><td>逐元素应用函数</td><td>数据变换、特征标准化、数据增强</td><td>filter()、lambda</td></tr><tr><td>filter()</td><td>按条件筛选元素</td><td>数据清洗、异常值过滤、低置信度剔除</td><td>map()、列表推导式</td></tr><tr><td>sorted()</td><td>返回新排序列表</td><td>Top-K预测、按指标排序、置信度排名</td><td>sort()、key参数</td></tr><tr><td>sum/max/min</td><td>数值聚合计算</td><td>损失计算、准确率统计、最优模型选择</td><td>any/all、mean</td></tr></tbody></table></div>
<h2>重点答疑</h2>
<h3>Q1: <code>range()</code> 和 <code>list(range())</code> 有什么区别？什么时候该转成 list？</h3>
<p><code>range()</code> 返回一个<strong>惰性的 range 对象</strong>——它只存储 start、stop、step 三个值，不实际创建所有元素。<code>list(range())</code> 会创建一个包含所有元素的实际列表，占用大量内存（对于大范围）。<strong>什么时候转 list？</strong> ①你需要多次遍历这些数字（range 对象被迭代一次就耗尽）；②你需要随机访问（<code>lst[100]</code>）——range 也支持索引但 list 的语义更直观；③你需要修改值。<strong>什么时候不转？</strong> 大多数 for 循环直接用 range 就够了——<code>for i in range(1000000)</code> 不占内存，极其高效。</p>
<h3>Q2: <code>map()</code> 和列表推导式有什么区别？哪个更好？</h3>
<p>两者功能基本等价——<code>list(map(f, data))</code> 约等于 <code>[f(x) for x in data]</code>。<strong>列表推导式更好（大多数情况）</strong>——因为它更 Pythonic、可读性更高、而且不需要额外的 <code>list()</code> 转换。Guido van Rossum（Python 之父）本人推荐列表推导式而非 <code>map()</code>。但在两种情况下 <code>map()</code> 更优：①函数已经存在（如 <code>map(int, strings)</code>）；②你不需要创建列表，只需要迭代结果（<code>for result in map(f, data)</code>——惰性求值，省内存）。目前社区共识：能用列表推导就用列表推导，<code>map</code> 在有现成函数且不转 list 时使用。</p>
<h3>Q3: <code>zip()</code> 的三参数版本和 <code>enumerate()</code> 有什么区别？能混合使用吗？</h3>
<p><code>zip(a, b, c)</code> 并行遍历多个序列，<code>enumerate(a)</code> 遍历单个序列并附加索引。它们<strong>可以完美混合使用</strong>——<code>for i, (x, y) in enumerate(zip(features, labels))</code>——外层 enumerate 提供 batch 编号，内层 zip 同时取出特征和标签。这是一个非常常见且推荐的模式。如果你想同时遍历三个序列并带索引：<code>for i, (a, b, c) in enumerate(zip(seq_a, seq_b, seq_c))</code>。</p>
<h3>Q4: <code>sorted()</code> 和 <code>list.sort()</code> 的核心区别在哪？</h3>
<p>三处关键区别：①<strong>返回值</strong>：<code>sorted()</code> 返回新列表，原列表不变；<code>list.sort()</code> 原地修改，返回 <code>None</code>。②<strong>适用范围</strong>：<code>sorted()</code> 适用于<strong>任何可迭代对象</strong>（列表、元组、字典、集合、字符串、生成器）；<code>list.sort()</code> 只能用于列表。③<strong>内存</strong>：<code>sorted()</code> 总是创建新列表（需要额外内存）；<code>list.sort()</code> 原地排序（更省内存但修改了原数据）。<strong>选择指南</strong>：需要保留原始数据 → <code>sorted()</code>；不需要保留且想省内存 → <code>list.sort()</code>；排序非列表数据 → 只能用 <code>sorted()</code>。</p>
<h3>Q5: Python 的 <code>round()</code> 为什么 <code>round(2.5) = 2</code> 而不是 3？</h3>
<p>这是 Python 采用的<strong>银行家舍入</strong>（Banker&#39;s Rounding）规则——精确值为 <code>x.5</code> 时，舍入到最接近的<strong>偶数</strong>。<code>round(2.5) → 2</code>（2 是偶数），<code>round(3.5) → 4</code>（4 是偶数）。这比传统的&quot;四舍五入&quot;更公平——在大量数据中不会产生系统性偏差（传统四舍五入会让平均值略偏高）。在 AI 中这通常不是问题（浮点数精度远不止 1 位），但如果你需要传统的四舍五入，可以用 <code>int(x + 0.5)</code> 或 <code>math.floor(x + 0.5)</code>。</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>enumerate</td><td>/ɪˈnjuːməreɪt/</td><td>枚举；同时获取索引和值的迭代</td></tr><tr><td>range</td><td>/reɪndʒ/</td><td>范围；生成整数等差数列</td></tr><tr><td>aggregate</td><td>/ˈæɡrɪɡeɪt/</td><td>聚合；将多个值合并为一个值</td></tr><tr><td>iterate</td><td>/ˈɪtəreɪt/</td><td>迭代；逐个遍历元素</td></tr><tr><td>lambda</td><td>/ˈlæmdə/</td><td>匿名函数；一行定义的小函数</td></tr><tr><td>zip</td><td>/zɪp/</td><td>拉链；并行配对多个可迭代对象</td></tr><tr><td>filter</td><td>/ˈfɪltər/</td><td>过滤；按条件筛选元素</td></tr><tr><td>lazy</td><td>/ˈleɪzi/</td><td>惰性；需要时才计算，不预存结果</td></tr></tbody></table></div>
<div class="quiz-raw"><h2>面试练习</h2>
<h3>Q1 [单选] <code>len({&quot;a&quot;: 1, &quot;b&quot;: 2, &quot;c&quot;: 3})</code> 的结果是？</h3>
<ul>
<li>A. 1</li><li>B. 2</li><li>C. 3</li><li>D. 6</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 正确。<code>len()</code> 对字典返回键值对的数量，这个字典有 3 个键值对（<code>&quot;a&quot;</code>、<code>&quot;b&quot;</code>、<code>&quot;c&quot;</code>），所以返回 3。</blockquote>


<h3>Q2 [单选] <code>list(range(5, 0, -1))</code> 的结果是？</h3>
<ul>
<li>A. <code>[5, 4, 3, 2, 1, 0]</code></li><li>B. <code>[5, 4, 3, 2, 1]</code></li><li>C. <code>[0, 1, 2, 3, 4, 5]</code></li><li>D. <code>[]</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。<code>range(5, 0, -1)</code> 从 5 开始，每次 -1，到 1 为止（不包括 0）。左闭右开规则对负数步长同样适用。</blockquote>


<h3>Q3 [单选] <code>for i, v in enumerate([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;], start=1):</code> 第一次循环的 i 和 v 是多少？</h3>
<ul>
<li>A. i=1, v=&quot;a&quot;</li><li>B. i=0, v=&quot;a&quot;</li><li>C. i=0, v=&quot;b&quot;</li><li>D. i=1, v=&quot;b&quot;</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A 正确。<code>start=1</code> 让索引从 1 开始，第一次循环时 <code>i=1, v=&quot;a&quot;</code>（第一个元素）。</blockquote>


<h3>Q4 [多选] 关于 <code>zip()</code>，以下说法正确的是？</h3>
<ul>
<li>A. <code>zip([1,2], [3,4])</code> 产生 <code>(1,3)</code> 和 <code>(2,4)</code></li><li>B. <code>zip()</code> 按最短的输入序列停止</li><li>C. <code>zip(*zipped)</code> 可以解压 zip 的结果</li><li>D. <code>zip()</code> 只能接受两个可迭代对象</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 正确。D 错误——<code>zip()</code> 可以接受任意数量的可迭代对象，<code>zip(a, b, c, d)</code> 都是合法的。</blockquote>


<h3>Q5 [单选] <code>sorted([3, 1, 2], reverse=True)</code> 的结果是？</h3>
<ul>
<li>A. <code>[1, 2, 3]</code></li><li>B. <code>[3, 2, 1]</code></li><li>C. <code>[3, 1, 2]</code></li><li>D. <code>None</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。<code>reverse=True</code> 表示降序排列。注意 <code>sorted()</code> 返回新列表（不同于 <code>list.sort()</code> 返回 None）。</blockquote>


<h3>Q6 [多选] 以下哪些操作是惰性求值（不立即创建完整数据结构）？</h3>
<ul>
<li>A. <code>range(1000000)</code></li><li>B. <code>map(str, [1,2,3])</code></li><li>C. <code>filter(bool, [0,1,0])</code></li><li>D. <code>zip([1,2], [3,4])</code></li><li>E. <code>list(range(10))</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C、D 都是惰性求值——返回迭代器/range对象，不占大量内存。E 错误——<code>list()</code> 强制把所有元素转为列表，立即占用内存。</blockquote>


<h3>Q7 [单选] <code>sum([1, 2, 3], 10)</code> 的结果是？</h3>
<ul>
<li>A. 6</li><li>B. 16</li><li>C. 10</li><li>D. ValueError</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。<code>sum(iterable, start=0)</code>——start 参数是初始值，所以 <code>sum([1,2,3], 10)</code> = <code>10 + 1 + 2 + 3 = 16</code>。默认 start=0。</blockquote>


<h3>Q8 [多选] 关于 <code>filter()</code> 和 <code>map()</code>，以下说法正确的是？</h3>
<ul>
<li>A. <code>filter(None, data)</code> 过滤掉&quot;假值&quot;（0, &quot;&quot;, None, False等）</li><li>B. <code>map()</code> 返回一个迭代器，需要用 <code>list()</code> 转换为列表</li><li>C. <code>map()</code> 只能接受一个可迭代对象</li><li>D. <code>filter()</code> 的 function 参数必须返回布尔值</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 正确。C 错误——<code>map()</code> 可以接受多个可迭代对象，如 <code>map(lambda a,b: a+b, [1,2], [3,4])</code>。</blockquote>


<h3>Q9 [单选] 以下哪个内置函数可以同时返回商和余数？</h3>
<ul>
<li>A. <code>divide()</code></li><li>B. <code>divmod()</code></li><li>C. <code>mod()</code></li><li>D. <code>split()</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。<code>divmod(a, b)</code> 返回 <code>(a // b, a % b)</code> 的元组——商和余数。如 <code>divmod(17, 5) → (3, 2)</code>。</blockquote>


<h3>Q10 [多选] 关于 <code>any()</code> 和 <code>all()</code>，以下说法正确的是？</h3>
<ul>
<li>A. <code>any([True, False, False])</code> 返回 True</li><li>B. <code>all([True, True, True])</code> 返回 True</li><li>C. <code>all([])</code> 返回 False</li><li>D. <code>any([])</code> 返回 False</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 正确。C 错误——奇怪但符合逻辑：<code>all([])</code> 返回 True（&quot;空集中所有元素满足条件&quot;——空真，Vacuous Truth）。<code>any([])</code> 返回 False（&quot;空集中有元素满足条件吗？&quot;——没有）。</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": 2,
    "explanation": "C 正确。`len()` 对字典返回键值对的数量，这个字典有 3 个键值对（`\"a\"`、`\"b\"`、`\"c\"`），所以返回 3。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。`range(5, 0, -1)` 从 5 开始，每次 -1，到 1 为止（不包括 0）。左闭右开规则对负数步长同样适用。"
  },
  {
    "type": "single",
    "answer": 0,
    "explanation": "A 正确。`start=1` 让索引从 1 开始，第一次循环时 `i=1, v=\"a\"`（第一个元素）。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 正确。D 错误——`zip()` 可以接受任意数量的可迭代对象，`zip(a, b, c, d)` 都是合法的。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。`reverse=True` 表示降序排列。注意 `sorted()` 返回新列表（不同于 `list.sort()` 返回 None）。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2,
      3
    ],
    "explanation": "A、B、C、D 都是惰性求值——返回迭代器/range对象，不占大量内存。E 错误——`list()` 强制把所有元素转为列表，立即占用内存。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。`sum(iterable, start=0)`——start 参数是初始值，所以 `sum([1,2,3], 10)` = `10 + 1 + 2 + 3 = 16`。默认 start=0。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 正确。C 错误——`map()` 可以接受多个可迭代对象，如 `map(lambda a,b: a+b, [1,2], [3,4])`。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。`divmod(a, b)` 返回 `(a // b, a % b)` 的元组——商和余数。如 `divmod(17, 5) → (3, 2)`。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 正确。C 错误——奇怪但符合逻辑：`all([])` 返回 True（\"空集中所有元素满足条件\"——空真，Vacuous Truth）。`any([])` 返回 False（\"空集中有元素满足条件吗？\"——没有）。"
  }
]</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>