<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <author>
    <name>Enoch</name>
  </author>
  <generator uri="https://hexo.io/">Hexo</generator>
  <id>https://cccignore.github.io/</id>
  <link href="https://cccignore.github.io/" rel="alternate"/>
  <link href="https://cccignore.github.io/atom.xml" rel="self"/>
  <rights>All rights reserved 2026, Enoch</rights>
  <subtitle>一个持续更新的中文学习博客，主要记录 Python、LeetCode、Hexo/Butterfly 博客搭建与技术学习过程。</subtitle>
  <title>Welcome to Enoch's Blog!</title>
  <updated>2026-03-18T16:20:00.000Z</updated>
  <entry>
    <author>
      <name>Enoch</name>
    </author>
    <category term="算法刷题" scheme="https://cccignore.github.io/categories/%E7%AE%97%E6%B3%95%E5%88%B7%E9%A2%98/"/>
    <category term="LeetCode Hot100" scheme="https://cccignore.github.io/categories/%E7%AE%97%E6%B3%95%E5%88%B7%E9%A2%98/LeetCode-Hot100/"/>
    <category term="Python" scheme="https://cccignore.github.io/tags/Python/"/>
    <category term="LeetCode" scheme="https://cccignore.github.io/tags/LeetCode/"/>
    <category term="Hot100" scheme="https://cccignore.github.io/tags/Hot100/"/>
    <category term="系列导航" scheme="https://cccignore.github.io/tags/%E7%B3%BB%E5%88%97%E5%AF%BC%E8%88%AA/"/>
    <content>
      <![CDATA[<p>这套 <code>LeetCode Hot100</code> 系列会按“适合长期复习”的方式来整理：首页只放这一篇导航文章，单题题解不刷首页，统一在系列内部维护。</p><span id="more"></span><h2 id="这个系列怎么读"><a href="#这个系列怎么读" class="headerlink" title="这个系列怎么读"></a>这个系列怎么读</h2><p>如果你现在和我一样：</p><ul><li>刚开始系统刷题</li><li>Python 不是完全不会，但已经有些生疏</li><li>想一边刷 Hot100，一边把语法和题型感觉捡回来</li></ul><p>那这套系列会更偏向“从入门到能复习”的写法，而不是只放一个标准答案。</p><p>每篇题解尽量都会包含：</p><ul><li>题目到底在问什么</li><li>最朴素的思路为什么成立</li><li>优化思路是怎么想到的</li><li>Python 代码逐段解释</li><li>Python Tutor 可视化截图</li><li>最后一段复盘总结</li></ul><h2 id="推荐刷题顺序"><a href="#推荐刷题顺序" class="headerlink" title="推荐刷题顺序"></a>推荐刷题顺序</h2><p>我会优先按专题推进，而不是先把所有简单题刷完。</p><p>目前比较推荐这条顺序：</p><ol><li>哈希表</li><li>双指针</li><li>滑动窗口</li><li>普通数组 &#x2F; 前缀和</li><li>栈与单调栈</li><li>二分查找</li><li>链表</li><li>二叉树遍历</li><li>回溯</li><li>堆</li><li>贪心</li><li>动态规划</li><li>图论</li></ol><h2 id="已更新文章"><a href="#已更新文章" class="headerlink" title="已更新文章"></a>已更新文章</h2><h3 id="哈希表"><a href="#哈希表" class="headerlink" title="哈希表"></a>哈希表</h3><ol><li><a href="/2026/03/18/leetcode-hot100/leetcode-hot100-01-two-sum/" title="Hot100 01 | 两数之和：从暴力枚举到哈希表">两数之和：从暴力枚举到哈希表</a></li><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-49-group-anagrams/" title="Hot100 49 | 字母异位词分组：排序 key 与计数 key">字母异位词分组：排序 key 与计数 key</a></li><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-128-longest-consecutive-sequence/" title="Hot100 128 | 最长连续序列：排序遍历与哈希集合">最长连续序列：排序遍历与哈希集合</a></li></ol><h3 id="双指针"><a href="#双指针" class="headerlink" title="双指针"></a>双指针</h3><ol><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-283-move-zeroes/" title="Hot100 283 | 移动零：额外数组到双指针原地修改">移动零：额外数组到双指针原地修改</a></li><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-11-container-with-most-water/" title="Hot100 11 | 盛最多水的容器：暴力枚举到双指针夹逼">盛最多水的容器：暴力枚举到双指针夹逼</a></li><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-15-3sum/" title="Hot100 15 | 三数之和：排序去重与双指针">三数之和：排序去重与双指针</a></li><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-42-trapping-rain-water/" title="Hot100 42 | 接雨水：按列思考到双指针收缩">接雨水：前缀最大值到双指针收缩</a></li></ol><h3 id="滑动窗口"><a href="#滑动窗口" class="headerlink" title="滑动窗口"></a>滑动窗口</h3><ol><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-03-longest-substring-without-repeating-characters/" title="Hot100 3 | 无重复字符的最长子串：从暴力到滑动窗口">无重复字符的最长子串：从暴力到滑动窗口</a></li><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-438-find-all-anagrams-in-a-string/" title="Hot100 438 | 找到字符串中所有字母异位词：定长滑动窗口">找到字符串中所有字母异位词：定长滑动窗口</a></li><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-76-minimum-window-substring/" title="Hot100 76 | 最小覆盖子串：可变长滑动窗口的代表题">最小覆盖子串：可变长滑动窗口的代表题</a></li></ol><h3 id="普通数组-前缀和"><a href="#普通数组-前缀和" class="headerlink" title="普通数组 &#x2F; 前缀和"></a>普通数组 &#x2F; 前缀和</h3><ol><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-53-maximum-subarray/" title="Hot100 53 | 最大子数组和：暴力到动态规划入门">最大子数组和：暴力到动态规划入门</a></li><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-56-merge-intervals/" title="Hot100 56 | 合并区间：排序后逐段吞并">合并区间：排序后逐段吞并</a></li><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-189-rotate-array/" title="Hot100 189 | 轮转数组：额外数组到三次反转">轮转数组：额外数组到三次反转</a></li><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-238-product-of-array-except-self/" title="Hot100 238 | 除自身以外数组的乘积：前缀积和后缀积">除自身以外数组的乘积：前缀积和后缀积</a></li><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-560-subarray-sum-equals-k/" title="Hot100 560 | 和为 K 的子数组：前缀和加哈希表">和为 K 的子数组：前缀和加哈希表</a></li></ol><h3 id="矩阵"><a href="#矩阵" class="headerlink" title="矩阵"></a>矩阵</h3><ol><li><a href="/2026/03/19/leetcode-hot100/leetcode-hot100-73-set-matrix-zeroes/" title="Hot100 73 | 矩阵置零：标记法与原地优化">矩阵置零：标记法与原地优化</a></li></ol><h2 id="完整导航页"><a href="#完整导航页" class="headerlink" title="完整导航页"></a>完整导航页</h2><p>如果想看更完整的专题清单、待更新题目和后续规划，可以进这个页面：</p><ul><li><a href="/leetcode-hot100/"><code>/leetcode-hot100/</code></a></li></ul><h2 id="说明"><a href="#说明" class="headerlink" title="说明"></a>说明</h2><ul><li>首页只保留这一篇系列导航，避免被大量单题题解刷碎</li><li>单题题解会继续发布，但默认不出现在首页</li><li>后面每完成一题，我都会回到这里补入口</li><li>文章会按专题分组，比如哈希表、双指针、滑动窗口，方便回头复习同一类题</li></ul>]]>
    </content>
    <id>https://cccignore.github.io/2026/03/19/leetcode-hot100/leetcode-hot100-index/</id>
    <link href="https://cccignore.github.io/2026/03/19/leetcode-hot100/leetcode-hot100-index/"/>
    <published>2026-03-18T16:20:00.000Z</published>
    <summary>按专题整理 LeetCode Hot100 的刷题入口与更新进度，让首页只保留一个系列导航，单题题解集中到系列内部维护</summary>
    <title>LeetCode Hot100 刷题导航（系列导航）</title>
    <updated>2026-03-18T16:20:00.000Z</updated>
  </entry>
  <entry>
    <author>
      <name>Enoch</name>
    </author>
    <category term="技术教程" scheme="https://cccignore.github.io/categories/%E6%8A%80%E6%9C%AF%E6%95%99%E7%A8%8B/"/>
    <category term="Python教程核心章节" scheme="https://cccignore.github.io/categories/%E6%8A%80%E6%9C%AF%E6%95%99%E7%A8%8B/Python%E6%95%99%E7%A8%8B%E6%A0%B8%E5%BF%83%E7%AB%A0%E8%8A%82/"/>
    <category term="教程" scheme="https://cccignore.github.io/tags/%E6%95%99%E7%A8%8B/"/>
    <category term="Python" scheme="https://cccignore.github.io/tags/Python/"/>
    <category term="学习笔记" scheme="https://cccignore.github.io/tags/%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/"/>
    <content>
      <![CDATA[<p>这套系列将原来的超长文章拆分为 5 篇，按章节顺序阅读更清晰。</p><span id="more"></span><h2 id="阅读顺序"><a href="#阅读顺序" class="headerlink" title="阅读顺序"></a>阅读顺序</h2><ol><li><a href="/2026/03/17/python-core/python-core-01-basic/" title="Python教程核心章节 01：Python基础">Python基础</a></li><li><a href="/2026/03/17/python-core/python-core-02-functions/" title="Python教程核心章节 02：函数">函数</a></li><li><a href="/2026/03/17/python-core/python-core-03-modules/" title="Python教程核心章节 03：模块">模块</a></li><li><a href="/2026/03/17/python-core/python-core-04-errors-debug-test/" title="Python教程核心章节 04：错误、调试和测试">错误、调试和测试</a></li><li><a href="/2026/03/17/python-core/python-core-05-builtin-modules/" title="Python教程核心章节 05：常用内建模块">常用内建模块</a></li></ol><h2 id="说明"><a href="#说明" class="headerlink" title="说明"></a>说明</h2><ul><li>来源：<code>https://liaoxuefeng.com/books/python/</code> 与本地 PDF <code>Python教程-廖雪峰-2025-06-16.pdf</code></li><li>提取范围：Python基础、函数、模块、错误&#x2F;调试&#x2F;测试、常用内建模块</li><li>图片沿用原教程链接，便于直接显示</li></ul>]]>
    </content>
    <id>https://cccignore.github.io/2026/03/17/python-core/python-core-index/</id>
    <link href="https://cccignore.github.io/2026/03/17/python-core/python-core-index/"/>
    <published>2026-03-17T07:59:00.000Z</published>
    <summary>将廖雪峰Python教程核心内容按章节拆分为系列文章，便于顺序阅读</summary>
    <title>Python教程核心章节整理（系列导航）</title>
    <updated>2026-03-17T07:59:00.000Z</updated>
  </entry>
  <entry>
    <author>
      <name>Enoch</name>
    </author>
    <category term="技术教程" scheme="https://cccignore.github.io/categories/%E6%8A%80%E6%9C%AF%E6%95%99%E7%A8%8B/"/>
    <category term="机器学习" scheme="https://cccignore.github.io/categories/%E6%8A%80%E6%9C%AF%E6%95%99%E7%A8%8B/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/"/>
    <category term="决策树" scheme="https://cccignore.github.io/tags/%E5%86%B3%E7%AD%96%E6%A0%91/"/>
    <category term="ID3" scheme="https://cccignore.github.io/tags/ID3/"/>
    <category term="信息增益" scheme="https://cccignore.github.io/tags/%E4%BF%A1%E6%81%AF%E5%A2%9E%E7%9B%8A/"/>
    <category term="数学" scheme="https://cccignore.github.io/tags/%E6%95%B0%E5%AD%A6/"/>
    <category term="机器学习" scheme="https://cccignore.github.io/tags/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/"/>
    <content>
      <![CDATA[<h1 id="用-ID3（信息增益）手算两道题：缺失值-连续特征"><a href="#用-ID3（信息增益）手算两道题：缺失值-连续特征" class="headerlink" title="用 ID3（信息增益）手算两道题：缺失值 + 连续特征"></a>用 ID3（信息增益）手算两道题：缺失值 + 连续特征</h1><p>这篇笔记把课堂两道练习题按 ID3 的信息增益法完整手算一遍，并把用到的公式、处理缺失值与连续特征的做法先讲清楚。熵一律用 $\log_2$。</p><hr><h2 id="0-算法与公式"><a href="#0-算法与公式" class="headerlink" title="0. 算法与公式"></a>0. 算法与公式</h2><p>数值全部保留 4 位小数；所有对数底为 2。</p><h3 id="0-1-熵（Entropy）"><a href="#0-1-熵（Entropy）" class="headerlink" title="0.1 熵（Entropy）"></a>0.1 熵（Entropy）</h3><p>二分类数据集 $S$ 中，正例比例为 $p$、反例为 $1-p$：<br>$$<br>\mathrm{Ent}(S)<br>&#x3D; -\sum_{c\in{+,-}} p_c \log_2 p_c<br>&#x3D; -p\log_2 p - (1-p)\log_2(1-p)<br>$$</p><h3 id="0-2-信息增益（Information-Gain）"><a href="#0-2-信息增益（Information-Gain）" class="headerlink" title="0.2 信息增益（Information Gain）"></a>0.2 信息增益（Information Gain）</h3><p>离散特征 $A$ 取值集合为 $\mathcal{V}$，划分后子集为 $S_v$：<br>$$<br>\begin{aligned}<br>\mathrm{Gain}(S,A)<br>&amp;&#x3D; \mathrm{Ent}(S) \<br>&amp;\quad - \sum_{v\in\mathcal{V}} \frac{|S_v|}{|S|},\mathrm{Ent}(S_v)<br>\end{aligned}<br>$$</p><h3 id="0-3-连续特征阈值"><a href="#0-3-连续特征阈值" class="headerlink" title="0.3 连续特征阈值"></a>0.3 连续特征阈值</h3><p>连续特征按数值升序，取相邻中点为候选 $\theta$。划分 $L&#x3D;{x\le\theta},R&#x3D;{x&gt;\theta}$：<br>$$<br>\begin{aligned}<br>\mathrm{Gain}(S,\theta)<br>&amp;&#x3D; \mathrm{Ent}(S) \<br>&amp;\quad - \frac{|L|}{|S|}\mathrm{Ent}(L)<br>     - \frac{|R|}{|S|}\mathrm{Ent}(R)<br>\end{aligned}<br>$$</p><h3 id="0-4-缺失值处理"><a href="#0-4-缺失值处理" class="headerlink" title="0.4 缺失值处理"></a>0.4 缺失值处理</h3><p>特征 $A$ 的缺失样本（记为“？”）<strong>不参与熵计算</strong>；但在信息增益加权时，依旧按照 $\tfrac{|S_v|}{|S|}$ 使用其在原集合中的占比。这与课堂的写法一致。</p><hr><h2 id="1-题一：离散特征-缺失值"><a href="#1-题一：离散特征-缺失值" class="headerlink" title="1) 题一：离散特征 + 缺失值"></a>1) 题一：离散特征 + 缺失值</h2><p>目标变量：是否去健身房（是&#x2F;否），共 9 条。</p><table><thead><tr><th align="right">序号</th><th>天气</th><th>是否有课</th><th>距离</th><th>是否去健身房</th></tr></thead><tbody><tr><td align="right">1</td><td>晴</td><td>有</td><td>近</td><td>是</td></tr><tr><td align="right">2</td><td>晴</td><td>无</td><td>远</td><td>否</td></tr><tr><td align="right">3</td><td>雨</td><td>?</td><td>近</td><td>是</td></tr><tr><td align="right">4</td><td>阴</td><td>有</td><td>中</td><td>否</td></tr><tr><td align="right">5</td><td>晴</td><td>无</td><td>近</td><td>是</td></tr><tr><td align="right">6</td><td>雨</td><td>无</td><td>远</td><td>否</td></tr><tr><td align="right">7</td><td>阴</td><td>?</td><td>中</td><td>是</td></tr><tr><td align="right">8</td><td>雨</td><td>有</td><td>近</td><td>是</td></tr><tr><td align="right">9</td><td>阴</td><td>无</td><td>远</td><td>否</td></tr></tbody></table><h3 id="1-0-数据集熵"><a href="#1-0-数据集熵" class="headerlink" title="1.0 数据集熵"></a>1.0 数据集熵</h3><p>总体正例 5、反例 4：<br>$$<br>\begin{aligned}<br>\mathrm{Ent}(D)<br>&amp;&#x3D; -\frac{5}{9}\log_2\frac{5}{9} - \frac{4}{9}\log_2\frac{4}{9} \<br>&amp;&#x3D; 0.9911<br>\end{aligned}<br>$$</p><h3 id="1-1-特征「是否有课」"><a href="#1-1-特征「是否有课」" class="headerlink" title="1.1 特征「是否有课」"></a>1.1 特征「是否有课」</h3><ul><li>有：${1,4,8}$（2 是 &#x2F; 1 否）<br>$$<br>\mathrm{Ent}(D_{\text{有}})<br>&#x3D; -\frac{2}{3}\log_2\frac{2}{3} - \frac{1}{3}\log_2\frac{1}{3}<br>&#x3D; 0.9183<br>$$</li><li>无：${2,5,6,9}$（1 是 &#x2F; 3 否）<br>$$<br>\mathrm{Ent}(D_{\text{无}})<br>&#x3D; -\frac{1}{4}\log_2\frac{1}{4} - \frac{3}{4}\log_2\frac{3}{4}<br>&#x3D; 0.8113<br>$$</li></ul><p>缺失样本两条忽略于熵，但加权仍按 $\tfrac{3}{9}$ 与 $\tfrac{4}{9}$：<br>$$<br>\sum_v \frac{|D_v|}{|D|}\mathrm{Ent}(D_v)<br>&#x3D; \frac{3}{9}\cdot 0.9183 + \frac{4}{9}\cdot 0.8113<br>&#x3D; 0.6667<br>$$<br>$$<br>\boxed{\mathrm{Gain}(D,\text{有课}) &#x3D; 0.9911 - 0.6667 &#x3D; 0.3244}<br>$$</p><h3 id="1-2-特征「天气」"><a href="#1-2-特征「天气」" class="headerlink" title="1.2 特征「天气」"></a>1.2 特征「天气」</h3><p>三种天气的熵完全相同：<br>$$<br>\mathrm{Ent}(D_{\text{晴}})&#x3D;\mathrm{Ent}(D_{\text{阴}})&#x3D;\mathrm{Ent}(D_{\text{雨}})&#x3D;0.9183<br>$$<br>$$<br>\sum_v \frac{|D_v|}{|D|}\mathrm{Ent}(D_v)<br>&#x3D; \frac{3}{9}\cdot 0.9183 \times 3<br>&#x3D; 0.9183<br>$$<br>$$<br>\boxed{\mathrm{Gain}(D,\text{天气}) &#x3D; 0.9911 - 0.9183 &#x3D; 0.0728}<br>$$</p><h3 id="1-3-特征「距离」"><a href="#1-3-特征「距离」" class="headerlink" title="1.3 特征「距离」"></a>1.3 特征「距离」</h3><ul><li>近：${1,3,5,8}$（4&#x2F;0）<br>$$<br>\mathrm{Ent}(D_{\text{近}})&#x3D;0<br>$$</li><li>中：${4,7}$（1&#x2F;1）<br>$$<br>\mathrm{Ent}(D_{\text{中}})&#x3D; -\tfrac{1}{2}\log_2\tfrac{1}{2}-\tfrac{1}{2}\log_2\tfrac{1}{2}&#x3D;1<br>$$</li><li>远：${2,6,9}$（0&#x2F;3）<br>$$<br>\mathrm{Ent}(D_{\text{远}})&#x3D;0<br>$$</li></ul><p>$$<br>\sum_v \frac{|D_v|}{|D|}\mathrm{Ent}(D_v)<br>&#x3D; \frac{4}{9}\cdot 0 + \frac{2}{9}\cdot 1 + \frac{3}{9}\cdot 0<br>&#x3D; 0.2222<br>$$<br>$$<br>\boxed{\mathrm{Gain}(D,\text{距离}) &#x3D; 0.9911 - 0.2222 &#x3D; 0.7689}<br>$$</p><p><strong>根节点选择</strong>：距离（信息增益最大）。</p><ul><li>距离＝近 → 纯“是” → <strong>是</strong>；</li><li>距离＝远 → 纯“否” → <strong>否</strong>；</li><li>距离＝中 → ${4:\text{否},7:\text{是}}$ 各一，可直接多数表决为“是”。</li></ul><hr><h2 id="2-题二：连续特征-离散特征"><a href="#2-题二：连续特征-离散特征" class="headerlink" title="2) 题二：连续特征 + 离散特征"></a>2) 题二：连续特征 + 离散特征</h2><p>目标变量：是否购买保险（是&#x2F;否），共 8 条。</p><table><thead><tr><th align="right">序号</th><th align="right">年龄</th><th>是否有车</th><th>购保</th></tr></thead><tbody><tr><td align="right">1</td><td align="right">25</td><td>否</td><td>否</td></tr><tr><td align="right">2</td><td align="right">30</td><td>是</td><td>是</td></tr><tr><td align="right">3</td><td align="right">35</td><td>否</td><td>否</td></tr><tr><td align="right">4</td><td align="right">40</td><td>是</td><td>是</td></tr><tr><td align="right">5</td><td align="right">45</td><td>否</td><td>是</td></tr><tr><td align="right">6</td><td align="right">50</td><td>是</td><td>是</td></tr><tr><td align="right">7</td><td align="right">55</td><td>否</td><td>是</td></tr><tr><td align="right">8</td><td align="right">60</td><td>是</td><td>是</td></tr></tbody></table><h3 id="2-0-数据集熵"><a href="#2-0-数据集熵" class="headerlink" title="2.0 数据集熵"></a>2.0 数据集熵</h3><p>总体正例 6、反例 2：<br>$$<br>\begin{aligned}<br>\mathrm{Ent}(D)<br>&amp;&#x3D; -\frac{6}{8}\log_2\frac{6}{8} - \frac{2}{8}\log_2\frac{2}{8} \<br>&amp;&#x3D; 0.8113<br>\end{aligned}<br>$$</p><h3 id="2-1-连续特征「年龄」阈值枚举"><a href="#2-1-连续特征「年龄」阈值枚举" class="headerlink" title="2.1 连续特征「年龄」阈值枚举"></a>2.1 连续特征「年龄」阈值枚举</h3><p>排序值：25, 30, 35, 40, 45, 50, 55, 60，对应候选中点<br>$\theta \in {27.5, 32.5, 37.5, 42.5, 47.5, 52.5, 57.5}$。逐一计算：</p><ol><li><p><strong>$\theta&#x3D;27.5$</strong><br>$$<br>\mathrm{Ent}(L) &#x3D; 0,\quad<br>\mathrm{Ent}(R) &#x3D; -\frac{6}{7}\log_2\frac{6}{7}-\frac{1}{7}\log_2\frac{1}{7}&#x3D;0.5917<br>$$<br>$$<br>\mathrm{Gain}(D,27.5) &#x3D; 0.8113 - \frac{1}{8}\cdot 0 - \frac{7}{8}\cdot 0.5917 &#x3D; \boxed{0.2936}<br>$$</p></li><li><p><strong>$\theta&#x3D;32.5$</strong><br>$$<br>\mathrm{Ent}(L) &#x3D; 1,\quad<br>\mathrm{Ent}(R) &#x3D; -\frac{5}{6}\log_2\frac{5}{6}-\frac{1}{6}\log_2\frac{1}{6}&#x3D;0.6500<br>$$<br>$$<br>\mathrm{Gain}(D,32.5) &#x3D; 0.8113 - \frac{2}{8}\cdot 1 - \frac{6}{8}\cdot 0.6500 &#x3D; \boxed{0.0738}<br>$$</p></li><li><p><strong>$\theta&#x3D;37.5$</strong><br>$$<br>\mathrm{Ent}(L) &#x3D; -\frac{1}{3}\log_2\frac{1}{3}-\frac{2}{3}\log_2\frac{2}{3}&#x3D;0.9183,\quad<br>\mathrm{Ent}(R) &#x3D; 0<br>$$<br>$$<br>\mathrm{Gain}(D,37.5) &#x3D; 0.8113 - \frac{3}{8}\cdot 0.9183 - \frac{5}{8}\cdot 0 &#x3D; \boxed{0.4669}<br>$$</p></li><li><p><strong>$\theta&#x3D;42.5$</strong><br>$$<br>\mathrm{Ent}(L) &#x3D; 1,\quad \mathrm{Ent}(R) &#x3D; 0<br>$$<br>$$<br>\mathrm{Gain}(D,42.5) &#x3D; 0.8113 - \frac{4}{8}\cdot 1 - \frac{4}{8}\cdot 0 &#x3D; \boxed{0.3113}<br>$$</p></li><li><p><strong>$\theta&#x3D;47.5$</strong><br>$$<br>\mathrm{Ent}(L) &#x3D; -\frac{3}{5}\log_2\frac{3}{5}-\frac{2}{5}\log_2\frac{2}{5}&#x3D;0.9710,\quad<br>\mathrm{Ent}(R) &#x3D; 0<br>$$<br>$$<br>\mathrm{Gain}(D,47.5) &#x3D; 0.8113 - \frac{5}{8}\cdot 0.9710 - \frac{3}{8}\cdot 0 &#x3D; \boxed{0.2044}<br>$$</p></li><li><p><strong>$\theta&#x3D;52.5$</strong><br>$$<br>\mathrm{Ent}(L) &#x3D; -\frac{4}{6}\log_2\frac{4}{6}-\frac{2}{6}\log_2\frac{2}{6}&#x3D;0.9183,\quad<br>\mathrm{Ent}(R) &#x3D; 0<br>$$<br>$$<br>\mathrm{Gain}(D,52.5) &#x3D; 0.8113 - \frac{6}{8}\cdot 0.9183 - \frac{2}{8}\cdot 0 &#x3D; \boxed{0.1226}<br>$$</p></li><li><p><strong>$\theta&#x3D;57.5$</strong><br>$$<br>\mathrm{Ent}(L) &#x3D; -\frac{5}{7}\log_2\frac{5}{7}-\frac{2}{7}\log_2\frac{2}{7}&#x3D;0.8631,\quad<br>\mathrm{Ent}(R) &#x3D; 0<br>$$<br>$$<br>\mathrm{Gain}(D,57.5) &#x3D; 0.8113 - \frac{7}{8}\cdot 0.8631 - \frac{1}{8}\cdot 0 &#x3D; \boxed{0.0560}<br>$$</p></li></ol><p>最大信息增益出现在 $\boxed{\theta^* &#x3D; 37.5}$（0.4669）。</p><h3 id="2-2-特征「是否有车」"><a href="#2-2-特征「是否有车」" class="headerlink" title="2.2 特征「是否有车」"></a>2.2 特征「是否有车」</h3><ul><li>有车：${2,4,6,8}$（全为“是”）<br>$$<br>\mathrm{Ent}(D_{\text{是}}) &#x3D; 0<br>$$</li><li>无车：${1,3,5,7}$（2 是 &#x2F; 2 否）<br>$$<br>\mathrm{Ent}(D_{\text{否}}) &#x3D; 1<br>$$</li></ul><p>$$<br>\sum_v \frac{|D_v|}{|D|}\mathrm{Ent}(D_v)<br>&#x3D; \frac{4}{8}\cdot 0 + \frac{4}{8}\cdot 1<br>&#x3D; 0.5<br>$$<br>$$<br>\boxed{\mathrm{Gain}(D,\text{有车}) &#x3D; 0.8113 - 0.5 &#x3D; 0.3113}<br>$$</p><p><strong>根节点选择</strong>：先按年龄 $\le 37.5$ 划分。得到的决策规则：</p><ul><li>年龄 $&gt; 37.5$ ⇒ 纯“是” ⇒ <strong>购买</strong>；</li><li>年龄 $\le 37.5$ ⇒ 再看是否有车：有车 ⇒ <strong>购买</strong>；无车 ⇒ <strong>不购买</strong>。</li></ul><hr><h2 id="3-写作与复习提示"><a href="#3-写作与复习提示" class="headerlink" title="3. 写作与复习提示"></a>3. 写作与复习提示</h2><ol><li>先写出 $\mathrm{Ent}(D)$ 的原式、代入分数，再给小数值。</li><li>每个候选划分都写出 $\mathrm{Ent}(\cdot)$ 的分式表达、加权和以及最终信息增益。</li><li>连续特征必须列出全部相邻中点阈值并逐一计算。</li><li>缺失值：熵忽略缺失样本，加权仍按总体比例。</li></ol><hr><p>公式与步骤这样展开后，复现课堂计算会更直接。如果需要决策树示意图或 PDF 版本，也可以继续完善文章。</p>]]>
    </content>
    <id>https://cccignore.github.io/2025/10/18/%E6%89%8B%E7%AE%97ID3%E4%BF%A1%E6%81%AF%E5%A2%9E%E7%9B%8A%E4%B8%A4%E9%81%93%E9%A2%98/</id>
    <link href="https://cccignore.github.io/2025/10/18/%E6%89%8B%E7%AE%97ID3%E4%BF%A1%E6%81%AF%E5%A2%9E%E7%9B%8A%E4%B8%A4%E9%81%93%E9%A2%98/"/>
    <published>2025-10-18T10:00:00.000Z</published>
    <summary>记录课堂两道 ID3 信息增益练习的完整手算过程，覆盖缺失值处理、连续特征阈值枚举和重点公式，便于复习查阅</summary>
    <title>用 ID3（信息增益）手算两道题：缺失值 + 连续特征</title>
    <updated>2025-10-18T15:59:53.824Z</updated>
  </entry>
  <entry>
    <author>
      <name>Enoch</name>
    </author>
    <category term="生活分享" scheme="https://cccignore.github.io/categories/%E7%94%9F%E6%B4%BB%E5%88%86%E4%BA%AB/"/>
    <category term="音乐推荐" scheme="https://cccignore.github.io/categories/%E7%94%9F%E6%B4%BB%E5%88%86%E4%BA%AB/%E9%9F%B3%E4%B9%90%E6%8E%A8%E8%8D%90/"/>
    <category term="中文说唱" scheme="https://cccignore.github.io/tags/%E4%B8%AD%E6%96%87%E8%AF%B4%E5%94%B1/"/>
    <category term="音乐分享" scheme="https://cccignore.github.io/tags/%E9%9F%B3%E4%B9%90%E5%88%86%E4%BA%AB/"/>
    <content>
      <![CDATA[<span id="more"></span><h2 id="一、华云龙-KLE"><a href="#一、华云龙-KLE" class="headerlink" title="一、华云龙 KLE"></a>一、华云龙 KLE</h2><h3 id="1-《山东王-Freestyle》"><a href="#1-《山东王-Freestyle》" class="headerlink" title="1.《山东王 Freestyle》"></a>1.《山东王 Freestyle》</h3><div class="responsive-video-container">  <iframe src="//player.bilibili.com/player.html?isOutside=true&aid=114555233502643&bvid=BV1W1JxzjEsb&cid=30102981707&autoplay=0" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"></iframe></div><h3 id="2-《枣庄一夜》"><a href="#2-《枣庄一夜》" class="headerlink" title="2. 《枣庄一夜》"></a>2. 《枣庄一夜》</h3><div class="responsive-video-container">  <iframe src="//player.bilibili.com/player.html?isOutside=true&aid=114552364603849&bvid=BV1tvJWzLEnz&cid=30097542322&autoplay=0" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"></iframe></div><h3 id="3-《底层特律》"><a href="#3-《底层特律》" class="headerlink" title="3. 《底层特律》"></a>3. 《底层特律》</h3><div class="responsive-video-container">  <iframe src="//player.bilibili.com/player.html?isOutside=true&aid=114773303758582&bvid=BV17GgCz8Eje&cid=30782062758&autoplay=0" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"></iframe></div><h3 id="4-《天下谁人不识君》"><a href="#4-《天下谁人不识君》" class="headerlink" title="4. 《天下谁人不识君》"></a>4. 《天下谁人不识君》</h3><div class="responsive-video-container">  <iframe src="//player.bilibili.com/player.html?isOutside=true&aid=114556374358811&bvid=BV1xPjEznEs1&cid=30107372564&autoplay=0" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"></iframe></div><h2 id="二、Echo-王耍大"><a href="#二、Echo-王耍大" class="headerlink" title="二、Echo 王耍大"></a>二、Echo 王耍大</h2><h3 id="1-《关关难》"><a href="#1-《关关难》" class="headerlink" title="1.《关关难》"></a>1.《关关难》</h3><div class="responsive-video-container">  <iframe src="//player.bilibili.com/player.html?isOutside=true&aid=1655951844&bvid=BV1yE421N7X8&cid=1596560981&autoplay=0" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"></iframe></div><h3 id="2-《不可能》"><a href="#2-《不可能》" class="headerlink" title="2.《不可能》"></a>2.《不可能》</h3><div class="responsive-video-container">  <iframe src="//player.bilibili.com/player.html?isOutside=true&aid=112987973092210&bvid=BV1gipmePETt&cid=500001654700975&autoplay=0" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"></iframe></div><h3 id="3-《害哈（feat-派克特）》"><a href="#3-《害哈（feat-派克特）》" class="headerlink" title="3.《害哈（feat.派克特）》"></a>3.《害哈（feat.派克特）》</h3><div class="responsive-video-container">  <iframe src="//player.bilibili.com/player.html?isOutside=true&aid=1305141680&bvid=BV1GM4m1r7Z3&cid=1557873619&autoplay=0" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"></iframe></div><h2 id="三、艾志恒-Asen"><a href="#三、艾志恒-Asen" class="headerlink" title="三、艾志恒 Asen"></a>三、艾志恒 Asen</h2><h3 id="1-《芳草地》"><a href="#1-《芳草地》" class="headerlink" title="1.《芳草地》"></a>1.《芳草地》</h3><div class="responsive-video-container">  <iframe src="//player.bilibili.com/player.html?isOutside=true&aid=297561078&bvid=BV13F411W77U&cid=561421791&autoplay=0" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"></iframe></div><h3 id="2-《Money-Focused-Freestyle》"><a href="#2-《Money-Focused-Freestyle》" class="headerlink" title="2.《Money Focused Freestyle》"></a>2.《Money Focused Freestyle》</h3><div class="responsive-video-container">  <iframe src="//player.bilibili.com/player.html?isOutside=true&aid=261042014&bvid=BV1pe411T75x&cid=847540630&autoplay=0" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"></iframe></div>]]>
    </content>
    <id>https://cccignore.github.io/2025/09/27/%E6%9C%80%E8%BF%91%E5%9C%A8%E5%90%AC%E7%9A%84%E4%B8%AD%E6%96%87%E8%AF%B4%E5%94%B1%E5%88%86%E4%BA%AB/</id>
    <link href="https://cccignore.github.io/2025/09/27/%E6%9C%80%E8%BF%91%E5%9C%A8%E5%90%AC%E7%9A%84%E4%B8%AD%E6%96%87%E8%AF%B4%E5%94%B1%E5%88%86%E4%BA%AB/"/>
    <published>2025-09-27T11:31:35.000Z</published>
    <summary>分享最近常听</summary>
    <title>中文说唱分享（PART I）</title>
    <updated>2025-09-27T11:31:35.000Z</updated>
  </entry>
  <entry>
    <author>
      <name>Enoch</name>
    </author>
    <category term="技术教程" scheme="https://cccignore.github.io/categories/%E6%8A%80%E6%9C%AF%E6%95%99%E7%A8%8B/"/>
    <category term="网络配置" scheme="https://cccignore.github.io/categories/%E6%8A%80%E6%9C%AF%E6%95%99%E7%A8%8B/%E7%BD%91%E7%BB%9C%E9%85%8D%E7%BD%AE/"/>
    <category term="Clash" scheme="https://cccignore.github.io/tags/Clash/"/>
    <category term="SSH" scheme="https://cccignore.github.io/tags/SSH/"/>
    <category term="Linux" scheme="https://cccignore.github.io/tags/Linux/"/>
    <category term="代理" scheme="https://cccignore.github.io/tags/%E4%BB%A3%E7%90%86/"/>
    <category term="教程" scheme="https://cccignore.github.io/tags/%E6%95%99%E7%A8%8B/"/>
    <content>
      <![CDATA[<h1 id="🧭-一步一步：让远程服务器通过本地-Clash-科学上网-复制认证文件"><a href="#🧭-一步一步：让远程服务器通过本地-Clash-科学上网-复制认证文件" class="headerlink" title="🧭 一步一步：让远程服务器通过本地 Clash 科学上网 + 复制认证文件"></a>🧭 一步一步：让远程服务器通过本地 Clash 科学上网 + 复制认证文件</h1><blockquote><p>适用于任何 Ubuntu &#x2F; Debian &#x2F; 其他 Linux 服务器，通过本地 Clash 代理实现科学上网，同时完成 <code>.codex/auth.json</code> 等认证文件的复制。</p></blockquote><h2 id="0️⃣-前置准备：确认本地代理正常"><a href="#0️⃣-前置准备：确认本地代理正常" class="headerlink" title="0️⃣ 前置准备：确认本地代理正常"></a>0️⃣ 前置准备：确认本地代理正常</h2><p>先确保你本地的 Clash 能联网。在<strong>本地电脑终端</strong>执行：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">curl -x http://127.0.0.1:7897 -I https://www.google.com</span><br></pre></td></tr></table></figure><p>若返回 <code>HTTP/2 200</code> 或 <code>301 / 308</code>，说明代理可用 ✅</p><blockquote><p>Clash 默认端口：</p><ul><li>HTTP(S)：7897</li><li>SOCKS5：7898<br>可在 Clash Dashboard 查看端口。</li></ul></blockquote><h2 id="1️⃣-建立-SSH-反向代理隧道"><a href="#1️⃣-建立-SSH-反向代理隧道" class="headerlink" title="1️⃣ 建立 SSH 反向代理隧道"></a>1️⃣ 建立 SSH 反向代理隧道</h2><p>关键步骤：让远程服务器“反向”访问你本地的代理。在<strong>本地电脑</strong>执行：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">ssh -p &lt;服务器端口&gt; \</span><br><span class="line">    -R 7897:127.0.0.1:7897 \</span><br><span class="line">    -o ServerAliveInterval=60 \</span><br><span class="line">    root@&lt;服务器地址&gt;</span><br></pre></td></tr></table></figure><p>示例：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">ssh -p 30065 -R 7897:127.0.0.1:7897 -o ServerAliveInterval=60 root@connect.westc.gpuhub.com</span><br></pre></td></tr></table></figure><table><thead><tr><th>参数</th><th>含义</th></tr></thead><tbody><tr><td><code>-R 7897:127.0.0.1:7897</code></td><td>把远程的 127.0.0.1:7897 转发到本地 Clash 代理端口</td></tr><tr><td><code>ServerAliveInterval=60</code></td><td>每 60 秒发一次心跳，防止断连</td></tr><tr><td><code>-p</code></td><td>SSH 端口号</td></tr></tbody></table><blockquote><p>保持此连接不要断，它就是“桥梁”。如果想后台运行，可配合 <code>autossh</code> 实现自动重连。</p></blockquote><h2 id="2️⃣-在远程服务器上设置代理环境变量"><a href="#2️⃣-在远程服务器上设置代理环境变量" class="headerlink" title="2️⃣ 在远程服务器上设置代理环境变量"></a>2️⃣ 在远程服务器上设置代理环境变量</h2><h3 id="2-1-临时设置（当前会话生效）"><a href="#2-1-临时设置（当前会话生效）" class="headerlink" title="2.1 临时设置（当前会话生效）"></a>2.1 临时设置（当前会话生效）</h3><p>在远程终端执行：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">export</span> http_proxy=<span class="string">&quot;http://127.0.0.1:7897&quot;</span></span><br><span class="line"><span class="built_in">export</span> https_proxy=<span class="string">&quot;http://127.0.0.1:7897&quot;</span></span><br><span class="line"><span class="built_in">export</span> no_proxy=<span class="string">&quot;localhost,127.0.0.1,.local&quot;</span></span><br></pre></td></tr></table></figure><p>测试：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">curl -I https://chat.openai.com</span><br><span class="line">curl -I https://www.google.com</span><br></pre></td></tr></table></figure><p>如返回 200 &#x2F; 30x 响应，即代理生效 ✅</p><h3 id="2-2-永久生效（登录自动加载）"><a href="#2-2-永久生效（登录自动加载）" class="headerlink" title="2.2 永久生效（登录自动加载）"></a>2.2 永久生效（登录自动加载）</h3><p>将上述环境变量追加到 shell 配置文件。</p><h4 id="bash"><a href="#bash" class="headerlink" title="bash"></a>bash</h4><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">echo</span> <span class="string">&#x27;export http_proxy=&quot;http://127.0.0.1:7897&quot;&#x27;</span> &gt;&gt; ~/.bashrc</span><br><span class="line"><span class="built_in">echo</span> <span class="string">&#x27;export https_proxy=&quot;http://127.0.0.1:7897&quot;&#x27;</span> &gt;&gt; ~/.bashrc</span><br><span class="line"><span class="built_in">echo</span> <span class="string">&#x27;export no_proxy=&quot;localhost,127.0.0.1,.local&quot;&#x27;</span> &gt;&gt; ~/.bashrc</span><br><span class="line"><span class="built_in">source</span> ~/.bashrc</span><br></pre></td></tr></table></figure><h4 id="zsh"><a href="#zsh" class="headerlink" title="zsh"></a>zsh</h4><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">echo</span> <span class="string">&#x27;export http_proxy=&quot;http://127.0.0.1:7897&quot;&#x27;</span> &gt;&gt; ~/.zshrc</span><br><span class="line"><span class="built_in">echo</span> <span class="string">&#x27;export https_proxy=&quot;http://127.0.0.1:7897&quot;&#x27;</span> &gt;&gt; ~/.zshrc</span><br><span class="line"><span class="built_in">echo</span> <span class="string">&#x27;export no_proxy=&quot;localhost,127.0.0.1,.local&quot;&#x27;</span> &gt;&gt; ~/.zshrc</span><br><span class="line"><span class="built_in">source</span> ~/.zshrc</span><br></pre></td></tr></table></figure><h2 id="3️⃣-测试代理是否生效"><a href="#3️⃣-测试代理是否生效" class="headerlink" title="3️⃣ 测试代理是否生效"></a>3️⃣ 测试代理是否生效</h2><p>在远程服务器执行：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">curl -I https://www.google.com</span><br><span class="line">curl -I https://chat.openai.com</span><br></pre></td></tr></table></figure><p>若输出包含 <code>HTTP/1.1 200 Connection established</code> 或 <code>HTTP/2 200</code>，说明代理成功。</p><p>其他命令测试示例：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">pip install requests</span><br><span class="line">apt update</span><br><span class="line">git <span class="built_in">clone</span> https://github.com/openai/openai-cookbook.git</span><br></pre></td></tr></table></figure><h2 id="4️⃣-复制-codex-auth-json（或其他认证文件）"><a href="#4️⃣-复制-codex-auth-json（或其他认证文件）" class="headerlink" title="4️⃣ 复制 .codex/auth.json（或其他认证文件）"></a>4️⃣ 复制 <code>.codex/auth.json</code>（或其他认证文件）</h2><p>若远程服务器需要访问 ChatGPT &#x2F; Codex 等服务，需要同步认证文件。</p><p>假设本机路径为 <code>~/.codex/auth.json</code>：</p><h3 id="拷贝整个-codex-文件夹"><a href="#拷贝整个-codex-文件夹" class="headerlink" title="拷贝整个 .codex 文件夹"></a>拷贝整个 <code>.codex</code> 文件夹</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">scp -P &lt;服务器端口&gt; -r ~/.codex root@&lt;服务器地址&gt;:~</span><br></pre></td></tr></table></figure><p>示例：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">scp -P 30065 -r ~/.codex root@connect.westc.gpuhub.com:~</span><br></pre></td></tr></table></figure><h3 id="或仅拷贝-auth-json"><a href="#或仅拷贝-auth-json" class="headerlink" title="或仅拷贝 auth.json"></a>或仅拷贝 <code>auth.json</code></h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">ssh -p &lt;服务器端口&gt; root@&lt;服务器地址&gt; <span class="string">&quot;mkdir -p ~/.codex&quot;</span></span><br><span class="line">scp -P &lt;服务器端口&gt; ~/.codex/auth.json root@&lt;服务器地址&gt;:~/.codex/</span><br></pre></td></tr></table></figure><h3 id="远程服务器确认"><a href="#远程服务器确认" class="headerlink" title="远程服务器确认"></a>远程服务器确认</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">ls</span> -la ~/.codex</span><br><span class="line"><span class="built_in">chmod</span> 700 ~/.codex</span><br><span class="line"><span class="built_in">chmod</span> 600 ~/.codex/auth.json</span><br></pre></td></tr></table></figure><h2 id="5️⃣-VS-Code-Remote-SSH-自动化配置（推荐）"><a href="#5️⃣-VS-Code-Remote-SSH-自动化配置（推荐）" class="headerlink" title="5️⃣ VS Code Remote SSH 自动化配置（推荐）"></a>5️⃣ VS Code Remote SSH 自动化配置（推荐）</h2><p>在本地编辑 <code>~/.ssh/config</code>：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">nano ~/.ssh/config</span><br></pre></td></tr></table></figure><p>添加配置：</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">Host myserver</span><br><span class="line">    HostName &lt;服务器地址&gt;</span><br><span class="line">    Port &lt;端口号&gt;</span><br><span class="line">    User root</span><br><span class="line">    RemoteForward 7897 127.0.0.1:7897</span><br><span class="line">    ServerAliveInterval 60</span><br></pre></td></tr></table></figure><p>示例：</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">Host gpuhub-westc</span><br><span class="line">    HostName connect.westc.gpuhub.com</span><br><span class="line">    Port 30065</span><br><span class="line">    User root</span><br><span class="line">    RemoteForward 7897 127.0.0.1:7897</span><br><span class="line">    ServerAliveInterval 60</span><br></pre></td></tr></table></figure><p>之后在 VS Code 选择 <code>gpuhub-westc</code> 连接即可自动建立代理隧道。</p><h2 id="6️⃣-验证代理端口监听状态"><a href="#6️⃣-验证代理端口监听状态" class="headerlink" title="6️⃣ 验证代理端口监听状态"></a>6️⃣ 验证代理端口监听状态</h2><p>在远程执行：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">ss -lnpt | grep 7897</span><br><span class="line"><span class="comment"># 或</span></span><br><span class="line">netstat -lnpt 2&gt;/dev/null | grep 7897</span><br></pre></td></tr></table></figure><p>出现如下输出代表 SSH 已成功建立反向转发：</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">LISTEN  0  128 127.0.0.1:7897  *:*  users:((&quot;sshd&quot;,pid=xxx,fd=3))</span><br></pre></td></tr></table></figure><h2 id="7️⃣-常见问题排查"><a href="#7️⃣-常见问题排查" class="headerlink" title="7️⃣ 常见问题排查"></a>7️⃣ 常见问题排查</h2><table><thead><tr><th>问题</th><th>原因</th><th>解决方案</th></tr></thead><tbody><tr><td><code>Connection refused</code></td><td>本地 Clash 未运行或端口不匹配</td><td>检查本地代理状态与端口号</td></tr><tr><td><code>curl</code> 卡住或超时</td><td>SSH 隧道断开</td><td>保持连接或使用 <code>autossh</code> 自动重连</td></tr><tr><td><code>.codex</code> 权限错误</td><td>认证文件权限过宽被拒</td><td>执行 <code>chmod 600 ~/.codex/auth.json</code></td></tr><tr><td><code>apt</code> &#x2F; <code>git</code> &#x2F; <code>pip</code> 仍不走代理</td><td>未继承环境变量</td><td>在各自配置文件中单独设置代理</td></tr></tbody></table><h2 id="8️⃣-一键命令模板（通用换主机）"><a href="#8️⃣-一键命令模板（通用换主机）" class="headerlink" title="8️⃣ 一键命令模板（通用换主机）"></a>8️⃣ 一键命令模板（通用换主机）</h2><p>替换以下变量即可复用：</p><ul><li><code>PORT</code> → SSH 端口</li><li><code>HOST</code> → 服务器地址</li></ul><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 本地建立隧道</span></span><br><span class="line">ssh -p PORT -R 7897:127.0.0.1:7897 -o ServerAliveInterval=60 root@HOST</span><br><span class="line"></span><br><span class="line"><span class="comment"># 远程设置环境变量</span></span><br><span class="line"><span class="built_in">echo</span> <span class="string">&#x27;export http_proxy=&quot;http://127.0.0.1:7897&quot;&#x27;</span> &gt;&gt; ~/.bashrc</span><br><span class="line"><span class="built_in">echo</span> <span class="string">&#x27;export https_proxy=&quot;http://127.0.0.1:7897&quot;&#x27;</span> &gt;&gt; ~/.bashrc</span><br><span class="line"><span class="built_in">echo</span> <span class="string">&#x27;export no_proxy=&quot;localhost,127.0.0.1,.local&quot;&#x27;</span> &gt;&gt; ~/.bashrc</span><br><span class="line"><span class="built_in">source</span> ~/.bashrc</span><br><span class="line"></span><br><span class="line"><span class="comment"># 拷贝认证</span></span><br><span class="line">scp -P PORT -r ~/.codex root@HOST:~</span><br></pre></td></tr></table></figure><hr><p>🎉 完成！你现在拥有：</p><ul><li>远程服务器的网络流量走本地 Clash 代理</li><li><code>.codex/auth.json</code> 等认证文件安全同步</li><li>VS Code Remote SSH 自动转发配置</li><li>可快速迁移到任意新服务器的标准流程</li></ul><p>随时换服务器、换端口、换账号，只需跟着本文操作即可。</p>]]>
    </content>
    <id>https://cccignore.github.io/2025/06/21/%E8%BF%9C%E7%A8%8B%20SSH%20%E4%BD%BF%E7%94%A8%20Codex%EF%BC%9A%E8%BD%AC%E5%8F%91%E6%9C%AC%E5%9C%B0%20Clash%20%E4%BB%A3%E7%90%86%E5%88%B0%E6%9C%8D%E5%8A%A1%E5%99%A8/</id>
    <link href="https://cccignore.github.io/2025/06/21/%E8%BF%9C%E7%A8%8B%20SSH%20%E4%BD%BF%E7%94%A8%20Codex%EF%BC%9A%E8%BD%AC%E5%8F%91%E6%9C%AC%E5%9C%B0%20Clash%20%E4%BB%A3%E7%90%86%E5%88%B0%E6%9C%8D%E5%8A%A1%E5%99%A8/"/>
    <published>2025-06-21T04:00:00.000Z</published>
    <summary>详解将本地 Clash 代理转发至远程服务器，以便在 Remote SSH 会话中顺利使用 Codex 插件和其他联网工具的完整流程</summary>
    <title>远程 SSH 使用 Codex：转发本地 Clash 代理到服务器</title>
    <updated>2025-10-18T07:32:23.737Z</updated>
  </entry>
  <entry>
    <author>
      <name>Enoch</name>
    </author>
    <category term="Python数据分析" scheme="https://cccignore.github.io/categories/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90/"/>
    <category term="判断题" scheme="https://cccignore.github.io/categories/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90/%E5%88%A4%E6%96%AD%E9%A2%98/"/>
    <category term="考试复习" scheme="https://cccignore.github.io/tags/%E8%80%83%E8%AF%95%E5%A4%8D%E4%B9%A0/"/>
    <content>
      <![CDATA[<!-- 文章摘要，会显示在首页 --><span id="more"></span><h2 id="第二章：Python语言基础与环境-第三章：Pandas-数据结构与操作"><a href="#第二章：Python语言基础与环境-第三章：Pandas-数据结构与操作" class="headerlink" title="第二章：Python语言基础与环境 + 第三章：Pandas 数据结构与操作"></a>第二章：Python语言基础与环境 + 第三章：Pandas 数据结构与操作</h2><p><strong>1. 元组中的元素只能是同一数据类型 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** Python 的元组和列表都可以包含不同数据类型的元素，是异构容器。例如 `(1, "hello", 3.14)` 是合法的。</details><hr><p><strong>2. 可以用<code>a=&#123;&#125;</code>创建空的集合 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 使用 `{}` 创建的是一个空的<b>字典</b>。要创建空集合，必须使用 `set()` 构造函数。</details><hr><p><strong>3. 在Python中，运行代码<code>&#39;5&#39;+5</code>，会生成字符串’55’（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 字符串和整数之间不能直接使用 `+` 运算符，会引发 `TypeError`。</details><hr><p><strong>4. 语句<code>20==20.0</code>返回结果是True （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `==` 运算符比较的是值。整数 `20` 和浮点数 `20.0` 的数值相等。</details><hr><p><strong>5. 可以将列表作为字典的键 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 字典的键必须是不可变（hashable）的对象。列表是可变的，因此不能作为键。</details><hr><p><strong>6. 所有写在“&#x2F;&#x2F;”号之后的文本会自动被Python解释器忽略 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** Python 的单行注释符号是 `#`。`//` 是整除运算符。</details><hr><p><strong>7. 列表中的pop方法可以返回特定位置的元素但是remove不可以（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `.pop(index)` 会移除并返回指定索引的元素。`.remove(value)` 移除指定值，但返回 `None`。</details><hr><p><strong>8. 通过<code>isinstance(a, (int, str))</code>可以检测变量a的类型是否在int, str中 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 `isinstance` 函数的标准用法，其第二个参数可以是一个类型元组。</details><hr><p><strong>9. 列表、字典、Numpy数组都是可变(mutable)对象 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这三者都允许在创建后修改其内部的元素或内容。</details><hr><p><strong>10. <code>tup=(1,[1,2,3],3); tup[1].append(4)</code>不能执行（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 元组本身是不可变的，但其内部的可变元素（如列表）是可以被修改的。</details><hr><p><strong>11. <code>&#39;5&#39;+&#39;3&#39;</code>的结果是’8’（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 字符串使用 `+` 运算符会进行拼接，结果是字符串 `'53'`。</details><hr><p><strong>12. 对于对象<code>a=[1,2,3]</code>和<code>b=[1,2,3]</code>，<code>a is b</code>和<code>a==b</code>输出的结果都为True （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `a == b` (值相等) 是 `True`，但 `a is b` (身份标识不同) 是 `False`，因为它们是两个独立的对象。</details><hr><p><strong>13. <code>d=&#123;&#125;; d[tuple([1, 2, 3])] = 5</code>语句不能执行（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 元组是不可变的，可以作为字典的键，该语句合法。</details><hr><p><strong>14. 函数柯里化的过程中，如果传入的参数数量不足，剩下的参数将默认为空值传入（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 它会返回一个等待接收剩余参数的新函数。</details><hr><p><strong>15. 运行以下代码，<code>4 &gt; 3 &gt; 2 &gt; 1</code>，将返回True（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** Python 支持链式比较，该表达式等价于 `(4 > 3) and (3 > 2) and (2 > 1)`。</details><hr><p><strong>16. 下列这句代码是对的：<code>test_data = 1,</code> （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 结尾的逗号会使 Python 将其解释为一个单元素元组 `(1,)`。</details><hr><p><strong>17. Python中不可以使用java中表示语句块的“{}”，以及分隔符“；” （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** Python 不使用 `{}` 表示语句块，但可以使用分号 `;` 在同一行分隔多个语句。</details><hr><p><strong>18. <code>(4,None,&#39;foo&#39;)+(6,0)+(&#39;bar&#39;)</code>不能执行 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `('bar')` 只是一个带括号的字符串，不是元组。元组和字符串不能相加，会引发 `TypeError`。正确的单元素元组应写为 `('bar',)`。</details><hr><p><strong>19. 设<code>a = ’python’</code>,可以执行<code>a[0]=‘P’</code> ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 字符串是不可变对象，不能通过索引赋值来修改内容。</details><hr><p><strong>20. <code>None</code>是<code>NoneType</code>类型的唯一实例 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 `None` 的正确定义。</details><hr><p><strong>21. 像Java语言一样，Python语句也是以分号结尾的 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** Python 语句以换行符作为默认的终止符。</details><hr><p><strong>22. 对于含有换行的多行字符串，可以使用三个单引号’’’或者三个双引号””” （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 Python 定义多行字符串的标准语法。</details><hr><p><strong>23. 表达式<code>“[3] in [1, 2, 3, 4]”</code>的值是True.（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `in` 运算符检查的是元素。列表 `[1, 2, 3, 4]` 包含整数 `3`，但不包含列表 `[3]`。</details><hr><p><strong>24. <code>def choise(x,y,z=5): choise(5,z= 2,y = 3)</code> 可以调用 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `5` 作为位置参数赋给了 `x`，`y=3` 和 `z=2` 作为关键字参数赋值。所有参数都得到了明确且无冲突的赋值。</details><hr><p><strong>25. <code>num1=num2=num3=20</code> 在内存中指向不同的变量地址（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 链式赋值使 `num1`, `num2`, `num3` 都指向内存中同一个存放整数 `20` 的对象。</details><hr><p><strong>26. 使用<code>pop( )</code>方法删除列表中某一元素后，该元素从栈顶被推出且无法再访问。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `pop()` 方法会<b>返回</b>被删除的那个元素，可以将其赋值给变量以备后续使用。</details><hr><p><strong>27. 在Python中可以使用 id 作为变量名 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `id` 是一个内置函数，但不是关键字。因此可以作为变量名，但这会覆盖内置函数，是不推荐的做法。</details><hr><p><strong>28. 列表的插入函数<code>insert()</code>指定的序号可以大于数组长度。 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 如果 `index` 大于列表长度，`insert()` 会将元素插入到列表的末尾，效果等同于 `append()`。</details><hr><p><strong>29. List中的<code>remove()</code>函数会移除列表中指定的所有的元素。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `.remove(value)` 只会移除列表中<b>第一个</b>匹配到的 `value`。</details><hr><p><strong>30. 用 <code>sort</code> 函数可以产生一个排好序的序列副本。 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 列表的 `.sort()` **方法**是原地排序，返回 `None`。而内置的 `sorted()` **函数**才会产生一个排好序的副本。</details><hr><p><strong>31. <code>tup1=(1,2,3,4,5)；a , b , *rest = tup1；type(rest)</code>；结果为 <code>tuple</code> 。 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 在解包赋值中，带星号的 `*rest` 会将所有剩余的元素打包成一个<b>列表 (list)</b>。</details><hr><p><strong>32. <code>set([2,[2,3,4]])</code>的输出结果是<code>&#123;2,[2,3,4]&#125;</code>。 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 集合的元素必须是可哈希的。列表 `[2,3,4]` 是可变的，不能放入集合中，会引发 `TypeError`。</details><hr><p><strong>33. <code>type((1))</code>和<code>type(())</code>的输出都是<code>tuple</code> （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `type(())` 是 `tuple`，但 `(1)` 只是一个带括号的整数，`type((1))` 是 `int`。</details><hr><p><strong>34. 已经<code>a=[1,2,3,4,5]</code>, <code>b=[6,7,8,9]</code>,则<code>a.append(b)</code>的输出结果是<code>[1,2,3,4,5,6,7,8,9]</code> ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `.append(b)` 会将整个列表 `b` 作为一个<b>单一元素</b>添加到 `a` 的末尾，结果是 `[1,2,3,4,5, [6,7,8,9]]`。应使用 `.extend(b)` 或 `a + b` 来拼接。</details><h2 id="第四章：NumPy-数组与操作"><a href="#第四章：NumPy-数组与操作" class="headerlink" title="第四章：NumPy 数组与操作"></a>第四章：NumPy 数组与操作</h2><p><strong>1. <code>ndarray</code>包含的每一个元素均为相同类型。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 NumPy 数组（`ndarray`）的核心特性之一。它是一个同构数据容器，所有元素必须是相同的数据类型（如 `int64`, `float64` 等），这使得 NumPy 能够进行高效的批量运算。（旧版专门测试过是可以异构，但新版已经只能同构。所以答案是T）</details><hr><p><strong>2. <code>import numpy as np, arr=np.arange(10), arr.astype(float), print(arr)</code>，输出结果为<code>[0 1 2 3 4 5 6 7 8 9]</code>。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `arr.astype(float)` 方法会返回一个<b>新的</b>、数据类型为浮点数的数组副本，它并<b>不会原地修改</b> `arr` 本身。因此，`print(arr)` 打印的仍然是原始的整数数组。</details><hr><p><strong>3. 嵌套序列能被转换为多维数组（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `np.array()` 函数可以将嵌套的列表或元组（如 `[[1,2],[3,4]]`）转换为多维 NumPy 数组。</details><hr><p><strong>4. NumPy中的<code>random</code>函数中的<code>randn()</code>可以产生N(0,1)的数（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `np.random.randn()` 函数用于生成服从标准正态分布（均值为0，方差为1，即 N(0,1)）的随机数。</details><hr><p><strong>5. 使用<code>np.unique</code>函数可以对NumPy数组进行去重。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `np.unique(arr)` 会找出数组 `arr` 中的唯一元素，并返回一个已排序的新数组。</details><hr><p><strong>6. 两个大小相等数组之间的算术运算，都是“点对点”的运算。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 NumPy 的核心特性，也称为元素级 (element-wise) 运算。数组间的算术运算会作用于对应位置的元素。</details><hr><p><strong>7. 可以通过numpy中的<code>astype</code>方法显式地转换数组的数据类型。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `arr.astype(new_dtype)` 是转换 NumPy 数组数据类型的标准方法。</details><hr><p><strong>8. <code>np.arange()</code>是python内建函数的<code>range</code>的数组版（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `np.arange()` 的功能与 `range()` 类似，但它返回的是一个 NumPy 数组，而不是一个迭代器，并且它支持浮点数步长。</details><hr><p><strong>9. <code>arr.mean(1)</code>计算的是每一列的平均值，<code>arr.sum(0)</code>计算行轴向的累和（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** <ul><li>`axis=1` 表示沿着<b>行</b>的方向进行计算，因此 `arr.mean(1)` 计算的是每一<b>行</b>的平均值。</li><li>`axis=0` 表示沿着<b>列</b>的方向进行计算，因此 `arr.sum(0)` 计算的是每一<b>列</b>的和。</li></ul></details><hr><p><strong>10. 数组的切片就是将原数组的数据复制，对切片的修改不会影响原数组（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** NumPy 数组的切片返回的是原始数组的<b>视图 (view)</b>，而不是副本。对切片（视图）的修改会直接影响到原始数组。</details><hr><p><strong>11. 数组生成函数<code>array</code>将输入数据转化为<code>ndarray</code>，默认复制所有的输入数据.（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `np.array()` 函数默认会创建一个输入数据的副本，除非输入本身就是一个 `ndarray` 且 `copy=False`。</details><hr><p><strong>12. 运用<code>arr.ndim</code>可以查看数组<code>arr</code>的秩。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `.ndim` 属性返回数组的维度数，即秩 (rank)。</details><hr><p><strong>13. 同尺寸数组之间直接的比较会产生一个布尔值。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 数组间的比较是元素级的，会产生一个与原数组形状相同的<b>布尔数组</b>，而不是单个布尔值。</details><hr><p><strong>14. <code>data=np.random.randn(2,3)</code>，则<code>data.ndim</code>的输出结果是3（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `np.random.randn(2, 3)` 创建的是一个 2 行 3 列的<b>二维数组</b>。因此，其维度数 `.ndim` 是 2。</details><hr><p><strong>15. NumPy中的<code>zeros</code>方法和<code>empty</code>方法本质是一样的，都是创建一个全0的数组 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `np.zeros()` 创建并初始化一个全为 0 的数组。`np.empty()` 只分配内存空间，不进行初始化，其内容是内存中残留的“垃圾值”，是不确定的。</details><hr><p><strong>16. <code>np.sort</code>方法对数组按位置进行排序。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析**： `np.sort()` 是一个函数，它返回一个排好序的数组<b>副本</b>，不改变原数组。对数组进行原地排序的是 `.sort()` **方法**。</details><hr><p><strong>17. 用NumPy数组对象的<code>reshape</code>方法变换维度时会改变原数组。 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `.reshape()` 方法返回一个具有新形状的<b>视图</b>，如果可能的话。它不会改变原始数组的形状。</details><hr><p><strong>18. <code>bool = np.array(...)</code>，则<code>(bool&gt;0).any()</code>返回True。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 在数值比较中，`True` 被当作 1，`False` 被当作 0。`bool>0` 会产生一个布尔数组，其中原为 `True` 的位置现在也是 `True`。因为结果中至少有一个 `True`，所以 `.any()` 返回 `True`。</details><hr><p><strong>19. 使用布尔值索引选择数据时，生成的是数据的视图 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 布尔索引和花式索引（整数数组索引）总是返回数据的<b>副本</b>，而不是视图。</details><hr><p><strong>20. 多维Numpy数组的修改元素操作可使用tuple，例如<code>arr2d[(0,0)]=0</code>。 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 使用元组 (tuple) 来指定多维数组中元素的位置是 NumPy 的标准索引方式。`arr2d[(0,0)]`（通常简写为 `arr2d[0,0]`）会精确地选中第 0 行第 0 列的元素，并可以对其进行赋值修改。</details><hr><p><strong>21. 对一个array数组进行reshape操作，作用对象的数组形状会发生改变。( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 此题与第17题类似。`.reshape()` 返回一个新形状的视图或副本，原始数组的形状不变。</details><hr><p><strong>22. 下面代码会报错。<code>arr=[1,2,3];np.sqrt(arr,arr)</code>( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `np.sqrt(arr, out=arr)` 的第二个参数是输出位置。但 `arr` 是一个 Python 列表，而不是 NumPy 数组。NumPy 的 ufunc (如 `np.sqrt`) 通常不能直接将结果写回 Python 列表。即便 `arr` 是 NumPy 数组，如果它是整数类型，将浮点数结果写回整数数组也会导致类型错误。</details><hr><p><strong>23. numpy的方法<code>dot</code>和<code>*</code>计算方式没有差别。( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `*` 是元素级乘法。`np.dot()` 是矩阵乘法（或向量内积）。两者计算方式和结果完全不同。</details><hr><p><strong>24. numpy的<code>mean()</code>函数只能对一维数组使用( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `mean()` 函数可以对任意维度的数组使用，并且可以通过 `axis` 参数指定沿哪个轴计算均值。</details><hr><p><strong>25. 如果<code>a.shape=（2，3，4）</code>，那么<code>a.mean(1).shape=（2，3）</code>( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `a.mean(1)` (或 `axis=1`) 会沿着第 1 轴进行聚合，该轴会被“压缩”掉。原形状 `(2,3,4)`，去掉第 1 轴后，结果形状应为 `(2,4)`。</details><hr><p><strong>26. 输入<code>np.empty(10)</code>的结果为：<code>array([0., 0., ..., 0.])</code> ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `np.empty()` 只分配内存，不初始化。其内容是内存中的“垃圾值”，是不确定的，通常不是全0。</details><hr><p><strong>27. 随机数生成器中的随机数种子相同可以产生不同的随机数组。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 设置相同的随机数种子 (`np.random.seed(...)`) 会保证后续生成的随机数序列是完全相同、可复现的。</details><hr><p><strong>28. 对Numpy 数组切片的修改并会影响原数组。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 此题与第10题类似。NumPy 数组的切片是视图，修改切片就是修改原始数组的对应部分。</details><hr><p><strong>29. 一个数组对象的<code>itemsize</code>，返回的值是由数组的大小决定的（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `.itemsize` 返回的是数组中<b>单个元素</b>占用的字节数，它由数组的<b>数据类型 (`dtype`)</b> 决定，与数组的大小（元素总数 `.size`）无关。</details><hr><p><strong>30. 已知<code>x=np.array([3,5,1,9,6,3])</code>,那么表达式<code>np.argmax(x)</code>的值为3（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `np.argmax()` 返回数组中最大值的<b>第一个</b>出现位置的索引。数组中的最大值是 9，其索引为 3。</details><hr><p><strong>31. <code>ar = np.arange(9).reshape(3,3)</code>；<code>ar[:2,0]</code> 会生成一维数组（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `ar[:2, 0]` 中，列索引是单个整数 `0`，这会导致降维。结果是选择了前两行的第 0 列元素，形成一个一维数组 `[0, 3]`。</details><hr><p><strong>32. <code>x=np.array([[0,1,2,3,4],[,5,6,7,8]])；x.shape</code>。输出结果是（2，5）（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 代码 `[,5,6,7,8]` 中，第一个逗号前缺少一个值，这是<b>语法错误 (SyntaxError)</b>，代码无法运行。</details><hr><p><strong>33. <code>arr=[4,-1,9,16];np.sqrt(arr);arr</code> 以上代码输出的结果为<code>array([2,nan,3,4])</code> ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `np.sqrt(arr)` 会返回一个新的计算结果数组，但不会修改原始的 Python 列表 `arr`。所以最后打印 `arr` 仍然是 `[4, -1, 9, 16]`。</details><hr><p><strong>34. 与列表不同，数组中要求所有元素的dtype是一样的，如果传入的参数类型和数组类型不一样，需要按照已有的类型进行转换。( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是对 NumPy 数组同构性和类型转换的准确描述。例如，向一个整数数组的某个位置赋浮点数，该浮点数会被截断为整数。</details><hr><p><strong>35. <code>np.zeros()</code>生成的矩阵元素属性是Int ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `np.zeros()` 默认生成的元素类型是<b>浮点数 (`float64`)</b>。要生成整数，需要明确指定 `dtype`，如 `np.zeros(..., dtype=int)`。</details><h2 id="第五章：Pandas-核心功能"><a href="#第五章：Pandas-核心功能" class="headerlink" title="第五章：Pandas 核心功能"></a>第五章：Pandas 核心功能</h2><p><strong>1. <code>pd.isnull(frame)</code>与<code>pd.notnull(frame)</code>方法可以判断DataFrame对象frame中的元素是否缺失，返回布尔值DataFrame。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这两个函数（或等价的 `.isnull()` 和 `.notnull()` 方法）都会返回一个与原始 DataFrame 形状相同的布尔型 DataFrame，用于标识每个元素是否为缺失值。</details><hr><p><strong>2. 针对DataFrame在行上的标签索引<code>iloc</code>是左闭右开区间,<code>loc</code>是左闭右闭区间。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 这个叙述是<b>错误</b>的。`.iloc` 是基于<b>整数位置</b>的索引，它是“左闭右开”的。`.loc` 是基于<b>标签</b>的索引，它是“左闭右闭”的。题目中将 `iloc` 描述为“标签索引”是错误的。</details><hr><p><strong>3. 在DataFrame中，当A是有效的Python变量名时，<code>frame[‘A’]</code>与<code>frame.A</code>返回的结果是相同的（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 Pandas 中两种访问列的方式。字典式 `frame['A']` 总是有效，而属性式 `frame.A` 只有在列名是有效 Python 标识符时才有效。当两者都有效时，返回结果相同。</details><hr><p><strong>4. pandas中的Series数据结构可以认为是一个长度固定且有序的字典（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** Series 将一个值序列和一个索引序列对应起来，这在概念上与有序字典（从Python 3.7+开始，字典默认有序）非常相似，其中索引是键，值是值。</details><hr><p><strong>5. <code>pandas.to_datetime(date).year</code>可以实现从时间序列（data）中提取年份（ ）</strong></p><details>  <summary style-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `pd.to_datetime()` 返回的是 `Timestamp` 或 `DatetimeIndex`。要从这些对象中提取年份，需要使用 `.dt` 访问器（对于 Series）或直接访问 `.year` 属性（对于单个 Timestamp）。正确的写法应为 `pd.to_datetime(data).year` (对于单个值) 或 `pd.to_datetime(data).dt.year` (对于Series)。</details><hr><p><strong>6. 设有<code>s = pd.Series(np.arange(3))</code>，则<code>s.loc[:1]</code>，<code>s.iloc[:2]</code>，<code>s[:2]</code>输出的结果不一样（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `s` 的索引是 `[0, 1, 2]`。  <ul>    <li>`s.loc[:1]`：标签切片，左闭右闭，选择标签 0 和 1。</li>    <li>`s.iloc[:2]`：位置切片，左闭右开，选择位置 0 和 1。</li>    <li>`s[:2]`：标准的 Series 切片，当索引为整数时，行为与位置切片相同，选择位置 0 和 1。</li>  </ul>  这三者输出的结果都是相同的。</details><hr><p><strong>7. 从DataFrame中选取的列是数据的视图，而不是拷贝。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 通常情况下，使用 `df['col_name']` 这种方式选择单列返回的是原始 DataFrame 的视图。对这个视图进行修改会影响原始 DataFrame，并可能触发 `SettingWithCopyWarning`。</details><hr><p><strong>8. <code>df1 = ...</code> 其中<code>df1.iloc[2:1]=8</code> （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **解析：** 此题缺失判断。但 `df1.iloc[2:1]` 是一个空的切片（起始位置在结束位置之后），对空切片赋值不会修改 DataFrame，也不会报错。</details><hr><p><strong>9. 包含Series的字典可以用于构造DataFrame（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是创建 DataFrame 的一种常见且有效的方式。字典的键会成为列名，Series 的值成为列数据，Pandas 会自动对齐 Series 的索引。</details><hr><p><strong>10. <code>obj = pd.Series(...)</code>, <code>obj.sort_values()</code>，此操作会将obj中所有的缺失值都放到它的尾部。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `.sort_values()` 方法的 `na_position` 参数默认为 `'last'`，即缺失值 (`NaN`) 会被放在排序结果的末尾。</details><hr><p><strong>11. 如果嵌套字典被赋值给DataFrame，pandas会将字典的键作为列，内部字典的键作为行索引（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 `pd.DataFrame()` 处理嵌套字典的标准行为，例如 `pd.DataFrame({'col1': {'row1': 1}})`。</details><hr><p><strong>12. <code>pd.DataFrame(np.arange(9).reshape((3,3))))</code>可以建立3列3行的DataFrame。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `np.arange(9).reshape((3,3))` 创建一个 3x3 的 NumPy 数组，`pd.DataFrame()` 可以直接接受这个二维数组来创建一个 3x3 的 DataFrame。</details><hr><p><strong>13. 将Series赋值给DataFrame的一列时，Series的索引会按照DataFrame的索引重新排列，并在空缺的地方填充缺失值。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 Pandas 的核心特性之一：自动对齐索引。赋值时，Pandas 会根据 DataFrame 的行索引来匹配 Series 的索引，如果某个 DataFrame 索引在 Series 中找不到，对应位置就会被填充为 `NaN`。</details><hr><p><strong>14. 在pandas中，通过<code>isnull</code>和<code>notnull</code>函数检查缺失数据，返回的结果是一样的（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `isnull()` 和 `notnull()` 的功能正好相反。`isnull()` 在缺失值位置返回 `True`，而 `notnull()` 在非缺失值位置返回 `True`。</details><hr><p><strong>15. <code>ser=pd.Series(np.arange(3.))</code>，<code>ser.loc[:1]</code>和<code>ser.iloc[:1]</code>的结果是一样的（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `ser` 的索引是 `[0, 1, 2]`。  <ul>    <li>`ser.loc[:1]`：标签切片，左闭右闭，选择标签 0 和 1。结果包含两个元素。</li>    <li>`ser.iloc[:1]`：位置切片，左闭右开，只选择位置 0。结果包含一个元素。</li>  </ul>  两者结果不同。</details><hr><p><strong>16. <code>[&#39;c&#39;:&#39;d&#39;]</code>是无效的索引 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 对于 Pandas 的 Series 或 DataFrame，如果其索引是字符串标签，那么 `['c':'d']` 这种形式的<b>标签切片</b>是完全有效的。</details><hr><p><strong>17. 对DataFrame中选取的列进行修改不会映射到DataFrame中。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 选取的列通常是视图，对其进行修改<b>会</b>映射回原始的 DataFrame。</details><hr><p><strong>18. DataFrame的 <code>values</code>属性会把包含在DataFrame中的数据以NumPy数组的形式返回（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析**：这是 `.values` 属性（在新版中推荐使用 `.to_numpy()`）的标准功能。</details><hr><p><strong>19. 对于索引值为<code>[‘a’,’b’]</code>的Series对象obj，可以使用<code>obj[1]</code>获取值 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当 Series 的索引是非整数类型时，整数索引会被明确地解释为<b>位置索引</b>。`obj[1]` 会获取第二个元素。</details><hr><p><strong>20. <code>4 in pd.Series([4,7,-5,3])</code>返回的结果是True。 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `in` 运算符对于 Series 检查的是<b>索引</b>，而不是值。由于该 Series 的索引是 `[0, 1, 2, 3]`，不包含 `4`，所以返回 `False`。要检查值，应使用 `4 in series.values`。</details><hr><p><strong>21. <code>obj=...;</code>对于<code>obj</code>的切片，<code>obj[&quot;b&quot;:&quot;c&quot;]</code>,其输出值为 <code>b 1.0</code>。( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 标签切片 `obj["b":"c"]` 是“左闭右闭”的，会包含标签 `'b'` 和 `'c'` 的所有行。结果应为 `'b': 1.0, 'c': 2.0`。</details><hr><p><strong>22. 已知<code>obj2 = ...</code>，输入<code>obj2[&#39;a&#39;:&#39;f&#39;]</code>，会正确执行。 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `obj2` 的索引 `['d', 'b', 'a', 'c']` 是无序的。对无序索引进行标签切片，Pandas 无法确定 `'a'` 和 `'f'` 之间的范围，会引发 `KeyError`。</details><hr><p><strong>23. <code>states = (&#39;California&#39;, ...)</code>和<code>states = [&#39;California&#39;, ...]</code>都可以执行的。( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 第一条语句创建元组，第二条创建列表，都是合法的 Python 语法。</details><hr><p><strong>24. 从DataFrame中选取的列是数据的拷贝，而不是视图。( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 此题与第7题类似。选取的列通常是视图。</details><hr><p><strong>25. Series中的索引值可以重复；DataFrame每列内需是相同的值类型。( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这两个都是 Pandas 数据结构的基本特性。</details><hr><p><strong>26. <code>a1</code>是一个Series，<code>a2</code>是一个DataFrame，他们都属于Pandas，但是<code>a1.values</code>和<code>a2.values</code>返回的数据类型不一样( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 两者的 `.values` 属性都返回一个 NumPy `ndarray` 对象。区别在于维度，`a1.values` 是一维的，`a2.values` 是二维的，但它们的类型都是 `numpy.ndarray`。</details><hr><p><strong>27. 对pandas对象进行切片时：按Label索引进行切片…（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这个叙述准确地总结了 Pandas 切片的三条规则。</details><hr><p><strong>28. <code>del</code>在DataFrame中只能够删除列不能够删除行。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** Python 的 `del` 关键字与 Pandas 结合使用时，`del df['col']` 是删除列的有效语法。但没有 `del df[row_index]` 这种删除行的语法，删除行必须使用 `.drop()` 方法。</details><hr><p><strong>29. 已知有一个DataFrame对象，可以直接用切片索引它的行列（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `df[...]` 这种直接切片操作是针对<b>行</b>的。要同时索引行和列，必须使用 `.loc` 或 `.iloc` 索引器，如 `df.loc[row_slice, col_slice]`。</details><h2 id="第六章：数据输入输出与接口"><a href="#第六章：数据输入输出与接口" class="headerlink" title="第六章：数据输入输出与接口"></a>第六章：数据输入输出与接口</h2><p><strong>1. 用pandas读取文件时不指定列名时，会报错（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 不指定列名时，Pandas 的 `read_csv` 等函数会默认将文件的<b>第一行</b>作为列名。如果文件没有列名行，可以设置 `header=None`，Pandas 会自动生成整数列名。</details><hr><p><strong>2. <code>pd.read_csv(&#39;examples/ex2.csv&#39;, header=0)</code>，<code>header = 0</code>表示取文件中的第一行作为列名。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `header` 参数指定用作列名的行号，索引从 0 开始。`header=0` 明确表示使用文件的第一行作为列名，这也是 `read_csv` 的默认行为。</details><hr><p><strong>3. 使用<code>read_csv</code>方法读取文件时，可以通过指定<code>chunksize</code>进行分块读入文件( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `chunksize` 参数用于处理大文件，它会返回一个 `TextFileReader` 对象，可以通过迭代该对象来逐块读取数据。</details><hr><p><strong>4. csv产生的数据都是字符串类型的，它不会做任何其它类型的转换（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `read_csv` 会自动进行类型推断，尝试将列转换为数值类型（如 `int64`, `float64`）或日期时间类型。</details><hr><p><strong>5. 使用<code>json.loads</code>方法可以将JSON字符串转化为python形式，使用<code>json.dumps</code>可以将python对象转化为JSON。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `json.loads` (load string) 用于反序列化，`json.dumps` (dump string) 用于序列化。</details><hr><p><strong>6. DataFrame中的<code>to_csv</code>方法只能导出逗号分隔的文件（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `to_csv` 方法可以通过 `sep` 参数指定任意分隔符，例如 `sep='\t'` 可以导出制表符分隔的文件。</details><hr><p><strong>7. JSON对象中的键可以是int形式（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 根据 JSON 规范，对象的键 (key) 必须是<b>字符串</b>。虽然 Python 字典的键可以是整数，但在序列化为标准 JSON 格式时，这些整数键会被转换为字符串。</details><hr><p><strong>8. 当要读入的文件没有列名时，可以设置关键字<code>header=None</code>（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `header=None` 明确告诉 Pandas 文件没有列名行，应将所有行都作为数据读取，并自动生成整数列名。</details><hr><p><strong>9. 读取的字段由多种不同数量的空格分开时，我们可以通过向<code>sep</code>传入正则表达式来进行读取（ )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当分隔符不固定时，可以使用正则表达式。例如，`sep='\s+'` 可以匹配一个或多个空格作为分隔符。</details><hr><p><strong>10. CSV文件在写入的时候<code>data1=data.to_csv(...)</code>，其中<code>sep</code>参数用于制定分隔符（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `to_csv` 的 `sep` 参数用于指定输出文件中的字段分隔符。</details><hr><p><strong>11. 使用<code>read_csv()</code>函数必须从头开始逐行读取（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 可以通过 `skiprows` 参数跳过文件开头的任意行，或通过 `skipfooter` 跳过结尾的行。</details><hr><p><strong>12. 将pandas数据写入到Excel格式中必须直接调用<code>ExcelWriter</code>（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 最简单的方式是使用 DataFrame 的 `.to_excel()` 方法。只有当需要向同一个 Excel 文件的多个工作表中写入数据时，才需要显式地使用 `ExcelWriter`。</details><hr><p><strong>13. pandas中的函数<code>read_html</code>在默认的情况下会解析一个html页面中的所有标签，返回的结果是DataFrame对象的列表 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `pd.read_html()` 会尝试在 HTML 页面中找到所有 `<table>` 标签，并将每个表格都解析成一个 DataFrame，最后将这些 DataFrame 放在一个列表中返回。</details><hr><p><strong>14. 语句<code>options.display.max_rows</code>可以调整pandas的最大显示行数，设置显示最开始的行数.( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `pd.options.display.max_rows` 设置的是当 DataFrame 行数超过该值时，Pandas 如何<b>截断显示</b>（例如，显示头尾几行）。它设置的是<b>总的显示行数阈值</b>，而不是只显示最开始的行数。要只看最开始的几行，应使用 `.head(n)` 方法。</details><hr><p><strong>15. 使用<code>read_csv()</code>方法读入文件的时候，默认的分隔符是”,”。 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `read_csv` 的 "csv" 就代表 "Comma-Separated Values"，其 `sep` 参数默认值为 `','`。</details><hr><p><strong>16. <code>na_values</code>可以接受一组用于表示缺失值的字符串 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `na_values` 参数可以接受一个列表或集合，其中包含所有需要在读取时被转换成 `NaN` 的字符串。</details><hr><p><strong>17. 在字典中，每列不可以指定不同的缺失值标识。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 可以向 `na_values` 传入一个字典，其中键是列名，值是该列特定的缺失值标识。例如 `na_values={'col_A': ['missing'], 'col_B': [-1]}`。</details><hr><p><strong>18. 当要读入的文件没有列名时，可以设置关键字<code>header=None</code> （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 此题与第 8 题相同，叙述正确。</details><hr><p><strong>19. 使用<code>read_table</code>方法读取文件时，可以传入<code>seq</code>参数指定分隔符 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 指定分隔符的参数是 `sep` 或 `delimiter`，不是 `seq`。</details><hr><p><strong>20. <code>pd.read_csv(&#39;test.csv&#39;,skiprows=1)</code>没有语法错误。( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `skiprows=1` 是 `read_csv` 的有效用法，表示跳过文件开头的 1 行。</details><hr><p><strong>21. 在<code>read_csv</code>的参数中，<code>skiprows</code>传入的行号必须为列表形式( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `skiprows` 既可以是一个整数（表示从文件开头跳过 N 行），也可以是一个行号列表。</details><hr><p><strong>22. 读入文件时，行和列的标签不可以禁止写入。( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 在使用 `.to_csv()` 等写入方法时，可以通过设置 `header=False` 来禁止写入列标签，通过设置 `index=False` 来禁止写入行标签。</details><hr><p><strong>23. 当读取的txt文件中列名的数量比数据的列数少一个，因此<code>read_table</code>推断第一列应当作为DataFrame的索引。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 Pandas 解析器的一个智能推断行为。当发现列标题行比数据行的字段数少一个时，它会假定第一列没有标题，并将其用作行索引。</details><hr><p><strong>24. <code>panda.read_json</code>只能自动将JSON数据集按指定次序转换为Series（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `pd.read_json` 默认会将 JSON 对象或数组转换为 **DataFrame**。只有在特定格式或设置下才会转换为 Series。</details><hr><p><strong>25. <code>...nrows=5</code> 和 <code>...chunker.get_chunk(5)</code> 输出结果一样( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `nrows=5` 直接读取文件的前 5 行数据。`chunker = ...chunksize=1000` 创建一个迭代器，`chunker.get_chunk(5)` 从这个迭代器中获取一个大小为 5 行的块。两者都会得到包含文件前 5 行数据的 DataFrame。</details><hr><p><strong>26. 使用<code>read_table</code>函数时，可以使用一个正则表达式作为分隔符。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `read_table` 和 `read_csv` 的 `sep` 参数都支持正则表达式。</details><hr><p><strong>27. <code>read_csv</code>中的参数<code>header</code>默认为<code>None</code> （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `header` 的默认值是 `0`，表示将文件的第一行作为列名。</details><hr><p><strong>28. 为了分块读入文件，可以使用<code>chunksize</code>作为每一块的行数 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 此题与第 3 题类似，叙述正确。</details><hr><p><strong>29. HDF不是事务数据库，它最适合用作”一次写多次读“的数据集 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** HDF5 (Hierarchical Data Format) 是一种文件格式，不是数据库。它为高效读写大量科学数据而设计，非常适合“一次写，多次读” (WORM) 的场景。</details><hr><p><strong>30. <code>Pd.read_csv()</code>方法中，参数<code>header</code>和<code>names</code>同时设置最终以<code>names</code>作为基准设置列标签 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当 `names` 被指定时，它会覆盖 `header` 的作用。`header` 参数此时只用来告诉 Pandas 文件中的哪一行是旧的列名行，以便可以跳过它。</details><hr><p><strong>31. 当要读入的文件没有列名时，可以设置关键字<code>header=0</code> （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `header=0` 是默认行为，它会把文件的<b>第一行当作列名</b>。如果文件没有列名，这样做会导致第一行数据被错误地用作列名。正确的做法是设置 `header=None`。</details><h2 id="第七章：数据清洗与转换"><a href="#第七章：数据清洗与转换" class="headerlink" title="第七章：数据清洗与转换"></a>第七章：数据清洗与转换</h2><p><strong>1. 使用<code>cut</code>方法需要制定具体的边界。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `pd.cut()` 不仅可以接受一个具体的边界列表作为 `bins` 参数，也可以接受一个<b>整数</b>，`cut` 会自动根据数据的最大最小值将范围等分成指定数量的等宽区间。</details><hr><p><strong>2. <code>data = pd.Series(...)</code>，<code>data.str.replace(&#39;a&#39;,&#39;d&#39;)</code>其中9会被处理为Nan （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `.str` 访问器下的方法（如 `.replace`）是为字符串设计的。当 Series 中包含非字符串类型的值（如整数 `9`）时，这些方法在这些值上的操作结果是 `NaN`。</details><hr><p><strong>3. 默认情况下，<code>fillna</code>方法可以传入指定值来补全缺失值，从而修改了原对象（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `fillna()` 方法默认 `inplace=False`，它会返回一个填充了缺失值的新对象，而<b>不修改</b>原始对象。</details><hr><p><strong>4. 在删除dataframe的某一行时,设置关键词<code>inplace=True</code>可以覆盖原有的数据。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 在 Pandas 的许多方法中（如 `.drop()`, `.fillna()` 等），设置 `inplace=True` 会使操作直接在原始对象上生效，并返回 `None`。</details><hr><p><strong>5. 对于DataFrame对象，<code>dropna</code>在默认情况下会删除所有值均为NA的行（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `dropna()` 的 `how` 参数默认为 `'any'`，这意味着它会删除<b>任何包含</b> `NaN` 的行，而不是只删除所有值均为 `NaN` 的行。</details><hr><p><strong>6. <code>data.dropna(how=&#39;all&#39;)</code>可以删除data中所有包含NA的行（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `how='all'` 表示只删除那些<b>所有值都为 `NaN`</b> 的行/列，而不是所有包含 `NaN` 的行/列。</details><hr><p><strong>7. <code>map</code>和<code>replace</code>都可以用于修改一个对象中的子集的值（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `map` 可以通过字典对 Series 中的每个元素进行映射替换。`replace` 也可以通过字典或列表来替换对象中的一个或多个值。两者都可以用于修改值的子集。</details><hr><p><strong>8. 处理缺失数据时可以用<code>dropna()</code>方法直接过滤缺失值（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `dropna()` 的核心功能就是删除（过滤掉）含有缺失值的行或列。</details><hr><p><strong>9. Data为Series类型，操作<code>data[data.notnull()]</code>与<code>data.dropna()</code>是等价的。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `data.notnull()` 返回一个布尔 Series，其中非缺失值位置为 `True`。使用这个布尔 Series 进行索引，会筛选出所有非缺失值。这与 `.dropna()`（默认删除所有含 `NaN` 的行）的效果是完全等价的。</details><hr><p><strong>10. 使用pandas的<code>cut</code>操作返回的是一个DataFrame对象。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `pd.cut()` 返回的是一个特殊的 **Categorical** 对象，它本质上像一个 Series，其值是表示区间的 `Interval` 对象。</details><hr><p><strong>11. pandas的索引中不可以包含重复标签（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 与 Python 集合不同，Pandas 的 Index 对象<b>可以</b>包含重复的标签。</details><hr><p><strong>12. Python中<code>in</code>关键字、<code>index</code>方法、<code>find</code>方法都可以检查子字符串（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `in` 返回布尔值，`index` 和 `find` 返回索引位置（或在找不到时报错/返回-1），但它们都可以用来检查子字符串是否存在。</details><hr><p><strong>13. <code>fillna()</code>方法可以传入字典，实现对不同列的缺失值用不同的值进行填充（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是一个 `fillna` 的常用功能。例如 `df.fillna({'col_A': 0, 'col_B': 'missing'})`。</details><hr><p><strong>14. DataFrame中的列索引是自动从1开始的（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 如果不指定，DataFrame 的行索引和列索引都是自动从 <b>0</b> 开始的整数索引。</details><hr><p><strong>15. pandas中如果我们不为Series对象指定索引，程序会报错（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 如果不指定索引，Pandas 会自动创建一个从 0 开始的整数 `RangeIndex`。</details><hr><p><strong>16. NA和NaN的意思都是一样的 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 在 Pandas 的语境中，NA (Not Available) 是表示缺失数据的通用概念，而 `NaN` (Not a Number) 是其在数值类型（特别是浮点数）中的具体实现。它们通常可以互换使用来指代缺失值。</details><hr><p><strong>17. <code>data.index[0]=&#39;aaa&#39;</code>可以将data中第0行的索引变为<code>aaa</code> （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** Pandas 的 Index 对象是<b>不可变的 (immutable)</b>，不能通过索引赋值来修改其内容。这会引发 `TypeError`。</details><hr><p><strong>18. 通过<code>index</code>方法查找指定字符的位置，如果字符不存在会返回-1。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 字符串的 `.index()` 方法如果找不到子字符串，会<b>引发 `ValueError`</b>。返回 -1 的是 `.find()` 方法。</details><hr><p><strong>19. <code>drop_duplicates</code>函数删除重复行，默认保留第一个观测到的值。 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `drop_duplicates` 的 `keep` 参数默认为 `'first'`。</details><hr><p><strong>20. 对于存放数值型数据的DataFrame对象，调用<code>describe</code>方法可以返回各个列的统计数据 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `.describe()` 默认会对 DataFrame 中所有数值类型的列计算描述性统计。</details><hr><p><strong>21. Python内建的<code>None</code>值在对象数组中也被当作NA处理。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** Pandas 会将 `None` 识别为缺失值。在 `object` 类型的数组中，它会保持为 `None`，但在 `isnull()` 等函数中会被当作 `NA`。如果数组是数值类型，`None` 会被强制转换为 `NaN`。</details><hr><p><strong>22. 使用<code>rename</code>方法对DataFrame对象<code>df</code>进行重命名将会返回一个新的对象。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `.rename()` 方法默认 `inplace=False`，返回一个重命名了索引或列的新 DataFrame 对象。</details><hr><p><strong>23. pandas中用<code>cut</code>函数进行分箱得到的分组区间只能是前开后闭（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `cut` 默认是左开右闭 `(a, b]`，但可以通过设置 `right=False` 来实现左闭右开 `[a, b)`。</details><hr><p><strong>24. pandas中的<code>cut</code>函数可以通过传入参数实现两端均封闭。( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 可以通过 `include_lowest=True` 参数来确保第一个区间的左边界是封闭的。例如，`pd.cut(data, bins=[0,1,2], include_lowest=True)` 会产生 `[-0.001, 1.0]` 和 `(1.0, 2.0]`。</details><hr><p><strong>25. 在DataFrame对象中，使用<code>fillna</code>来补全缺失值时，返回的是一个新对象。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 此题与第3题类似。`fillna` 默认 `inplace=False`，返回新对象。</details><hr><p><strong>26. <code>dropna</code> 默认情况下会删除包含缺失值的列。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `dropna` 的 `axis` 参数默认为 `0`，即默认删除包含缺失值的<b>行</b>。</details><hr><p><strong>27. 语句<code>np.sign(data)</code>根据数据中的值的正负分别生成0和1的值 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `np.sign()` 会返回：正数 -> `1`，负数 -> `-1`，零 -> `0`。</details><hr><p><strong>28. <code>dropna()</code>函数的<code>axis</code>和<code>how</code>参数的默认值分别为0，<code>any</code>( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `axis` 默认为 0 (行)，`how` 默认为 'any' (任何一个 `NaN` 就删除)。</details><hr><p><strong>29. <code>fillna</code>方法的参数可以传入字典为不同列设置不同的填充值 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 此题与第13题类似，叙述正确。</details><h2 id="第八章：数据合并与重塑"><a href="#第八章：数据合并与重塑" class="headerlink" title="第八章：数据合并与重塑"></a>第八章：数据合并与重塑</h2><p><strong>1. 默认情况下，<code>concat</code>方法是沿着<code>axis=0</code>的轴向生效的（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `pd.concat` 的 `axis` 参数默认为 `0`，表示沿行方向进行拼接（垂直堆叠）。</details><hr><p><strong>2. NumPy中的<code>concatenate</code>函数默认情况下是进行横向拼接（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `np.concatenate` 的 `axis` 参数默认为 `0`，表示沿第一个轴（行方向）进行拼接（垂直堆叠），而不是横向拼接（`axis=1`）。</details><hr><p><strong>3. <code>merge</code>函数会在没有指定连接键的情况下，自动将重叠列名作为连接的键（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 如果不通过 `on`, `left_on`, `right_on` 等参数指定连接键，`pd.merge` 会自动使用两个 DataFrame 中共有的列名作为连接键。</details><hr><p><strong>4. 如果不是所有的级别值都能在各分组中找到，则<code>unstack</code>操作会引入缺失数据（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `unstack` 在将索引层级旋转到列时，如果某个新的行列组合在原始数据中不存在，该位置就会用 `NaN` 填充。</details><hr><p><strong>5. <code>swaplevel</code>接收两个层级序号或名称，将原对象的层级进行变更。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `swaplevel` 会返回一个层级交换后的<b>新对象</b>，而<b>不改变</b>原对象。</details><hr><p><strong>6. 分层索引中“内部层级”是不可以选择的 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 可以通过多种方式选择内部层级，例如使用元组 `df.loc[('outer_key', 'inner_key')]`，或者通过 `.xs()` 方法。</details><hr><p><strong>7. 在DataFrame中拆堆时，被拆堆的层级会变为结果中最低（level最大）的层级（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `unstack` 会将指定的行索引层级移动到列索引中，并成为新的列索引层级中的最内层（即最低层级）。</details><hr><p><strong>8. DataFrame的<code>join</code>方法，能更为方便地实现按索引合并…但要求没有重叠的列（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `.join()` 是一个方便的按索引连接的方法。如果两个 DataFrame 有重叠的列名，`join` 会引发 `ValueError`，除非你使用 `lsuffix` 或 `rsuffix` 参数来区分它们。</details><hr><p><strong>9. 一个分层索引的Series对象使用<code>unstack</code>方法会修改原对象（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `unstack` 会返回一个重塑后的新对象（通常是 DataFrame），不修改原始的 Series。</details><hr><p><strong>10. 使用<code>merge</code>函数进行列-列连接时，传递的DataFrame索引对象会被丢弃。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当 `merge` 基于列进行连接时，默认情况下，结果会生成一个新的从 0 开始的整数索引，原始的行索引会被丢弃。</details><hr><p><strong>11. 在使用<code>pandas.melt</code>的时候，需要指明作为分组目标的列（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `pd.melt` 需要指明的是作为<b>标识符变量</b>的列（通过 `id_vars` 参数），而不是分组目标。未在 `id_vars` 中指定的列会被“融合”到 `variable` 和 `value` 两列中。</details><hr><p><strong>12. <code>combine_first</code>可用于拼接重复数据，用一个对象中的值填充另一个对象中的缺失值（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是对 `combine_first` 功能的准确描述。它会用调用对象（第二个对象）的值来“修补”或“填充”第一个对象中的 `NaN` 值。</details><hr><p><strong>13. 在数据透视表中，加入<code>margins=False</code>,可以在下方显示一些总和数据。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 要显示总计（小计），需要设置 <b>`margins=True`</b>。`margins=False` 是默认行为，不显示总计。</details><hr><p><strong>14. 以列表（或者数组）作为Series的索引可以构造分层索引。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 要构造分层索引，需要传入一个由<b>元组组成的列表</b>，或者使用 `pd.MultiIndex.from_...` 方法。直接传入一个列表（如 `['a', 'b']`）只会创建单层索引。</details><hr><p><strong>15. 在分级索引中，可以通过<code>level</code>选项并通过改变轴向来进行聚合。 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 像 `.sum()`, `.mean()` 等聚合方法都接受 `level` 参数来指定在哪个索引层级上进行聚合，也接受 `axis` 参数来指定是在行索引还是列索引上操作。</details><hr><p><strong>16. <code>unstack</code>操作的只能是最内层，<code>stack</code>也是如此 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `unstack` 和 `stack` 默认操作最内层，但都可以接受一个 `level` 参数（层级名称或编号）来指定操作任意一个层级。</details><hr><p><strong>17. 默认情况下，<code>merge</code>函数会联合左连接和右连接的效果。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `merge` 默认是<b>内连接 (`inner`)</b>。联合左连接和右连接效果的是<b>外连接 (`outer`)</b>。</details><hr><p><strong>18. 使用<code>merge</code>函数进行列-列连接时，传递的DataFrame索引对象会被丢弃。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 此题与第 10 题相同，叙述正确。</details><hr><p><strong>19. 通过给出层级排序函数<code>sort_index</code>函数中的<code>level</code>选项，可以指明对这一个层级的索引排序（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `sort_index` 的 `level` 参数专门用于在多重索引中指定按哪个层级进行排序。</details><hr><p><strong>20. <code>concat</code>函数对两个含有重叠索引的Series进行连接后，重叠索引对应的值为连接前两个重叠索引对应的值之和（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `concat` 只是简单地将 Series 拼接在一起。如果存在重叠的索引，结果中会保留这些重复的索引及其各自对应的值，而不会进行任何算术运算。</details><hr><p><strong>21. DataFrame的<code>join</code>方法进行连接键上的左连接，完全保留左边DataFrame的行索引（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `.join()` 方法默认 `how='left'`，即左连接，它会以调用该方法的 DataFrame（左边）的索引为基准进行连接。</details><hr><p><strong>22. 若一个具有二重行列索引的数据，使用<code>data.loc(axis=0)[0,1]</code>命令，获得的数据保留二重索引。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `data.loc(axis=0)[0,1]` 是错误的语法。`.loc` 不是一个函数，不能用 `()` 调用。正确的语法是 `data.loc[...]`。</details><hr><p><strong>23. DataFrame的多对多连接是行的笛卡尔积（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 在 `merge` 操作中，如果左表的连接键有 M 个匹配项，右表的连接键有 N 个匹配项，那么多对多连接会产生 M * N 行的笛卡尔积。</details><hr><p><strong>24. <code>groupby()</code>后，使用<code>agg()</code>可以…但不能对不同的列使用不同的函数( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `.agg()` 的一个核心功能就是可以通过传入一个字典，来对不同的列应用不同的聚合函数。例如 `df.groupby('key').agg({'col_A': 'sum', 'col_B': 'mean'})`。</details><hr><p><strong>25. 对两个Series数组调用<code>concat</code>方法，…如果设定<code>axis=1</code>，会生成一个DataFrame （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `axis=0` (默认) 会将两个 Series 垂直拼接成一个更长的 Series。`axis=1` 会将两个 Series 水平并列，每个 Series 成为一列，从而构成一个 DataFrame。</details><hr><p><strong>26. DataFrame的<code>set_index</code>函数会生成一个新的DataFrame。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `set_index` 默认 `inplace=False`，返回一个设置了新索引的新 DataFrame 对象。</details><hr><p><strong>27. <code>stack</code>(堆叠)会将行中的数据透视到列中（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `stack` (堆叠) 是将<b>列</b>中的数据“堆叠”到<b>行</b>上，形成一个更长的、带有更多层级索引的 Series。将行透视到列的操作是 `unstack`。</details><hr><p><strong>28. <code>swaplevel</code>接收两个层级序号或层级名称，返回一个进行了层级变更的新对象（但是原数据是不变的）( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是对 `swaplevel` 功能的准确描述。</details><hr><p><strong>29. <code>concat</code>函数中，<code>join</code>默认的连接方式是<code>&#39;inner&#39;</code>（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `concat` 的 `join` 参数默认为 `'outer'`，即取所有轴上索引的并集。</details><hr><p><strong>30. <code>concat</code>函数中，如果传入了<code>keys</code>和&#x2F;或<code>levels</code>参数，则该参数不能用于多层索引的层级名称（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `keys` 参数用于提供新创建的层级的标签，而 `names` 参数（不是`levels`）用于为这些层级命名。`levels` 是 MultiIndex 的一个属性。这个表述混淆了参数，是错误的。</details><hr><p><strong>31. 在<code>concat</code>方法中传入参数<code>ignore_index</code>参数将忽略轴向索引 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `ignore_index=True` 会使 `concat` 忽略原始对象的索引，并生成一个新的从 0 开始的整数索引。</details><hr><p><strong>32. <code>merge</code>函数中<code>on</code>参数所需要连接的列名并不必须在两边的DataFrame对象中都出现。( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `on` 参数指定的是在两个 DataFrame 中都<b>共同存在</b>的列名。如果两边的列名不同，需要分别使用 `left_on` 和 `right_on`。</details><hr><p><strong>33. …<code>frame.reset_index(1)</code>和<code>frame.sort_index(level=1)</code>返回的结果相同。 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `reset_index(1)` 会将第 1 层索引（key2）变成一个数据列。`sort_index(level=1)` 会根据第 1 层索引的值对行进行排序。两者功能和返回结果的结构完全不同。</details><hr><p><strong>34. <code>sort_index</code>只能在单一层级上对数据进行排序 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `sort_index` 的 `level` 参数可以接受一个<b>列表</b>，从而按多个层级的先后顺序进行排序。</details><h2 id="第九章：数据可视化"><a href="#第九章：数据可视化" class="headerlink" title="第九章：数据可视化"></a>第九章：数据可视化</h2><p><strong>1. <code>fig.add_subplot(2, 3, 5)</code>，第3个参数的含义是在创建的6个子图中，它是第五个（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `add_subplot(nrows, ncols, index)` 中的 `index` 参数是从 1 开始计数的，表示子图在网格中的位置。对于 2x3 的网格，`index=5` 指的是第二行第二列的子图，也就是第5个。</details><hr><p><strong>2. DataFrame的<code>plot</code>方法可以在同一个子图中将每一列绘制为不同的折线，并自动生成图例（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 `df.plot()` 的标准行为。它会为 DataFrame 的每一列（通常是数值列）绘制一条折线，并使用列名作为标签自动生成图例。</details><hr><p><strong>3. <code>matplotlib</code>和<code>seaborn</code>都是可以用于绘图的包。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** Matplotlib 是基础绘图库，Seaborn 是基于 Matplotlib 的高级封装，两者都是 Python 中主流的数据可视化库。</details><hr><p><strong>4. 在图表中添加图形时，需要生成patch对象<code>shp</code>，再调用<code>add_patch(shp)</code>将它加入到子图（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `Patch` 是 Matplotlib 中几何形状的基类。添加形状的标准流程就是先创建 Patch 对象（如 `plt.Rectangle`, `plt.Circle`），然后使用 Axes 对象的 `.add_patch()` 方法将其添加到子图中。</details><hr><p><strong>5. <code>fig.add_subplot</code>返回的是Axes Subplot对象（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `fig.add_subplot()` 和 `plt.subplots()` 返回的子图对象都是 `matplotlib.axes.Axes` 的实例（或其子类），通常称为 Axes 对象或子图对象。</details><hr><p><strong>6. <code>matplotlib</code>并不检查标签是否重叠（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** Matplotlib 的默认布局算法通常不会主动检查和避免坐标轴刻度、标题等文本标签的重叠，有时需要用户手动调用 `plt.tight_layout()` 或调整图形参数来解决。</details><hr><p><strong>7. <code>regplot</code>是<code>seaborn</code>中的绘制折线图的方法（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `regplot` 用于绘制<b>散点图</b>并拟合一条线性<b>回归线</b>。Seaborn 中绘制折线图的主要函数是 `lineplot`。</details><hr><p><strong>8. 对于折线图，后续的点默认是线性内插（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** Matplotlib 的 `plot` 函数在绘制折线图时，会用直线连接相邻的数据点，这在视觉上是一种线性插值的效果。</details><hr><p><strong>9. 运行代码<code>fig.add_subplot（2，2，0）</code>生成的是2×2图片中的第一个子图（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `add_subplot(nrows, ncols, index)` 中的 `index` 参数是从 <b>1</b> 开始计数的，`index=0` 是无效的，会引发 `ValueError`。</details><hr><p><strong>10. 使用分面网格是利用多种分组变量对数据进行可视化的方式（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 分面网格（Facet Grid），如 Seaborn 中的 `catplot` 或 `relplot`，核心思想就是根据一个或多个分类变量的值将数据划分到不同的子图中，从而在多个维度上进行比较和可视化。</details><hr><p><strong>11. 绘制图表时可以通过传递<code>label</code>参数添加图例来区分不同的绘图元素 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 在 `plt.plot` 等绘图函数中设置 `label` 参数，然后调用 `plt.legend()`，即可显示图例。</details><hr><p><strong>12. DataFrame对象调用<code>plot</code>方法时，可以通过传递<code>subplots=True</code>来使得对象的每一列绘制在独立的子图中（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 `subplots=True` 参数的正确功能描述。</details><hr><p><strong>13. <code>plt.plot([2,3, 6, 7,8], &#39;g--o&#39;)</code>与<code>plt.plot([2,3, 6, 7,8], &#39;go--&#39;)</code>生成的图形不一样。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 在 Matplotlib 的格式字符串中，颜色、标记和线型的顺序是任意的。`'g--o'` 和 `'go--'` 都表示：颜色绿色(`g`)，线型虚线(`--`)，标记圆点(`o`)。两者生成的图形是完全一样的。</details><hr><p><strong>14. pandas对象的<code>plot.barh</code>方法绘制的是垂直的柱状图（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `barh` 中的 `h` 代表 horizontal（水平）。`.plot.barh()` 绘制的是<b>水平</b>柱状图。`.plot.bar()` 才是绘制垂直柱状图。</details><hr><p><strong>15. matplotlib在设置x轴刻度的时候，区间长度必须一致。 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** Matplotlib 的刻度设置非常灵活，完全可以设置不均匀的刻度位置。例如 `plt.xticks([0, 1, 5, 10])`。</details><hr><p><strong>16. matplotlib绘制的图位于Figure对象中，可以使用<code>plt.figure()</code>调用 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `Figure` 是 Matplotlib 中最高层级的容器，包含了所有的绘图元素。`plt.figure()` 用于<b>创建</b>一个新的 `Figure` 对象，或者获取当前活动的 `Figure` 对象。</details><hr><p><strong>17. 通过使用<code>shareX</code>、<code>shareY</code>可以使得子图分别拥有相同的x轴和y轴 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 在 `plt.subplots()` 函数中，设置 `sharex=True` 和 `sharey=True` 可以让所有子图共享相同的 x 轴和 y 轴范围及刻度，这对于比较不同子图非常有用。</details><hr><p><strong>18. <code>set_xticks</code>在数据范围内设定刻度的位置，而不设置刻度的标签。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `ax.set_xticks()` 用于设置 x 轴<b>主刻度线的位置</b>。要设置这些位置对应的<b>标签文本</b>，需要使用 `ax.set_xticklabels()`。</details><hr><p><strong>19. <code>plt.savefig</code>函数可以将图片保存到文件中，并且只能以<code>svg</code>格式存储（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `savefig` 支持多种文件格式，如 `.png`, `.jpg`, `.pdf`, `.svg` 等，通常根据你提供的文件扩展名自动推断格式。</details><hr><p><strong>20. 在绘制直方图的参数中，<code>bins</code>的默认参数是10。 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 在 `plt.hist()` 和 Pandas 的 `.plot.hist()` 中，如果不指定 `bins` 参数，默认会将数据划分到 10 个箱子中。</details><hr><p><strong>21. 假设有一个figure对象<code>fig</code>，则<code>fig.add_subplot(224)</code>和<code>fig.add_subplot(2,2,4)</code>执行的结果相同。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `add_subplot` 支持一种三位数的简写形式，其中百位是行数，十位是列数，个位是索引。因此 `add_subplot(224)` 等价于 `add_subplot(2, 2, 4)`。</details><hr><p><strong>22. 默认情况下，Series和DataFrame的<code>plot()</code>方法绘制的是条形图（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 默认绘制的是<b>线图 (line plot)</b>。</details><hr><p><strong>23. <code>fig=plt.figure()</code>随后<code>fig.plot()</code>没有问题。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `Figure` 对象本身没有 `.plot()` 方法。绘图是在 `Axes` (子图) 对象上进行的。正确的做法是先用 `fig.add_subplot()` 创建一个子图 `ax`，然后调用 `ax.plot()`。</details><hr><p><strong>24. <code>plot</code>函数中’b’代表黑色 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `'b'` 代表蓝色 (blue)，`'k'` 代表黑色 (black)。</details><hr><p><strong>25. 代码<code>plt.xlim（[0, 10]）</code>的目的是将x轴的范围设置为0到10。 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 `plt.xlim()` 函数的标准用法，也可以用 `plt.xlim(0, 10)`。</details><hr><p><strong>26. 使用<code>value_counts:s.value_counts().plot.bar()</code>可以有效地对Series值进行可视化。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `s.value_counts()` 会计算 Series 中每个唯一值的出现频率，返回一个新的 Series。对其调用 `.plot.bar()` 可以非常直观地将这些频率以柱状图的形式展示出来。</details><hr><p><strong>27. <code>plt.subplots</code>方法可以创建一个新的Figure，并返回一个含有已创建的subplot对象的NumPy数组。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `fig, axes = plt.subplots(...)` 返回一个 Figure 对象 `fig` 和一个包含所有子图 (Axes) 对象的 NumPy 数组 `axes`（如果只创建一个子图，则返回单个 Axes 对象）。</details><hr><p><strong>28. <code>matplotlib</code>会自动检查标签是否重叠（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 此题与第 6 题类似，Matplotlib 默认不会检查标签重叠。</details><hr><p><strong>29. <code>ax.scatter(np.arange(10), np.arange(10))</code>可以绘制一个x和y取值都在1-10之间的散点图。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `np.arange(10)` 生成的是从 <b>0 到 9</b> 的整数序列，而不是 1 到 10。</details><hr><p><strong>30. DataFrame直接进行绘图时，默认把columns当成x轴（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 默认情况下，`df.plot()` 使用 DataFrame 的<b>索引 (index)</b> 作为 x 轴，每一列 (columns) 作为一条独立的 y 轴序列。</details><h2 id="第十章：高级数据分析技术"><a href="#第十章：高级数据分析技术" class="headerlink" title="第十章：高级数据分析技术"></a>第十章：高级数据分析技术</h2><p><strong>1. 调用<code>groupby</code>方法生成一个GroupBy对象可以直接进行输出。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** GroupBy 对象本身是一个中间对象，它包含了分组信息但没有进行任何计算。直接打印它只会显示其类型信息，如 `<pandas.core.groupby.generic.DataFrameGroupBy object ...>`，而不会显示分组后的数据。</details><hr><p><strong>2. <code>quantile</code>（分位数）是Series的方法所以也可以用来聚合。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 任何能从数组中产生标量值的函数都可以作为聚合函数。`quantile()` 是 Series 的一个有效方法，可以计算分位数（一个标量），因此可以用于 GroupBy 对象的聚合，例如 `grouped.quantile(0.5)`。</details><hr><p><strong>3. 在没有特定指明对DataFrame对象的哪一列进行计算时，默认情况下会对所 有的数值列进行聚合（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当对一个 GroupBy 对象调用聚合方法（如 `.mean()`, `.sum()`）时，如果未选择特定列，该方法会自动应用到所有可进行该运算的列上，通常是数值类型的列。</details><hr><p><strong>4. 聚合数据必须返回行索引，并且自己创建的聚合函数是可以直接使用的（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 聚合后的数据，其索引是分组键，不一定是行索引。自定义的聚合函数可以通过 `.agg()` 或 `.apply()` 方法使用。</details><hr><p><strong>5. 使用<code>groupby</code>方法分组时分组键可以是多种形式的，而且键的类型也不一定完全相同（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** GroupBy 的分组键 `by` 参数非常灵活，可以接受列名、Series、数组、函数等，它们的类型也可以不同。</details><hr><p><strong>6. 分层索引的数据集可以在某个指定的层级上进行聚合（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** GroupBy 的 `by` 参数和聚合方法（如 `.sum()`）的 `level` 参数都可以用来指定在哪个索引层级上进行分组和聚合。</details><hr><p><strong>7. 若传入一组函数或函数名，得到的DataFrame的列就会以相应的函数命名（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当向 `.agg()` 传入一个函数列表时，例如 `grouped.agg(['mean', 'std'])`，结果 DataFrame 的列名会自动以函数名（如 'mean', 'std'）作为新的层级。</details><hr><p><strong>8. 聚合只是分组运算中的一种…它只是接受能够将一维数组简化为标量值的函数。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是对聚合 (aggregation) 的准确定义。它是一种将一组值（如一个分组内的数据）转换为一个单一标量值（如均值、和、最大值等）的数据转换过程。</details><hr><p><strong>9. 对多个分组键的GroupBy对象进行迭代，生成的元组序列中的第一个元素是键值的元组（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当按多个键（如 `df.groupby(['key1', 'key2'])`）分组并迭代时，每次迭代返回 `(group_name, sub_df)`。其中 `group_name` 是一个包含该组所有键值的元组，例如 `('a', 'one')`。</details><hr><p><strong>10. <code>Crosstab</code>的前两个参数可以是数组、Series、或者数组的列表（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `pd.crosstab` 的 `index` 和 `columns` 参数非常灵活，可以接受 Series、数组或列表，或者这些类型的列表（用于创建多级交叉表）。</details><hr><p><strong>11. 对于<code>groupby</code>中的<code>size</code>方法，分组键中的任何缺失值都会被排除在结果之外（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 默认情况下，`groupby` 会忽略分组键中的 `NaN` 值。`.size()` 会计算每个有效分组的大小，但它本身不处理分组键的缺失。</details><hr><p><strong>12. <code>apply</code>方法是将对象拆分为多块，在每一块都会调用传递的函数（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是对 GroupBy 的 "Split-Apply-Combine" 模式中 "Apply" 步骤的准确描述。`apply` 方法会对每个分组（块）执行传入的函数。</details><hr><p><strong>13. 使用字典构造传给<code>groupby</code>的数组时，字典的键必须与对象的长度一致（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 当使用字典进行分组时，字典的键应该与被分组<b>轴的索引标签</b>相对应，而不是与对象的长度一致。</details><hr><p><strong>14. 默认情况下，<code>groupby</code>在<code>axis = 1</code>的轴向上分组（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `groupby` 的 `axis` 参数默认为 `0`，即默认按行进行分组。</details><hr><p><strong>15. 分组键中有缺失值会导致程序报错 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `groupby` 默认会忽略分组键中的 `NaN` 值，不会报错。</details><hr><p><strong>16. 分组信息不能以非数组形式存在 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 分组信息（分组键）可以是多种形式，如函数、字典、Series，不限于数组。</details><hr><p><strong>17. 在没有特定指明对DataFrame对象的哪一列进行计算时，<code>agg</code>方法默认情况下会对所有的数值列进行聚合（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 此题与第 3 题类似，叙述正确。</details><hr><p><strong>18. …执行<code>df.groupby([&#39;key1&#39;,&#39;key2&#39;])[&#39;data2&#39;].mean()</code>可以获得<code>data2</code>列的均值并以DataFrame的形式返回结果（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `df.groupby(...)['data2']` 选择了一列，这是一个 GroupBy Series 对象。对其调用 `.mean()` 会返回一个<b>Series</b>，其索引是分组键 `('key1', 'key2')`。</details><hr><p><strong>19. 若<code>df</code>是一个DataFrame对象，则默认情况下，<code>df</code>中的所有的数值列都可以聚合。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 此题与第 3 题和第 17 题类似，叙述正确。</details><hr><p><strong>20. 假设有DataFrame对象<code>df</code>，<code>key1</code>是<code>df</code>中的列，则<code>df.groupby(&#39;key1&#39;).mean()</code>等价于<code>df.groupby([&#39;key1&#39;]).mean()</code>。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 按单列分组时，传入字符串 `'key1'` 和包含单个字符串的列表 `['key1']` 是等价的。</details><hr><p><strong>21. 使用自定义的聚合函数时需要将其传递给<code>agg</code>方法 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `.agg()` 是应用一个或多个聚合函数（包括自定义函数）到分组上的标准方法。</details><hr><p><strong>22. 使用含有原数据不存在的分组键的字典或Series进行分组会出现报错 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 不会报错。如果分组字典或 Series 的键在被分组对象的索引中找不到，这些键值对会被忽略。</details><hr><p><strong>23. <code>groupby</code>的参数只可以是列名，不可以是index名。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 可以通过 `level` 参数按索引的层级名称或编号进行分组。</details><hr><p><strong>24. <code>cumsum</code>函数不会对<code>df</code>的索引进行排序。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `cumsum()` 在计算累积和时，是按照数据现有的顺序进行的，不会改变或排序索引。</details><hr><p><strong>25. 对从DataFrame创建的GroupBy对象用列表或数组进行索引时，返回的是分组的DataFrame( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当对一个 GroupBy 对象使用 `[]` 选择一列或多列时（如 `grouped[['col_A', 'col_B']]`），它会返回一个新的、只包含这些选定列的 GroupBy 对象，可以继续进行聚合等操作。</details><hr><p><strong>26. 返回的聚合数据…取消这种模式，在调用<code>groupby</code>的时候设定<code>as_index=True</code>即可。 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `as_index=True` 是默认行为，它会使分组键成为结果的索引。要取消这种模式（即让分组键保留为数据列），需要设置 <b>`as_index=False`</b>。</details><hr><p><strong>27. <code>cut</code>返回的Categorical对象不能直接传递给<code>groupby</code> （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `pd.cut()` 返回的 Categorical 对象是进行分箱分析时 `groupby` 的理想分组键。</details><hr><p><strong>28. <code>pandas</code>提供了<code>crosstab()</code>函数…返回新的<code>DataFrame</code>对象。 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是对 `pd.crosstab` 功能的准确描述。</details><hr><p><strong>29. <code>apply</code>函数只可以传入函数 ( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 与 `.agg()` 或 `.transform()` 不同，`.apply()` 不接受像 `'mean'` 这样的字符串快捷方式，它必须接受一个可调用的函数对象。</details><hr><p><strong>30. 在用<code>groupby</code>方法对DataFrame对象进行分组处理时，…可以是字符串类型的列名、其他python对象…以及python的函数。 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 此题与第 5 题类似，准确描述了 `groupby` 分组键的灵活性。</details><hr><p><strong>31. <code>Goupby</code> 对象会生成包含组名和数据块的二位元组序列 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 迭代一个 GroupBy 对象时，每次会产生一个 `(group_name, sub_dataframe)` 形式的二元元组。</details><hr><p><strong>32. 由于<code>quantile</code>并不是显式的为GroupBy对象实现的，因此不能用于聚合 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 此题与第 2 题类似。虽然 `.quantile()` 不是像 `.mean()` 那样直接的 GroupBy 方法，但它可以作为有效的聚合函数通过 `.agg()` 或 `.apply()` 来使用。</details><h2 id="第十一章：时间序列数据的处理和分析"><a href="#第十一章：时间序列数据的处理和分析" class="headerlink" title="第十一章：时间序列数据的处理和分析"></a>第十一章：时间序列数据的处理和分析</h2><p><strong>1. <code>datetime.strptime</code>可以在已知格式的情况下转换日期。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `datetime.strptime(string, format)` 的核心功能就是将一个字符串按照指定的格式解析为 `datetime` 对象。</details><hr><p><strong>2. 不能创建含有重复索引的时间序列（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** Pandas 的时间序列（以及其他任何 Series/DataFrame）的索引都<b>可以</b>包含重复的标签。</details><hr><p><strong>3. <code>Timestamp</code>与<code>datetime</code>都是时间类型，但是<code>timestamp</code>只使用<code>datetime</code>一半的存储空间。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** Pandas 的 `Timestamp` 对象内部使用一个 64 位整数（8字节）来存储纳秒级精度的时间。Python 的 `datetime` 对象通常也占用相似或更多的空间。说 `Timestamp` 只使用一半空间是不准确的。</details><hr><p><strong>4. 如果时间序列是含有重复索引的，进行索引得到的结果是切片（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当使用一个在索引中重复出现的标签进行索引时，Pandas 会返回一个包含所有匹配该标签的行的新 Series 或 DataFrame，这在概念上是一个“切片”或子集。</details><hr><p><strong>5. 不同索引的时间序列之间的算术运算在日期上自动对齐（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 Pandas 的核心特性之一。在进行算术运算时，Pandas 会自动按索引对齐数据，对于只存在于一方的索引，结果会是 `NaN`。</details><hr><p><strong>6. <code>pd.date_range(&#39;2000-01-01&#39;,&#39;2000-01-03 23:59&#39;,freq=&#39;0.545H&#39;)</code>是不能运行的。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `freq` 参数可以接受小数，表示非整数倍的频率。`'0.545H'` 是一个有效的频率字符串，表示 0.545 个小时。代码可以正常运行。</details><hr><p><strong>7. 以时间戳作为索引的Series可以传递能解释为日期的字符串进行索引。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 Pandas 时间序列索引的便利之处。你可以使用 `'2011-01-10'`、`'1/10/2011'` 等字符串来索引一个 `DatetimeIndex`，Pandas 会自动解析它们。</details><hr><p><strong>8. <code>resample</code>后使用<code>ohlc</code>聚合函数可以获得包含开端-峰值-谷值-结束四种聚合值列的DataFrame（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `ohlc` (Open-High-Low-Close) 是一种专门为金融时间序列设计的聚合函数，它会在每个重采样周期内计算开盘价（第一个值）、最高价、最低价和收盘价（最后一个值）。</details><hr><p><strong>9. 在<code>date_range</code>的<code>freq</code>参数传入“1h10min”是无效的（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** Pandas 的频率字符串支持组合。`'1h10min'` 是一个有效的频率，表示 1 小时 10 分钟。</details><hr><p><strong>10. 如果两个时间区间拥有相同的频率，则它们的差是它们之间的单位数。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 对两个相同频率的 `Period` 对象进行减法运算，会得到它们之间相差的频率单位数量。例如 `pd.Period('2011-03', 'M') - pd.Period('2011-01', 'M')` 的结果是 `2`。</details><hr><p><strong>11. 时间序列进行索引和选择时，传入的日期字符串格式必须与时间序列中的格式相同（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 此题与第 7 题类似。Pandas 的日期解析器非常灵活，不需要传入的字符串格式与 `DatetimeIndex` 的内部格式完全一致。</details><hr><p><strong>12. 所有使用<code>datetime</code>对象的地方都可以使用<code>Timestamp</code>（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** Pandas 的 `Timestamp` 对象是 Python 内置 `datetime` 对象的兼容替代品，并提供了更高的时间精度（纳秒）和一些额外功能。在大多数情况下，它们可以互换使用。</details><hr><p><strong>13. 两个时区不同的时间序列联合的结果是UTC时间（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当合并或操作两个具有不同时区的时间序列时，Pandas 会将它们都转换为协调世界时 (UTC) 以进行统一处理，结果的时区也会是 UTC。</details><hr><p><strong>14. 锚定偏置量构成的时间频率是均匀间隔的。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 锚定偏移量（如 `'M'` 月末，`'W-FRI'` 每周五）的间隔是不均匀的，因为每个月的天数不同，每周五之间的间隔也是固定的7天但日期会变。均匀间隔的频率是像 `'D'` (每日) 或 `'H'` (每小时) 这样的。</details><hr><p><strong>15. <code>shift</code>函数可以推移时间戳，但不能推移数据。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `shift` 函数有两种用法：  <ul>    <li>`ts.shift(periods)`：<b>移动数据</b>，索引不变。</li>    <li>`ts.shift(periods, freq)`：<b>移动索引</b>，数据不变。</li>  </ul>  因此，它既可以推移数据也可以推移时间戳。</details><hr><p><strong>16. 当获得包含时间信息的时间戳时…可以将<code>normalize</code>设置为True。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `pd.to_datetime()` 的 `normalize=True` 参数或 `DatetimeIndex` 的 `.normalize()` 方法可以将时间戳的时间部分“抹掉”，设置为午夜 `00:00:00`。</details><hr><p><strong>17. 不可以使用不包含在时间序列中的时间戳进行切片。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 时间序列的切片非常灵活。例如 `ts['2011-01-06':'2011-01-09']` 是完全有效的，即使 `'2011-01-06'` 和 `'2011-01-09'` 这两个日期本身并不在索引中，Pandas 也会返回这个日期范围内的所有数据。</details><hr><p><strong>18. 将高频率的数据聚合到低频率成为向上采样，将低频率数据转换到高频率数据称为向下采样。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 描述正好相反。  <ul>    <li><b>向下采样 (Downsampling)</b>：将高频率数据聚合到低频率（例如，将每日数据聚合为每月数据）。</li>    <li><b>向上采样 (Upsampling)</b>：将低频率数据转换到高频率（例如，将每月数据扩展为每日数据），这通常会引入缺失值。</li>  </ul></details><hr><p><strong>19. 进行重新采样时，将<code>W-WED</code>转换到<code>W-FRI</code>属于向下采样（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `W-WED` (每周三) 和 `W-FRI` (每周五) 都是周度频率，它们的频率是相同的。这不属于向上或向下采样，只是一种频率的转换。</details><hr><p><strong>20. 运行代码<code>pd.to_datetime([&#39;2000-1-1&#39;,&#39;31-12-2000&#39;,&#39;8-31-2000&#39;])</code>会报错（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `pd.to_datetime()` 的解析器非常强大，能够处理多种混合的日期格式。它能正确解析 `'31-12-2000'` (日-月-年) 和 `'8-31-2000'` (月-日-年)，不会报错。</details><hr><p><strong>21. 当把<code>datetime</code>类型的数据作为索引时，数据类型变为<code>DatetimeIndex</code>。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当使用 `datetime` 对象列表或类似序列作为 Series/DataFrame 的索引时，Pandas 会自动将其转换为 `DatetimeIndex` 类型。</details><hr><p><strong>22. <code>timedelta</code>可以查看<code>days</code>和<code>seconds</code>而不能查看<code>minutes</code>。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `timedelta` 对象内部只存储 `days`, `seconds`, `microseconds`。虽然没有直接的 `.minutes` 属性，但可以通过总秒数 `.total_seconds() / 60` 来计算分钟。</details><hr><p><strong>23. <code>resample</code>函数得<code>loffset</code>参数可以用<code>shift</code>实现（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `loffset` (label offset) 用于对聚合后的标签进行调整，其效果与对结果调用 `.shift()` 方法类似。</details><hr><p><strong>24. 向上采样中，目标频率是原频率得子区间（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 向上采样（如从月度到每日）意味着新的、更高频率的时间点是原始低频率区间的子集或细分。</details><hr><p><strong>25. <code>date_range()</code>函数生产日期时间数据时，如果以6天为间隔可以设置参数<code>freq</code>为<code>‘6D’</code>。( )</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** Pandas 频率字符串支持在基础频率前加一个整数倍数，`'6D'` 是表示“6天”的正确写法。</details><hr><p><strong>26. <code>...datetime.strptime(value, &#39;%Y/%m/%d&#39;)</code>都可以正确运行 ( )</strong></p><details>  <summary style-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `strptime` 要求字符串 `value` 的格式必须与提供的 `format` 参数<b>严格匹配</b>。`'2011-01-03'` 与 `'%Y/%m/%d'` 的分隔符不匹配，会引发 `ValueError`。</details><hr><p><strong>27. <code>datetime</code>的格式<code>%Y</code>显示的是四位的年份（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `%Y` 代表四位数的年份（如 2019），`%y` 代表两位数的年份（如 19）。</details><hr><p><strong>28. <code>resample</code> 的方法参数中，<code>convention</code>的默认值为<code>‘start’</code>（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 在对 `Period` 数据进行重采样时，`convention` 参数用于决定将低频区间转换为高频区间时，是取区间的开始 (`'start'`) 还是结束 (`'end'`)。其默认值为 `'start'`。</details><hr><p><strong>29. pandas的通用时间序列是不规则的，即时间序列的频率不是固定的 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** Pandas 的时间序列可以是不规则的，即时间戳之间没有固定的时间间隔。`resample` 等工具就是用来处理这种不规则序列并将其转换为规则频率的。</details><h2 id="第十二章：一些Pandas中的高级用法"><a href="#第十二章：一些Pandas中的高级用法" class="headerlink" title="第十二章：一些Pandas中的高级用法"></a>第十二章：一些Pandas中的高级用法</h2><p><strong>1. 一个分类数组可以包含任一不可变的值类型（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 分类数据 (Categorical) 的类别 (`categories`) 可以是任何不可变类型，如字符串、整数、元组等。</details><hr><p><strong>2. 分类数据一定是字符串。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 如上一题所述，分类数据的类别可以是任何不可变类型，不限于字符串。</details><hr><p><strong>3. 将特定的大型数据集进行分析时，将数据转换为分类数据会大幅提高性能（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当一个列包含大量重复的字符串或其他对象时，将其转换为 `category` 类型会用整数编码替代原始值，从而大大减少内存占用，并能显著提升某些分析操作（如 `groupby`）的性能。</details><hr><p><strong>4. 对于Series中的分类方法，<code>rename_categories</code>和<code>set_categories</code>…但前者不能改变类别的数量，而后者可以添加或删除类别（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是对这两个方法区别的准确描述。`rename_categories` 只是重命名现有的类别，数量不变。`set_categories` 则是用一个全新的列表来替换类别，可以增删类别。</details><hr><p><strong>5. 对一个Categorical进行<code>set_categories</code>操作，赋值给一个新的对象，不会影响到新对象的类别。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `set_categories` 的作用就是<b>改变</b>或设置类别。将操作结果赋值给新对象，新对象的类别就是被设置成的新类别。</details><hr><p><strong>6. <code>pipe</code>方法的一个潜在用途是将操作的序列泛化成可复用的函数（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `.pipe()` 方法允许将一个对象（如 DataFrame）作为第一个参数传递给一个函数，从而实现链式调用。这使得将一系列数据处理步骤封装成可复用的函数变得非常方便。</details><hr><p><strong>7. <code>pandas.qcut</code>生成的结果的数据类型是<code>pandas.Categorical</code>（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `pd.qcut` 和 `pd.cut` 都用于数据分箱，它们返回的结果是一个 `Categorical` 对象。</details><hr><p><strong>8. <code>df2=df.copy(),df2[&#39;k&#39;]=v</code>与<code>df2=df.assign(k=v)</code>是等价的（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 两者都实现了创建 `df` 的一个副本并添加或修改名为 `'k'` 的列。`.assign()` 方法专门为此设计，并返回一个新对象，而第一种方法是先显式复制再修改。在效果上是等价的。</details><hr><p><strong>9. <code>...pd.unique(values)</code>返回的结果是<code>FALSE</code> （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `pd.unique()` 会返回输入序列中的<b>唯一值</b>，并保持其出现的<b>原始顺序</b>。对于 `values`，结果会是一个包含 `['apple', 'orange']` 的 NumPy 数组。</details><hr><p><strong>10. <code>transform</code>可以产生一个标量值，并广播到各分组的尺寸数据中。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor:pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是对 `transform` 核心功能的准确描述。例如，`grouped.transform('mean')` 会计算每个分组的均值（一个标量），然后将这个标量值“广播”回该分组的所有原始位置。</details><hr><p><strong>11. Categorical对象的<code>codes</code>属性对应的<code>dtype</code>为<code>float64</code>（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `.codes` 属性是一个 NumPy 数组，其元素是表示类别的<b>整数</b>编码，数据类型通常是 `int8` 或 `int16` 等整数类型，不是 `float64`。</details><hr><p><strong>12. <code>transform</code>函数不可以改变它的输入（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `transform` 传入的函数必须返回一个与输入分组形状相同的对象，它用于“转换”数据，而不是像 `agg` 那样改变其形状（聚合）。</details><hr><p><strong>13. 分类转换会自动指定类别的顺序。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当从序列创建 Categorical 对象时，如果没有明确指定类别，Pandas 会自动从数据中找出唯一值，并<b>按字母或数值顺序</b>排列它们作为类别。</details><hr><p><strong>14. Categorical对象比Series使用更少的内存，在对象上进行操作也更快。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当数据包含大量重复值时，Categorical 对象通过整数编码来存储数据，可以显著减少内存占用，并提高某些操作（如 `groupby`）的性能。</details><hr><p><strong>15. <code>resample</code>是一种基于时间分段的分组操作。 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `.resample()` 的核心功能就是根据指定的时间频率将时间序列数据划分到不同的时间“箱子”（分段）中，其行为类似于一个专门针对时间序列的 `groupby`。</details><hr><p><strong>16. 使用<code>TimeGrouper</code>时，时间必须是Series或者DataFrame索引 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `TimeGrouper`（现在推荐使用 `pd.Grouper`）是 `groupby` 的一个特殊工具，它要求分组的轴必须是一个 `DatetimeIndex`。</details><hr><p><strong>17. <code>DataFrame.assign</code>方法可以按指定修改原DataFrame（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `.assign()` 方法总是返回一个<b>新的</b> DataFrame 副本，其中包含了新增或修改的列，而<b>不修改</b>原始的 DataFrame。</details><hr><p><strong>18. <code>...cat_s.remove_unused_categories()</code>可以去除所有没有出现在数据中的类别（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 这是 `.remove_unused_categories()` 方法的正确功能描述。</details><hr><p><strong>19. <code>fruits_cat = df[&#39;fruit&#39;].astype(&#39;category&#39;)</code>得到的<code>fruits_cat</code>是一个Numpy数组。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `df['fruit'].astype('category')` 返回的是一个数据类型为 `category` 的 Pandas <b>Series</b> 对象，而不是 NumPy 数组。</details><hr><p><strong>20. 通过<code>pandas.qcut</code>分箱函数生成的<code>Categories</code>对象的类别已经指定了顺序（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `qcut` 和 `cut` 生成的 `Categorical` 对象都是有序的（ordered），因为区间本身具有大小顺序。</details><hr><p><strong>21. <code>take</code>函数得到的Series的索引是<code>values</code>的值。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `s.take(indices)` 会根据 `indices` 中的<b>位置</b>来从 `s` 中取值，但返回的新 Series 的索引是 `indices` <b>本身</b>的索引（如果 `indices` 是一个 Series）或者是一个新的整数索引。</details><hr><p><strong>22. category的字符串类别输出时不带单引号。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 当打印一个分类类型的 Series 或 Categorical 对象时，其值（如果是字符串）通常不带引号，这是 Pandas 的一种显示优化。</details><hr><p><strong>23. pandas的<code>TimeGrouper</code>可以使用<code>Grouper</code>替代（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** `pd.TimeGrouper` 在较新版本的 Pandas 中已被弃用，官方推荐使用 `pd.Grouper`，例如 `df.groupby(pd.Grouper(key='time', freq='5min'))`。</details><hr><p><strong>24. <code>remove_categories</code>将移除类别所对应的值。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `.remove_categories()` 会移除指定的类别。如果被移除的类别在数据中存在，那么这些数据值会变成 `NaN`，而不是整个值（行）被移除。</details><hr><p><strong>25. Categorical对象比Series使用更少的内存，在对象上进行操作也明显更快。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 此题与第 14 题相同，叙述正确。</details><hr><p><strong>26. <code>g.transform(&#39;len&#39;)</code> 可以运行。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** `transform` 期望传入的函数能对每个分组（Series）进行计算并返回一个与输入形状相同的 Series。`len()` 函数作用于一个 Series 会返回一个<b>标量</b>（长度），而不是一个 Series。因此，`g.transform('len')`（或 `g.transform(len)`）会报错。能接受 `len` 的是 `.agg()` 或 `.apply()`。</details><hr><p><strong>27. 对一个Categorical进行<code>set_categories</code>操作，赋值给一个新的对象，会影响到新对象的类别。（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 正确 (True)  <br><br>  **解析：** 此题与第 5 题的叙述相反。`set_categories` 的作用就是改变或设置类别，所以新对象的类别当然会是新设置的类别。</details><hr><p><strong>28. <code>df[&#39;fruit&#39;].astype(&#39;category&#39;)</code>返回的是Numpy数组 （ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 此题与第 19 题相同，返回的是一个 Pandas <b>Series</b>。</details><hr><p><strong>29. <code>Categories</code>对象的<code>categories</code>属性…<code>codes</code>属性…（ ）</strong></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析</summary>  <br>  **正确答案：** 错误 (False)  <br><br>  **解析：** 描述正好相反。  <ul>    <li>`.categories`：是维度表，包含唯一的类别<b>值</b>。</li>    <li>`.codes`：是引用维度表的<b>整数数组</b>。</li>  </ul></details>]]>
    </content>
    <id>https://cccignore.github.io/2025/06/20/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E5%88%A4%E6%96%AD%E9%A2%98%E6%95%B4%E7%90%86/</id>
    <link href="https://cccignore.github.io/2025/06/20/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E5%88%A4%E6%96%AD%E9%A2%98%E6%95%B4%E7%90%86/"/>
    <published>2025-06-20T15:43:27.000Z</published>
    <summary>
      <![CDATA[<!-- 文章摘要，会显示在首页 -->]]>
    </summary>
    <title>Python数据分析判断题整理</title>
    <updated>2025-06-20T15:43:27.000Z</updated>
  </entry>
  <entry>
    <author>
      <name>Enoch</name>
    </author>
    <category term="Python数据分析" scheme="https://cccignore.github.io/categories/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90/"/>
    <category term="选择题" scheme="https://cccignore.github.io/categories/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90/%E9%80%89%E6%8B%A9%E9%A2%98/"/>
    <category term="考试复习" scheme="https://cccignore.github.io/tags/%E8%80%83%E8%AF%95%E5%A4%8D%E4%B9%A0/"/>
    <content>
      <![CDATA[<!-- 文章摘要，会显示在首页 --><span id="more"></span><h2 id="第二章：Python语言基础与环境-第三章：Pandas-数据结构与操作"><a href="#第二章：Python语言基础与环境-第三章：Pandas-数据结构与操作" class="headerlink" title="第二章：Python语言基础与环境 + 第三章：Pandas 数据结构与操作"></a>第二章：Python语言基础与环境 + 第三章：Pandas 数据结构与操作</h2><p><strong>1. 执行后可以查看Python的版本的是 （ ）</strong><br>A. import sys; print(sys.version)<br>B. import system; print(system.version)<br>C. import system; print(system.Version)<br>D. import sys; print(sys.Version)</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br> 解析：  要查看 Python 的版本，正确的模块是 `sys`，而不是 `system`。`sys` 模块提供了与 Python 解释器及其环境相关的功能。  `sys.version` 是一个字符串，包含了 Python 解释器的版本号、编译日期和编译器信息。  因此，正确的选项是 A。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> sys</span><br><span class="line"><span class="built_in">print</span>(sys.version)</span><br><span class="line"><span class="comment"># 示例输出可能类似于：</span></span><br><span class="line"><span class="comment"># 3.9.7 (default, Oct 16 2021, 19:42:19)</span></span><br><span class="line"><span class="comment"># [Clang 13.0.0 (clang-1300.0.29.3)]</span></span><br></pre></td></tr></table></figure></p></details><hr><p><strong>2. 已知 x&#x3D;5，三元表达式 <code>&#39;a&#39; if x&gt;=0 else &#39;b&#39;</code> 的结果为（ ）</strong><br>A. ‘a’<br>B. ‘b’<br>C. 5<br>D. 0</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  Python 的三元表达式（条件表达式）的语法是：`为真时的值 if 条件 else 为假时的值`。  <br>  在本题中：  <ul>    <li><b>条件</b> 是 `x >= 0`。</li>    <li>由于 `x` 的值为 `5`，所以条件 `5 >= 0` 的结果是 `True`。</li>    <li>因此，表达式会返回 <b>为真时的值</b>，也就是 `'a'`。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">x = <span class="number">5</span></span><br><span class="line">result = <span class="string">&#x27;a&#x27;</span> <span class="keyword">if</span> x &gt;= <span class="number">0</span> <span class="keyword">else</span> <span class="string">&#x27;b&#x27;</span></span><br><span class="line"><span class="built_in">print</span>(result)</span><br><span class="line"><span class="comment"># 输出:</span></span><br><span class="line"><span class="comment"># a</span></span><br></pre></td></tr></table></figure></p></details><hr><p><strong>3. 下列哪种不是Python元组的定义方式? （ ）</strong><br>A. (1,)<br>B. (1)<br>C. (1, 2)<br>D. (1, 2, (3, 4))</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  Python 中元组的创建关键在于逗号 `,`，而不仅仅是括号 `()`。  <ul>    <li><b>A. `(1,)`</b>：这是定义一个包含单个元素的元组的正确方式，末尾的逗号是必须的。</li>    <li><b>B. `(1)`</b>：这不会创建一个元组，括号在这里只起到改变运算优先级的作⽤，其结果仍然是整数 `1`。</li>    <li><b>C. `(1, 2)`</b>：这是定义包含多个元素的元组的正确方式。</li>    <li><b>D. `(1, 2, (3, 4))`</b>：这是一个合法的嵌套元组。</li>  </ul>  因此，B. `(1)` 不是元组的定义方式。<p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">print</span>(<span class="built_in">type</span>((<span class="number">1</span>,)))</span><br><span class="line"><span class="comment"># 输出: &lt;class &#x27;tuple&#x27;&gt;</span></span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="built_in">type</span>((<span class="number">1</span>)))</span><br><span class="line"><span class="comment"># 输出: &lt;class &#x27;int&#x27;&gt;</span></span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="built_in">type</span>((<span class="number">1</span>, <span class="number">2</span>)))</span><br><span class="line"><span class="comment"># 输出: &lt;class &#x27;tuple&#x27;&gt;</span></span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="built_in">type</span>((<span class="number">1</span>, <span class="number">2</span>, (<span class="number">3</span>, <span class="number">4</span>))))</span><br><span class="line"><span class="comment"># 输出: &lt;class &#x27;tuple&#x27;&gt;</span></span><br></pre></td></tr></table></figure></p></details><hr><p><strong>4. 下列代码的输出是（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">color = [<span class="string">&#x27;red&#x27;</span>, <span class="string">&#x27;blue&#x27;</span>, <span class="string">&#x27;green&#x27;</span>, <span class="string">&#x27;red&#x27;</span>, <span class="string">&#x27;yellow&#x27;</span>]</span><br><span class="line">color.append(<span class="string">&#x27;black&#x27;</span>)</span><br><span class="line">color.insert(<span class="number">1</span>,<span class="string">&#x27;red&#x27;</span>)</span><br><span class="line">color.remove(<span class="string">&#x27;red&#x27;</span>)</span><br><span class="line"><span class="built_in">print</span>(color)</span><br></pre></td></tr></table></figure><p>A. [‘blue’, ‘green’, ‘yellow’, ‘black’]<br>B. [‘red’, ‘blue’, ‘green’, ‘red’, ‘yellow’, ‘black’]<br>C. [‘red’, ‘red’, ‘blue’, ‘green’, ‘red’, ‘yellow’, ‘black’]<br>D. [‘blue’, ‘green’, ‘red’, ‘yellow’, ‘black’]</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  让我们逐步分析代码：  <ol>    <li><code>color = ['red', 'blue', 'green', 'red', 'yellow']</code>： 初始列表。</li>    <li><code>color.append('black')</code>：在列表末尾添加 'black'。 列表变为 <code>['red', 'blue', 'green', 'red', 'yellow', 'black']</code>。</li>    <li><code>color.insert(1,'red')</code>：在索引 1 处插入 'red'。 列表变为 <code>['red', 'red', 'blue', 'green', 'red', 'yellow', 'black']</code>。</li>    <li><code>color.remove('red')</code>：移除列表中<b>第一个</b>出现的 'red'（即索引0处的'red'）。 列表变为 <code>['red', 'blue', 'green', 'red', 'yellow', 'black']</code>。</li>  </ol>  因此，最终输出的是 `['red', 'blue', 'green', 'red', 'yellow', 'black']`。<p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line">color = [<span class="string">&#x27;red&#x27;</span>, <span class="string">&#x27;blue&#x27;</span>, <span class="string">&#x27;green&#x27;</span>, <span class="string">&#x27;red&#x27;</span>, <span class="string">&#x27;yellow&#x27;</span>]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Initial:      <span class="subst">&#123;color&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line">color.append(<span class="string">&#x27;black&#x27;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;After append:   <span class="subst">&#123;color&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line">color.insert(<span class="number">1</span>,<span class="string">&#x27;red&#x27;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;After insert:   <span class="subst">&#123;color&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line">color.remove(<span class="string">&#x27;red&#x27;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;After remove:   <span class="subst">&#123;color&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>5. 对于列表 <code>test_list = [5, 4, 3, 2, 1]</code> 而言，下列不能输出 <code>[1, 2, 3, 4, 5]</code> 的是（ ）</strong><br>A. <code>test_list[::-1]</code><br>B. <code>list(reversed(test_list))</code><br>C. <code>sorted(test_list)</code><br>D. <code>test_list[0:-5:1]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `test_list[::-1]`</b>：这是列表切片的反转用法，表示从头到尾以步长 -1 进行切片，结果为 `[1, 2, 3, 4, 5]`。</li>    <li><b>B. `list(reversed(test_list))`</b>：<code>reversed()</code> 函数返回一个反向迭代器，<code>list()</code> 将其转换为列表，结果为 `[1, 2, 3, 4, 5]`。</li>    <li><b>C. `sorted(test_list)`</b>：<code>sorted()</code> 函数对列表进行排序并返回一个新列表，结果为 `[1, 2, 3, 4, 5]`。</li>    <li><b>D. `test_list[0:-5:1]`</b>：这是一个列表切片，从索引 0 开始，到索引 -5（即列表中的元素 `5`）结束（不包括索引-5），步长为 1。这个切片范围是空的，因此结果是一个空列表 `[]`。</li>  </ul><p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">test_list = [<span class="number">5</span>, <span class="number">4</span>, <span class="number">3</span>, <span class="number">2</span>, <span class="number">1</span>]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;A: <span class="subst">&#123;test_list[::-<span class="number">1</span>]&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;B: <span class="subst">&#123;<span class="built_in">list</span>(<span class="built_in">reversed</span>(test_list))&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;C: <span class="subst">&#123;<span class="built_in">sorted</span>(test_list)&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;D: <span class="subst">&#123;test_list[<span class="number">0</span>:-<span class="number">5</span>:<span class="number">1</span>]&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>6. 对于以下二元操作符，其描述为 a 的 b 次方的是（ ）</strong><br>A. <code>a^b</code><br>B. <code>a**b</code><br>C. <code>a*b</code><br>D. <code>a//b</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `a^b`</b>：在 Python 中，`^` 是按位异或运算符。</li>    <li><b>B. `a**b`</b>：在 Python 中，`**` 是幂运算符，表示 a 的 b 次方。</li>    <li><b>C. `a*b`</b>：在 Python 中，`*` 是乘法运算符。</li>    <li><b>D. `a//b`</b>：在 Python 中，`//` 是整除运算符。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">a = <span class="number">2</span></span><br><span class="line">b = <span class="number">3</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a^b (按位异或): <span class="subst">&#123;a^b&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a**b (幂运算): <span class="subst">&#123;a**b&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a*b (乘法): <span class="subst">&#123;a*b&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a//b (整除): <span class="subst">&#123;a//b&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>7. 存在一个列表为 <code>a = [1, 2, 3]</code>，下列的操作中错误的是（ ）</strong><br>A. <code>a + 4</code><br>B. <code>a + [4]</code><br>C. <code>a + a</code><br>D. <code>a * 4</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  在 Python 中，列表的 `+` 运算符用于列表的拼接，`*` 运算符用于重复。  <ul>    <li><b>A. `a + 4`</b>：尝试将一个列表与一个整数相加，这会导致 <code>TypeError</code>，因为它们是不同类型的操作数。</li>    <li><b>B. `a + [4]`</b>：将列表 `a` 与另一个列表 `[4]` 进行拼接，是合法的，结果为 `[1, 2, 3, 4]`。</li>    <li><b>C. `a + a`</b>：将列表 `a` 与自身进行拼接，是合法的，结果为 `[1, 2, 3, 1, 2, 3]`。</li>    <li><b>D. `a * 4`</b>：将列表 `a` 重复 4 次，是合法的，结果为 `[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]`。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line">a = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a + [4]: <span class="subst">&#123;a + [<span class="number">4</span>]&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a + a: <span class="subst">&#123;a + a&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a * 4: <span class="subst">&#123;a * <span class="number">4</span>&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># A. a + 4 (This will cause an error)</span></span><br><span class="line"><span class="keyword">try</span>:</span><br><span class="line">  <span class="built_in">print</span>(<span class="string">f&quot;a + 4: <span class="subst">&#123;a + <span class="number">4</span>&#125;</span>&quot;</span>)</span><br><span class="line"><span class="keyword">except</span> TypeError <span class="keyword">as</span> e:</span><br><span class="line">  <span class="built_in">print</span>(<span class="string">f&quot;Error for a + 4: <span class="subst">&#123;e&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>8. 对于下列代码 <code>a=1; type(a); bool(a)</code> 在交互式环境中逐行执行，最终输出的结果为（ ）</strong><br>A. int;True<br>B. float;True<br>C. int;False<br>D. float;False</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`a = 1`</b>：将整数值 1 赋给变量 `a`。</li>    <li><b>`type(a)`</b>：<code>type()</code> 函数返回对象的类型。因为 `a` 是整数 1，其类型为 <code>&lt;class 'int'&gt;</code>。</li>    <li><b>`bool(a)`</b>：<code>bool()</code> 函数将值转换为布尔类型。在 Python 中，非零数字（包括1）转换为布尔值时都为 `True`。</li>  </ol>  虽然代码分行，但题目问的是最终结果，暗示了这两个函数的返回值。因此，类型是 `int`，布尔值是 `True`。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">a = <span class="number">1</span></span><br><span class="line"><span class="built_in">print</span>(<span class="built_in">type</span>(a))</span><br><span class="line"><span class="built_in">print</span>(<span class="built_in">bool</span>(a))</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>9. 设 <code>a=[2, 3, 7]; b=list(a)</code>，执行 <code>a is b</code> 和 <code>a == b</code> 得到的输出分别是（ ）</strong><br>A. False,False<br>B. False,True<br>C. True,False<br>D. True,True</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`a is b`</b>：`is` 运算符检查两个变量是否引用内存中的<b>同一个对象</b>。`b = list(a)` 通过 `list()` 构造函数创建了 `a` 的一个新副本，所以 `a` 和 `b` 指向不同的内存地址。因此 `a is b` 的结果是 `False`。</li>    <li><b>`a == b`</b>：`==` 运算符检查两个对象的<b>值是否相等</b>。由于 `a` 和 `b` 包含完全相同的元素且顺序一致，它们的值是相等的。因此 `a == b` 的结果是 `True`。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line">a = [<span class="number">2</span>, <span class="number">3</span>, <span class="number">7</span>]</span><br><span class="line">b = <span class="built_in">list</span>(a)</span><br><span class="line"></span><br><span class="line"><span class="comment"># a 和 b 的内存地址不同</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;id of a: <span class="subst">&#123;<span class="built_in">id</span>(a)&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;id of b: <span class="subst">&#123;<span class="built_in">id</span>(b)&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a is b: <span class="subst">&#123;a <span class="keyword">is</span> b&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a == b: <span class="subst">&#123;a == b&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>10. 下列代码的输出是（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">t = <span class="number">2</span></span><br><span class="line"><span class="keyword">def</span> <span class="title function_">a</span>(<span class="params">x</span>):</span><br><span class="line">  <span class="keyword">return</span> x ** t</span><br><span class="line"><span class="built_in">print</span>(a(a(<span class="number">3</span>)))</span><br></pre></td></tr></table></figure><p>A. 9<br>B. 27<br>C. 81<br>D. 243</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  代码执行过程分析：  <ol>    <li><b>`t = 2`</b>：定义了一个全局变量 `t`。</li>    <li><b>`def a(x): ...`</b>：定义了一个函数 `a`，它会引用全局变量 `t`。</li>    <li><b>`print(a(a(3)))`</b>：这是一个嵌套函数调用。        <ul>            <li>首先计算内层 <b>`a(3)`</b>：`x` 为 `3`，函数返回 `3 ** t`，即 `3 ** 2`，结果为 `9`。</li>            <li>然后计算外层 <b>`a(9)`</b>：`x` 为 `9`，函数返回 `9 ** t`，即 `9 ** 2`，结果为 `81`。</li>        </ul>    </li>  </ol>  因此，最终输出是 `81`。<p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line">t = <span class="number">2</span></span><br><span class="line"><span class="keyword">def</span> <span class="title function_">a</span>(<span class="params">x</span>):</span><br><span class="line">  <span class="keyword">return</span> x ** t</span><br><span class="line"></span><br><span class="line">inner_result = a(<span class="number">3</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a(3) = <span class="subst">&#123;inner_result&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line">outer_result = a(inner_result)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a(a(3)) which is a(9) = <span class="subst">&#123;outer_result&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>11. 下面不可以作为字典的键的是 （ ）</strong><br>A. <code>tuple([1,2,3,4])</code><br>B. <code>(1, 2, (1, 2, 3))</code><br>C. <code>(1, 2, [1, 2])</code><br>D. <code>1</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  Python 字典的键必须是<b>可哈希 (hashable)</b> 的对象。通常，<b>不可变 (immutable)</b> 对象是可哈希的，而<b>可变 (mutable)</b> 对象是不可哈希的。  <ul>    <li><b>A. `tuple([1,2,3,4])`</b>：这会创建一个元组 `(1, 2, 3, 4)`。元组是不可变的，因此可哈希。</li>    <li><b>B. `(1, 2, (1, 2, 3))`</b>：这是一个嵌套元组，所有元素都是不可变的，因此可哈希。</li>    <li><b>C. `(1, 2, [1, 2])`</b>：这是一个元组，但它的第三个元素是列表 `[1, 2]`。列表是可变对象，因此是不可哈希的。一个元组如果包含了不可哈希的元素，那么它自身也变得不可哈希。</li>    <li><b>D. `1`</b>：整数是不可变对象，因此可哈希。</li>  </ul><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br></pre></td><td class="code"><pre><span class="line">my_dict = &#123;&#125;</span><br><span class="line"></span><br><span class="line"><span class="comment"># A. Correct</span></span><br><span class="line">my_dict[<span class="built_in">tuple</span>([<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>,<span class="number">4</span>])] = <span class="string">&#x27;A&#x27;</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># B. Correct</span></span><br><span class="line">my_dict[(<span class="number">1</span>, <span class="number">2</span>, (<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>))] = <span class="string">&#x27;B&#x27;</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># D. Correct</span></span><br><span class="line">my_dict[<span class="number">1</span>] = <span class="string">&#x27;D&#x27;</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># C. Incorrect (will raise TypeError)</span></span><br><span class="line"><span class="keyword">try</span>:</span><br><span class="line">    my_dict[(<span class="number">1</span>, <span class="number">2</span>, [<span class="number">1</span>, <span class="number">2</span>])] = <span class="string">&#x27;C&#x27;</span></span><br><span class="line"><span class="keyword">except</span> TypeError <span class="keyword">as</span> e:</span><br><span class="line">    <span class="built_in">print</span>(<span class="string">f&quot;Error for (1, 2, [1, 2]): <span class="subst">&#123;e&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(my_dict)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>12. 对于代码 <code>a=[1,2,3]; b=a ; a.append(4); c=list(a)</code> 以下输出结果为False的是（ ）</strong><br>A. <code>a == c</code><br>B. <code>a is c</code><br>C. <code>a == b</code><br>D. <code>a is b</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  让我们逐步分析代码：  <ol>    <li><b>`a = [1,2,3]`</b>：创建列表 `[1,2,3]`，变量 `a` 引用它。</li>    <li><b>`b = a`</b>：变量 `b` 引用 `a` 所指向的<b>同一个列表对象</b>。</li>    <li><b>`a.append(4)`</b>：修改 `a` 引用的列表。因为 `a` 和 `b` 指向同一个对象，所以 `b` 的值也随之改变。此时 `a` 和 `b` 都指向 `[1, 2, 3, 4]`。</li>    <li><b>`c = list(a)`</b>：通过 `list()` 创建 `a` 的一个<b>新副本</b>。此时 `c` 是一个值为 `[1, 2, 3, 4]` 的新列表。</li>  </ol>  现在评估每个选项：  <ul>    <li><b>A. `a == c`</b>：比较值。`a` 和 `c` 的值都是 `[1, 2, 3, 4]`，所以结果为 `True`。</li>    <li><b>B. `a is c`</b>：比较内存地址。`a` 和 `c` 是两个不同的对象，所以结果为 `False`。</li>    <li><b>C. `a == b`</b>：比较值。`a` 和 `b` 指向同一个对象，值必然相等，所以结果为 `True`。</li>    <li><b>D. `a is b`</b>：比较内存地址。`a` 和 `b` 指向同一个对象，所以结果为 `True`。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line">a = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]</span><br><span class="line">b = a</span><br><span class="line">a.append(<span class="number">4</span>)</span><br><span class="line">c = <span class="built_in">list</span>(a)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a = <span class="subst">&#123;a&#125;</span>, id = <span class="subst">&#123;<span class="built_in">id</span>(a)&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;b = <span class="subst">&#123;b&#125;</span>, id = <span class="subst">&#123;<span class="built_in">id</span>(b)&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;c = <span class="subst">&#123;c&#125;</span>, id = <span class="subst">&#123;<span class="built_in">id</span>(c)&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;\na == c: <span class="subst">&#123;a == c&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a is c: <span class="subst">&#123;a <span class="keyword">is</span> c&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a == b: <span class="subst">&#123;a == b&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a is b: <span class="subst">&#123;a <span class="keyword">is</span> b&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>13. 下列代码<code>a = &#39;&#123;0:.2f&#125;&#123;0:d&#125;&#123;1:s&#125;&#39;.format(int(&#39;10&#39;), 5.0, 5) ; print(a)</code> 执行结果为（ ）</strong><br>A. 10.00105.0<br>B. 10.0055<br>C. 105.05<br>D. 会报错</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  此题考察 `str.format()` 方法中格式码的严格类型对应。  <ul>    <li><b>`{0:.2f}`</b> 和 <b>`{0:d}`</b> 分别将第一个参数 `10` 格式化为浮点数和整数，是正确的。</li>    <li><b>`{1:s}`</b>：`s` 格式码被设计用于字符串类型。当它被用于非字符串类型（如本题中的浮点数 `5.0`）时，根据题目的考察意图，这被视为类型不匹配，会导致 `TypeError`。</li>  </ul>  因此，这段代码被认为会引发错误。<p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 以下代码模拟了题目所考察的严格类型检查场景。</span></span><br><span class="line"><span class="comment"># 注意：在标准的现代Python中，此代码实际上不会报错。</span></span><br><span class="line"><span class="keyword">try</span>:</span><br><span class="line">  <span class="comment"># 假设一个严格的实现，其中 :s 仅接受字符串</span></span><br><span class="line">  param = <span class="number">5.0</span></span><br><span class="line">  <span class="keyword">if</span> <span class="keyword">not</span> <span class="built_in">isinstance</span>(param, <span class="built_in">str</span>):</span><br><span class="line">      <span class="keyword">raise</span> TypeError(<span class="string">f&quot;Unknown format code &#x27;s&#x27; for object of type &#x27;<span class="subst">&#123;<span class="built_in">type</span>(param).__name__&#125;</span>&#x27;&quot;</span>)</span><br><span class="line">  a = <span class="string">&#x27;&#123;0:.2f&#125;&#123;0:d&#125;&#123;1:s&#125;&#x27;</span>.<span class="built_in">format</span>(<span class="built_in">int</span>(<span class="string">&#x27;10&#x27;</span>), param, <span class="number">5</span>)</span><br><span class="line">  <span class="built_in">print</span>(a)</span><br><span class="line"><span class="keyword">except</span> TypeError <span class="keyword">as</span> e:</span><br><span class="line">  <span class="built_in">print</span>(<span class="string">f&quot;Error (as per question&#x27;s logic): <span class="subst">&#123;e&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 实际的标准Python行为</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n--- Actual Python 3 Behavior ---&quot;</span>)</span><br><span class="line">a_real = <span class="string">&#x27;&#123;0:.2f&#125;&#123;0:d&#125;&#123;1:s&#125;&#x27;</span>.<span class="built_in">format</span>(<span class="built_in">int</span>(<span class="string">&#x27;10&#x27;</span>), <span class="number">5.0</span>, <span class="number">5</span>)</span><br><span class="line"><span class="built_in">print</span>(a_real)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>14. 对于以下代码 <code>a = &quot;Hello world&quot; ;a[0] = &quot;h&quot; ; print(a)</code> 运行结果为（ ）</strong><br>A. “hello world”<br>B. “hHello world”<br>C. “Hhello world”<br>D. 报错</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  在 Python 中，字符串是<b>不可变 (immutable)</b> 对象。这意味着一旦字符串被创建，它的任何部分都不能被修改。  代码 `a[0] = "h"` 尝试通过索引赋值来修改字符串的第一个字符，这违反了字符串的不可变性，因此会引发 `TypeError`。<p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">a = <span class="string">&quot;Hello world&quot;</span></span><br><span class="line"><span class="keyword">try</span>:</span><br><span class="line">  a[<span class="number">0</span>] = <span class="string">&quot;h&quot;</span></span><br><span class="line">  <span class="built_in">print</span>(a)</span><br><span class="line"><span class="keyword">except</span> TypeError <span class="keyword">as</span> e:</span><br><span class="line">  <span class="built_in">print</span>(<span class="string">f&quot;Error: <span class="subst">&#123;e&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>15. 设 <code>seq = [7, 2, 3, 7, 5, 6, 0, 1]</code>，执行 <code>seq[3:4] = [6, 3]</code> 之后，<code>seq</code> 的值是（ ）</strong><br>A. <code>[7, 2, 3, 6, 3, 5, 6, 0, 1]</code><br>B. <code>[7, 2, 6, 3, 7, 5, 6, 0, 1]</code><br>C. <code>[7, 2, 3, 6, 5, 6, 0, 1]</code><br>D. <code>[7, 2, 6, 3, 5, 6, 0, 1]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  这是列表的切片赋值操作。  <ol>    <li><b>`seq = [7, 2, 3, 7, 5, 6, 0, 1]`</b>：初始列表。</li>    <li><b>`seq[3:4]`</b>：这是一个切片，选中从索引 3 开始到索引 4 结束（不包括4）的元素，即 `[7]`。</li>    <li><b>`seq[3:4] = [6, 3]`</b>：将切片 `[7]` 替换为新的列表 `[6, 3]`。这个操作会用新列表的内容替换掉原切片所占的位置。</li>  </ol>  原列表 `[7, 2, 3, | 7, | 5, 6, 0, 1]` 中的 `7` 被 `[6, 3]` 替换，得到 `[7, 2, 3, 6, 3, 5, 6, 0, 1]`。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">seq = [<span class="number">7</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">7</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">0</span>, <span class="number">1</span>]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Initial seq: <span class="subst">&#123;seq&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line">seq[<span class="number">3</span>:<span class="number">4</span>] = [<span class="number">6</span>, <span class="number">3</span>]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Final seq:   <span class="subst">&#123;seq&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>16. 以下是不可变对象的是（ ）</strong><br>A．列表<br>B. 字典<br>C. Numpy数组<br>D. 字符串</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. 列表 (list)</b>：列表是可变的，可以添加、删除或修改其元素。</li>    <li><b>B. 字典 (dict)</b>：字典是可变的，可以添加、删除或修改键值对。</li>    <li><b>C. Numpy 数组 (numpy.ndarray)</b>：Numpy 数组是可变的，可以修改其元素。</li>    <li><b>D. 字符串 (str)</b>：字符串是不可变的，一旦创建，其内容就不能被修改。</li>  </ul><p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 列表是可变的</span></span><br><span class="line">my_list = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]</span><br><span class="line">my_list[<span class="number">0</span>] = <span class="number">100</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Modified list: <span class="subst">&#123;my_list&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 字典是可变的</span></span><br><span class="line">my_dict = &#123;<span class="string">&#x27;a&#x27;</span>: <span class="number">1</span>&#125;</span><br><span class="line">my_dict[<span class="string">&#x27;a&#x27;</span>] = <span class="number">100</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Modified dict: <span class="subst">&#123;my_dict&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 字符串是不可变的 (会报错)</span></span><br><span class="line">my_string = <span class="string">&quot;hello&quot;</span></span><br><span class="line"><span class="keyword">try</span>:</span><br><span class="line">    my_string[<span class="number">0</span>] = <span class="string">&#x27;H&#x27;</span></span><br><span class="line"><span class="keyword">except</span> TypeError <span class="keyword">as</span> e:</span><br><span class="line">    <span class="built_in">print</span>(<span class="string">f&quot;Error when modifying string: <span class="subst">&#123;e&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>17. 代码 <code>a=[1,2]; b=[3,4,5] ; c=[6,7,8,9]; len(tuple(zip(a,b,c)))</code> 的输出为（ ）</strong><br>A. 1<br>B. 2<br>C. 3<br>D. 4</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`zip(a, b, c)`</b>：`zip()` 函数将多个可迭代对象中对应位置的元素打包成元组。`zip()` 的长度由<b>最短</b>的可迭代对象的长度决定。</li>    <li>在这里，`a` 的长度是 2，`b` 是 3，`c` 是 4。最短的是 `a`，长度为 2。</li>    <li>因此，`zip()` 会生成 2 个元组：`(1, 3, 6)` 和 `(2, 4, 7)`。</li>    <li><b>`tuple(...)`</b>：将 `zip` 对象的结果转换为一个元组，得到 `((1, 3, 6), (2, 4, 7))`。</li>    <li><b>`len(...)`</b>：获取这个元组的长度，它包含 2 个子元组，所以长度为 2。</li>  </ol><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line">a = [<span class="number">1</span>, <span class="number">2</span>]</span><br><span class="line">b = [<span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>]</span><br><span class="line">c = [<span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>]</span><br><span class="line"></span><br><span class="line">zipped_tuple = <span class="built_in">tuple</span>(<span class="built_in">zip</span>(a, b, c))</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Zipped tuple: <span class="subst">&#123;zipped_tuple&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line">length = <span class="built_in">len</span>(zipped_tuple)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Length: <span class="subst">&#123;length&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>18. 设 <code>a=[1, 2, 3]</code>, 执行 <code>b=a; a.append(3)</code> 之后输出 <code>b</code> 的值是（ ）</strong><br>A. <code>[1, 2, 3]</code><br>B. <code>[1, 2]</code><br>C. <code>[1, 2, 3, 3]</code><br>D. <code>[1, 2, 3, 3, 3]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`a = [1, 2, 3]`</b>：创建一个列表，`a` 引用它。</li>    <li><b>`b = a`</b>：这不是复制，而是将 `b` 指向 `a` 所引用的<b>同一个列表对象</b>。</li>    <li><b>`a.append(3)`</b>：修改 `a` 引用的列表。因为 `a` 和 `b` 指向同一个对象，所以通过 `a` 修改列表，`b` 也会看到这个变化。列表变为 `[1, 2, 3, 3]`。</li>  </ol>  因此，输出 `b` 的值将是 `[1, 2, 3, 3]`。<p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">a = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]</span><br><span class="line">b = a</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Before modification, a is b: <span class="subst">&#123;a <span class="keyword">is</span> b&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line">a.append(<span class="number">3</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;After modification, a = <span class="subst">&#123;a&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;After modification, b = <span class="subst">&#123;b&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>19. 下列代码的输出是（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">my_list = [<span class="number">11</span>, <span class="number">12</span>, <span class="number">13</span>, <span class="number">12</span>, <span class="number">15</span>, <span class="number">16</span>, <span class="number">13</span>, <span class="number">14</span>]</span><br><span class="line">a = <span class="built_in">set</span>(my_list)</span><br><span class="line"><span class="built_in">print</span>([x <span class="keyword">for</span> x <span class="keyword">in</span> a <span class="keyword">if</span> x &gt; <span class="number">11</span>])</span><br></pre></td></tr></table></figure><p>A. <code>[12, 13, 12, 15, 16, 13, 14]</code><br>B. <code>[11, 12, 13, 12, 15, 16, 13, 14]</code><br>C. <code>[12, 13, 15, 16, 14]</code><br>D. <code>[12, 13, 14, 15, 16]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`a = set(my_list)`</b>：`set()` 会从列表中创建一个集合，集合的特性是<b>无序</b>且<b>元素唯一</b>。因此，`a` 变为 `{11, 12, 13, 14, 15, 16}`。</li>    <li><b>`[x for x in a if x > 11]`</b>：这是一个列表推导式，遍历集合 `a`，筛选出所有大于 11 的元素。这些元素是 `12, 13, 14, 15, 16`。</li>    <li><b>输出顺序</b>：从 Python 3.7 开始，`set` 的迭代顺序是插入顺序。但 `set()` 从列表创建集合的内部顺序不保证与原列表一致。不过，对于选择题，通常会展示一个<b>有序</b>的结果作为标准答案。</li>  </ol>  将筛选出的元素 `{12, 13, 14, 15, 16}` 排序后，得到 `[12, 13, 14, 15, 16]`。<p>  <strong>正确答案：</strong> D (通常选择题会提供排序后的结果)</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">my_list = [<span class="number">11</span>, <span class="number">12</span>, <span class="number">13</span>, <span class="number">12</span>, <span class="number">15</span>, <span class="number">16</span>, <span class="number">13</span>, <span class="number">14</span>]</span><br><span class="line">a = <span class="built_in">set</span>(my_list)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Set a: <span class="subst">&#123;a&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line">result = [x <span class="keyword">for</span> x <span class="keyword">in</span> a <span class="keyword">if</span> x &gt; <span class="number">11</span>]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Result (actual output may vary in order): <span class="subst">&#123;result&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Result (sorted for comparison): <span class="subst">&#123;<span class="built_in">sorted</span>(result)&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>20. 下面对列表 <code>a = [1, 2, 3, 4, 5, 6, 7, 8, 9]</code> 的操作，得到的结果正确的是（ ）</strong><br>A. <code>c = a[::-2]</code>, c为 <code>[1, 3, 5, 7, 9]</code><br>B. <code>c = a[::3]</code>, c为 <code>[1, 4, 7]</code><br>C. <code>c = a[:-1]</code>, c为 <code>[1, 2, 3, 4, 5, 6, 7, 8, 9]</code><br>D. <code>c = a[-4:]</code>, c为 <code>[5, 6, 7, 8, 9]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `c = a[::-2]`</b>：从后向前反向切片，步长为2。结果为 `[9, 7, 5, 3, 1]`。所以 A 错误。</li>    <li><b>B. `c = a[::3]`</b>：从头到尾正向切片，步长为3。取索引 0, 3, 6 的元素。结果为 `[1, 4, 7]`。所以 B 正确。</li>    <li><b>C. `c = a[:-1]`</b>：切片从头开始，到倒数第一个元素之前结束。结果为 `[1, 2, 3, 4, 5, 6, 7, 8]`。所以 C 错误。</li>    <li><b>D. `c = a[-4:]`</b>：切片从倒数第四个元素开始，到末尾结束。结果为 `[6, 7, 8, 9]`。所以 D 错误。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">a = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a[::-2] is <span class="subst">&#123;a[::-<span class="number">2</span>]&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a[::3] is <span class="subst">&#123;a[::<span class="number">3</span>]&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a[:-1] is <span class="subst">&#123;a[:-<span class="number">1</span>]&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a[-4:] is <span class="subst">&#123;a[-<span class="number">4</span>:]&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>21. 下面对于列表的操作方法的叙述，错误的是（ ）</strong><br>A. 使用insert方法可以将元素插入到指定的列表位置。<br>B. 使用pop方法可以将特定位置的元素移除并返回。<br>C. 使用append方法可以将元素添加到列表的尾部。<br>D. 使用remove方法可以移除列表中所有符合要求的值。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `insert()`</b>：`list.insert(index, element)` 将元素插入到指定 `index` 位置。叙述正确。</li>    <li><b>B. `pop()`</b>：`list.pop(index)` 移除指定 `index` 位置的元素并返回该元素。叙述正确。</li>    <li><b>C. `append()`</b>：`list.append(element)` 将元素添加到列表的末尾。叙述正确。</li>    <li><b>D. `remove()`</b>：`list.remove(value)` 仅移除列表中<b>第一个</b>匹配到的 `value`。它不会移除所有符合要求的值。叙述错误。</li>  </ul><p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line">my_list = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">2</span>, <span class="number">4</span>]</span><br><span class="line">my_list.remove(<span class="number">2</span>) <span class="comment"># 只移除了第一个2</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;After single remove: <span class="subst">&#123;my_list&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 要移除所有2，需要循环或列表推导式</span></span><br><span class="line">my_list = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">2</span>, <span class="number">4</span>]</span><br><span class="line">my_list_all_removed = [x <span class="keyword">for</span> x <span class="keyword">in</span> my_list <span class="keyword">if</span> x != <span class="number">2</span>]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;After removing all 2s: <span class="subst">&#123;my_list_all_removed&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>22. 下面对字典 <code>d = &#123;&#39;a&#39; : &#39;some value&#39;, &#39;b&#39; : [1, 2, 3, 4]&#125;</code> 的操作的叙述，错误的是（ ）</strong><br>A. <code>&#39;a&#39; in d</code>, 返回True.<br>B. <code>&#39;some value&#39; in d</code>, 返回True<br>C. <code>print(d.pop(&#39;a&#39;))</code>, 输出结果为some value<br>D. <code>d.update(&#123;&#39;b&#39;: 1&#125;)</code>, d改变为 <code>&#123;&#39;a&#39;: &#39;some value&#39;, &#39;b&#39;: 1&#125;</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `'a' in d`</b>：`in` 运算符默认检查字典的<b>键</b>。字典 `d` 中存在键 `'a'`，所以返回 `True`。叙述正确。</li>    <li><b>B. `'some value' in d`</b>：`in` 运算符检查的是键，不是值。`'some value'` 是一个值，不是键，所以返回 `False`。叙述错误。 (要检查值，应使用 `d.values()`)</li>    <li><b>C. `print(d.pop('a'))`</b>：`pop('a')` 会移除键 `'a'` 及其对应的值，并返回被移除的值 `'some value'`。叙述正确。</li>    <li><b>D. `d.update({'b': 1})`</b>：`update()` 方法会用新字典更新原字典。键 `'b'` 已存在，其值会被更新为 `1`。叙述正确。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">d_test = &#123;<span class="string">&#x27;a&#x27;</span>: <span class="string">&#x27;some value&#x27;</span>, <span class="string">&#x27;b&#x27;</span>: [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>]&#125;</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;&#x27;a&#x27; in d_test: <span class="subst">&#123;<span class="string">&#x27;a&#x27;</span> <span class="keyword">in</span> d_test&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;&#x27;some value&#x27; in d_test: <span class="subst">&#123;<span class="string">&#x27;some value&#x27;</span> <span class="keyword">in</span> d_test&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;&#x27;some value&#x27; in d_test.values(): <span class="subst">&#123;<span class="string">&#x27;some value&#x27;</span> <span class="keyword">in</span> d_test.values()&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>23. 对于以下代码 <code>a = (3, 4, (5, 6)); a[1] = &#39;four&#39;</code> 运行结果为（ ）</strong><br>A. <code>(&#39;four&#39;, 4, (5, 6))</code><br>B. <code>(3, 4, &#39;four&#39;, (5, 6))</code><br>C. <code>TypeError</code><br>D. <code>(3, &#39;four&#39;, (5, 6))</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  在 Python 中，元组 (tuple) 是<b>不可变 (immutable)</b> 对象。这意味着一旦创建了一个元组，就不能修改其任何元素。  代码 `a[1] = 'four'` 尝试通过索引赋值的方式修改元组，这会引发 `TypeError`。<p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">a = (<span class="number">3</span>, <span class="number">4</span>, (<span class="number">5</span>, <span class="number">6</span>))</span><br><span class="line"><span class="keyword">try</span>:</span><br><span class="line">    a[<span class="number">1</span>] = <span class="string">&#x27;four&#x27;</span></span><br><span class="line">    <span class="built_in">print</span>(a)</span><br><span class="line"><span class="keyword">except</span> TypeError <span class="keyword">as</span> e:</span><br><span class="line">    <span class="built_in">print</span>(<span class="string">f&quot;Error: <span class="subst">&#123;e&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>24. 下面代码的结果是（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">lambdas = [<span class="keyword">lambda</span>: i <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">10</span>)]</span><br><span class="line">result = lambdas[<span class="number">0</span>]()</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure><p>A. 0<br>B. 1<br>C. 9<br>D. 10</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  这是一个关于闭包 (closure) 和变量作用域的经典问题。  <ol>    <li><b>`lambdas = [lambda: i for i in range(10)]`</b>：这个列表推导式创建了一个包含 10 个 `lambda` 函数的列表。</li>    <li><b>关键点</b>：这些 `lambda` 函数在定义时，并没有捕获 `i` 在每次迭代时的值，而是捕获了变量 `i` 本身。这被称为<b>延迟绑定</b>。</li>    <li>当列表推导式循环<b>结束时</b>，变量 `i` 的最终值是 `9`。</li>    <li><b>`result = lambdas[0]()`</b>：这行代码调用列表中的第一个 `lambda` 函数。当函数被<b>调用时</b>，它会去查找它所引用的变量 `i` 的当前值。此时 `i` 的值已经是 `9`。</li>  </ol>  因此，调用列表中任何一个 `lambda` 函数，都会返回 `9`。<p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line">lambdas = [<span class="keyword">lambda</span>: i <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">10</span>)]</span><br><span class="line">result = lambdas[<span class="number">0</span>]()</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Result of lambdas[0](): <span class="subst">&#123;result&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Result of lambdas[5](): <span class="subst">&#123;lambdas[<span class="number">5</span>]()&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 如果想捕获每次迭代的值，需要这样做：</span></span><br><span class="line">fixed_lambdas = [<span class="keyword">lambda</span> val=i: val <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">10</span>)]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;\nFixed result of fixed_lambdas[0](): <span class="subst">&#123;fixed_lambdas[<span class="number">0</span>]()&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Fixed result of fixed_lambdas[5](): <span class="subst">&#123;fixed_lambdas[<span class="number">5</span>]()&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>25. 下面代码的结果是（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">a = [[<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;i&#x27;</span>],</span><br><span class="line">     [<span class="string">&#x27;i&#x27;</span>,<span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>],</span><br><span class="line">     [<span class="string">&#x27;c&#x27;</span>, <span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;i&#x27;</span>, <span class="string">&#x27;c&#x27;</span>],</span><br><span class="line">     [<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;i&#x27;</span>,<span class="string">&#x27;a&#x27;</span>]]</span><br><span class="line">b = [i <span class="keyword">for</span> i, x <span class="keyword">in</span> <span class="built_in">enumerate</span>(a) <span class="keyword">if</span> x.index(<span class="string">&#x27;i&#x27;</span>) &gt; <span class="number">1</span>]</span><br><span class="line"><span class="built_in">print</span>(b)</span><br></pre></td></tr></table></figure><p>A. <code>[0, 2, 3]</code><br>B. <code>[0, 1, 2, 3]</code><br>C. <code>[[&#39;a&#39;, &#39;b&#39;, &#39;a&#39;, &#39;i&#39;],[&#39;c&#39;, &#39;a&#39;,&#39;i&#39;, &#39;c&#39;],[&#39;a&#39;,&#39;b&#39;,&#39;c&#39;,&#39;c&#39;,&#39;i&#39;,&#39;a&#39;]]</code><br>D. <code>[[&#39;a&#39;, &#39;b&#39;, &#39;a&#39;, &#39;i&#39;], [&#39;i&#39;,&#39;b&#39;, &#39;b&#39;, &#39;c&#39;],[&#39;c&#39;, &#39;a&#39;,&#39;i&#39;, &#39;c&#39;],[&#39;a&#39;,&#39;b&#39;,&#39;c&#39;,&#39;c&#39;,&#39;i&#39;,&#39;a&#39;]]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  这是一个列表推导式，`enumerate(a)` 会生成每个子列表的索引 `i` 和值 `x`。条件是 `x.index('i') > 1`，即子列表中 `'i'` 首次出现的索引大于 1。  我们逐个检查子列表：  <ul>    <li><b>索引 0: `['a', 'b', 'a', 'i']`</b>。`'i'` 的索引是 3。`3 > 1` 为 `True`。保留索引 `0`。</li>    <li><b>索引 1: `['i','b', 'b', 'c']`</b>。`'i'` 的索引是 0。`0 > 1` 为 `False`。丢弃索引 `1`。</li>    <li><b>索引 2: `['c', 'a','i', 'c']`</b>。`'i'` 的索引是 2。`2 > 1` 为 `True`。保留索引 `2`。</li>    <li><b>索引 3: `['a','b','c','c','i','a']`</b>。`'i'` 的索引是 4。`4 > 1` 为 `True`。保留索引 `3`。</li>  </ul>  因此，最终列表 `b` 的结果是 `[0, 2, 3]`。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">a = [[<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;i&#x27;</span>],</span><br><span class="line">     [<span class="string">&#x27;i&#x27;</span>,<span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>],</span><br><span class="line">     [<span class="string">&#x27;c&#x27;</span>, <span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;i&#x27;</span>, <span class="string">&#x27;c&#x27;</span>],</span><br><span class="line">     [<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;i&#x27;</span>,<span class="string">&#x27;a&#x27;</span>]]</span><br><span class="line"></span><br><span class="line">b = [i <span class="keyword">for</span> i, x <span class="keyword">in</span> <span class="built_in">enumerate</span>(a) <span class="keyword">if</span> x.index(<span class="string">&#x27;i&#x27;</span>) &gt; <span class="number">1</span>]</span><br><span class="line"><span class="built_in">print</span>(b)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>26. 执行下面代码的结果是( )</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">seq1=[(<span class="string">&#x27;foo&#x27;</span>,<span class="string">&#x27;bar&#x27;</span>),(<span class="string">&#x27;one&#x27;</span>,<span class="string">&#x27;two&#x27;</span>)]</span><br><span class="line">a, b = <span class="built_in">zip</span>(*seq1)</span><br><span class="line"><span class="built_in">print</span>(a)</span><br></pre></td></tr></table></figure><p>A. <code>[&#39;foo&#39;,&#39;bar&#39;]</code><br>B. <code>(&#39;foo&#39;,&#39;bar&#39;)</code><br>C. <code>[&#39;foo&#39;,&#39;one&#39;]</code><br>D. <code>(&#39;foo&#39;,&#39;one&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `zip(*seq1)` 是一个常见的用于“解压”或“转置”的操作。  <ol>    <li><b>`*seq1`</b>：这里的 `*` 是解包运算符。它会将 `seq1` 列表中的元素解开，作为独立的参数传给 `zip`。所以 `zip(*seq1)` 相当于 `zip(('foo', 'bar'), ('one', 'two'))`。</li>    <li><b>`zip(...)`</b>：`zip` 会将传入的多个序列中对应位置的元素打包。        <ul>            <li>第一个元素 `('foo', 'one')`</li>            <li>第二个元素 `('bar', 'two')`</li>        </ul>    </li>    <li><b>`a, b = ...`</b>：这是一个解包赋值。`a` 会得到第一个元组，`b` 会得到第二个。        <ul>            <li>`a` 被赋值为 `('foo', 'one')`。</li>            <li>`b` 被赋值为 `('bar', 'two')`。</li>        </ul>    </li>    <li><b>`print(a)`</b>：打印 `a` 的值。</li>  </ol><p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">seq1=[(<span class="string">&#x27;foo&#x27;</span>,<span class="string">&#x27;bar&#x27;</span>),(<span class="string">&#x27;one&#x27;</span>,<span class="string">&#x27;two&#x27;</span>)]</span><br><span class="line">a, b = <span class="built_in">zip</span>(*seq1)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a = <span class="subst">&#123;a&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;b = <span class="subst">&#123;b&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>27. 以下代码的输出结果为( )</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">seq1=[<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>]</span><br><span class="line">seq2=[<span class="string">&#x27;A&#x27;</span>,<span class="string">&#x27;B&#x27;</span>,<span class="string">&#x27;C&#x27;</span>]</span><br><span class="line">combine = <span class="built_in">zip</span>(seq1,seq2)</span><br><span class="line">first, last = <span class="built_in">zip</span>(*combine)</span><br><span class="line"><span class="built_in">print</span>(first)</span><br></pre></td></tr></table></figure><p>A. <code>(&#39;a&#39;, &#39;A&#39;)</code><br>B. <code>(&#39;A&#39;, &#39;a&#39;)</code><br>C. <code>(&#39;a&#39;, &#39;b&#39;, &#39;c&#39;)</code><br>D. <code>(&#39;A&#39;, &#39;B&#39;, &#39;C&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  这是一个 `zip` 的经典二次操作，实现了“压缩”再“解压”的过程。  <ol>    <li><b>`combine = zip(seq1,seq2)`</b>：`combine` 是一个迭代器，它将产生 `[('a', 'A'), ('b', 'B'), ('c', 'C')]`。</li>    <li><b>`*combine`</b>：解包 `combine` 迭代器，相当于把 `('a', 'A')`, `('b', 'B')`, `('c', 'C')` 作为三个独立的参数。</li>    <li><b>`zip(*combine)`</b>：这等价于 `zip(('a', 'A'), ('b', 'B'), ('c', 'C'))`。</li>    <li>这个新的 `zip` 操作会再次打包，将每个元组的第一个元素组合，第二个元素组合：        <ul>            <li>`('a', 'b', 'c')`</li>            <li>`('A', 'B', 'C')`</li>        </ul>    </li>    <li><b>`first, last = ...`</b>：解包赋值。`first` 得到 `('a', 'b', 'c')`，`last` 得到 `('A', 'B', 'C')`。</li>    <li><b>`print(first)`</b>：打印 `first` 的值。</li>  </ol><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">seq1=[<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>]</span><br><span class="line">seq2=[<span class="string">&#x27;A&#x27;</span>,<span class="string">&#x27;B&#x27;</span>,<span class="string">&#x27;C&#x27;</span>]</span><br><span class="line">combine = <span class="built_in">zip</span>(seq1, seq2)</span><br><span class="line">first, last = <span class="built_in">zip</span>(*combine)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;first = <span class="subst">&#123;first&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;last = <span class="subst">&#123;last&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>28. <code>a.union(b)</code> 和哪个是一样的（ ）</strong><br>A. <code>a | b</code><br>B. <code>a &amp; b</code><br>C. <code>a || b</code><br>D. <code>a &amp;&amp; b</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  在 Python 中，对于集合 (set) 类型：  <ul>    <li><b>A. `a | b`</b>：`|` 运算符是集合的<b>并集</b> (union)，与 `a.union(b)` 功能完全相同。</li>    <li><b>B. `a & b`</b>：`&` 运算符是集合的<b>交集</b> (intersection)。</li>    <li><b>C. `a || b`</b>：`||` 不是 Python 中的有效运算符。逻辑或是 `or`。</li>    <li><b>D. `a && b`</b>：`&&` 不是 Python 中的有效运算符。逻辑与是 `and`。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">a = &#123;<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>&#125;</span><br><span class="line">b = &#123;<span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>&#125;</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a.union(b): <span class="subst">&#123;a.union(b)&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a | b:        <span class="subst">&#123;a | b&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;a &amp; b:        <span class="subst">&#123;a &amp; b&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>29. <code>my_list=[5, 9, 12, 3, 10, 8, 16, 1]</code>, <code>my_list[::-3]</code> 的结果是( )</strong><br>A. <code>[1, 8, 3, 9]</code><br>B. <code>[8, 16, 1]</code><br>C. <code>[1, 10, 9]</code><br>D. <code>[5, 3, 16]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  列表切片 `list[start:stop:step]`。  对于 `list[::-3]`：  <ul>    <li>`start` 未指定，`step` 为负，表示从列表末尾开始。</li>    <li>`stop` 未指定，`step` 为负，表示到列表开头结束。</li>    <li>`step` 为 -3，表示从后往前每隔 3 个元素取一个。</li>  </ul>  让我们从后往前取：  <ol>    <li>第一个元素是索引 `-1` 的 `1`。</li>    <li>向前跳 3 个位置，到索引 `-4`，元素是 `10`。</li>    <li>再向前跳 3 个位置，到索引 `-7`，元素是 `9`。</li>    <li>再向前跳 3 个位置，索引 `-10` 超出范围，停止。</li>  </ol>  因此，结果是 `[1, 10, 9]`。<p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">my_list = [<span class="number">5</span>, <span class="number">9</span>, <span class="number">12</span>, <span class="number">3</span>, <span class="number">10</span>, <span class="number">8</span>, <span class="number">16</span>, <span class="number">1</span>]</span><br><span class="line">result = my_list[::-<span class="number">3</span>]</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>30. 取集合a和集合b中的所有不重复元素的操作符是( )</strong><br>A. -<br>B. |<br>C. &amp;<br>D. ^</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  “取集合a和集合b中的所有不重复元素”指的是求两个集合的<b>并集</b>。  <ul>    <li><b>A. `-`</b>：差集 (difference)，属于 a 但不属于 b 的元素。</li>    <li><b>B. `|`</b>：并集 (union)，属于 a 或属于 b 的所有元素。</li>    <li><b>C. `&`</b>：交集 (intersection)，同时属于 a 和 b 的元素。</li>    <li><b>D. `^`</b>：对称差集 (symmetric difference)，属于 a 或 b 但不同时属于二者的元素。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">a = &#123;<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>&#125;</span><br><span class="line">b = &#123;<span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>&#125;</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Union (a | b): <span class="subst">&#123;a | b&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>31. 下列代码的的运行结果为：( )</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> bisect</span><br><span class="line">c = [<span class="number">1</span>, <span class="number">8</span>, <span class="number">2</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">7</span>]</span><br><span class="line">bisect.insort(c, <span class="number">6</span>)</span><br><span class="line"><span class="built_in">print</span>(c)</span><br></pre></td></tr></table></figure><p>A. <code>[1, 2, 2, 3, 4, 6, 7, 8]</code><br>B. <code>[1, 6, 8, 2, 2, 3, 4, 7]</code><br>C. <code>[1, 8, 2, 2, 3, 4, 6, 7]</code><br>D. <code>Error</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `bisect.insort(list, item)` 函数的作用是，在保持 `list` <b>有序</b>的情况下，插入 `item`。  <b>关键点</b>：`bisect` 模块的函数<b>假设</b>传入的列表已经是排好序的。如果列表未排序，`bisect` 仍然会通过二分查找来寻找一个插入点，但最终结果可能不符合预期。  <ol>    <li>它会在未排序的列表 `c` 上执行二分查找来定位 `6` 的插入位置。</li>    <li>在 `[1, 8, 2, 2, 3, 4, 7]` 中，二分查找会确定一个插入点，使得插入后，该点左侧所有元素都小于等于 `6`，右侧都大于等于 `6`（这是在有序列表中的行为，在无序列表中，它只是找到一个满足二分查找逻辑的位置）。</li>    <li>经过计算，`bisect` 会确定索引 `6` 是插入 `6` 的位置（在 `4` 和 `7` 之间）。</li>    <li>所以 `6` 会被插入到原列表的索引 6 处，结果为 `[1, 8, 2, 2, 3, 4, 6, 7]`。</li>  </ol>  注意：最终列表并未完全排序，`insort` 只是完成了插入操作。<p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> bisect</span><br><span class="line">c = [<span class="number">1</span>, <span class="number">8</span>, <span class="number">2</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">7</span>]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Original c: <span class="subst">&#123;c&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line">bisect.insort(c, <span class="number">6</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;After insort: <span class="subst">&#123;c&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 正确用法示例</span></span><br><span class="line">c_sorted = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">7</span>, <span class="number">8</span>]</span><br><span class="line">bisect.insort(c_sorted, <span class="number">6</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Correct usage on sorted list: <span class="subst">&#123;c_sorted&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>32. 关于Python组合数据类型，以下描述错误的是：( )</strong><br>A. Python的字符串、元组和列表类型都属于序列类型<br>B. 组合数据类型能够将多个相同类型或不同类型的数据组织起来，通过单一的表示使数据操作更有序、更容易<br>C. 组合数据类型可以分为3类：序列类型、集合类型和映射类型<br>D. 序列类型是二维元素向量，元素之间存在先后关系，通过序号访问</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A</b>: 正确。字符串、元组和列表都是序列，其元素有顺序，可通过索引访问。</li>    <li><b>B</b>: 正确。这是对组合数据类型作用的准确描述。</li>    <li><b>C</b>: 正确。Python 的主要组合数据类型可分为这三类。</li>    <li><b>D</b>: 错误。序列类型是<b>一维</b>元素向量，而不是二维。其余描述（元素有先后关系，通过序号访问）是正确的。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>33. 下列代码的运行结果为：( )</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">print</span>(<span class="number">4</span> &gt; <span class="number">3</span> &gt; <span class="number">2</span> &gt; <span class="number">1</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="number">4</span> &gt; (<span class="number">3</span> &gt; <span class="number">2</span>) &gt; <span class="number">1</span>)</span><br></pre></td></tr></table></figure><p>A. <code>True True</code><br>B. <code>True False</code><br>C. <code>False False</code><br>D. <code>False True</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`4 > 3 > 2 > 1`</b>：在 Python 中，比较运算符可以<b>链式使用</b>。这个表达式等价于 `(4 > 3) and (3 > 2) and (2 > 1)`。因为所有子表达式都为 `True`，所以最终结果是 `True`。</li>    <li><b>`4 > (3 > 2) > 1`</b>：        <ul>            <li>首先计算括号内的 `(3 > 2)`，结果为 `True`。</li>            <li>表达式变为 `4 > True > 1`。</li>            <li>在数值比较中，`True` 会被当作整数 `1`。</li>            <li>表达式变为 `4 > 1 > 1`。</li>            <li>这又是一个链式比较，等价于 `(4 > 1) and (1 > 1)`。</li>            <li>`(4 > 1)` 是 `True`，但 `(1 > 1)` 是 `False`。</li>            <li>`True and False` 的结果是 `False`。</li>        </ul>    </li>  </ol><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">print</span>(<span class="number">4</span> &gt; <span class="number">3</span> &gt; <span class="number">2</span> &gt; <span class="number">1</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="number">4</span> &gt; (<span class="number">3</span> &gt; <span class="number">2</span>) &gt; <span class="number">1</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>34. 下列代码的运行结果为：( )</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">tup1 =( <span class="number">4</span> ,<span class="string">&#x27;#&#x27;</span>, <span class="string">&#x27;for&#x27;</span>) + ( <span class="number">1</span> ,[<span class="number">6</span> , <span class="number">0</span>] ) * <span class="number">2</span> + <span class="built_in">tuple</span> ( <span class="string">&#x27;bar&#x27;</span> )</span><br><span class="line"><span class="built_in">print</span>(tup1)</span><br></pre></td></tr></table></figure><p>A. <code>(4, &#39;#&#39;, &#39;for&#39;, 1, [6, 0], 1, [6, 0], &#39;b&#39;, &#39;a&#39;, &#39;r&#39;)</code><br>B. <code>(4, &#39;#&#39;, &#39;f&#39;, &#39;o&#39;, &#39;r&#39;, 1, [6, 0], 1, [6, 0], &#39;b&#39;, &#39;a&#39;, &#39;r&#39;)</code><br>C. <code>(4, &#39;#&#39;, &#39;for&#39;, 1, [6, 0], 1, [6, 0], &#39;bar&#39;)</code><br>D. <code>Error</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  让我们逐步分解表达式：  <ol>    <li><b>`(1, [6, 0]) * 2`</b>：元组重复操作。结果是 `(1, [6, 0], 1, [6, 0])`。</li>    <li><b>`tuple('bar')`</b>：将字符串转换为元组，每个字符成为一个元素。结果是 `('b', 'a', 'r')`。</li>    <li><b>`+` 运算符</b>：将三个元组进行拼接。        <br>`(4, '#', 'for') + (1, [6, 0], 1, [6, 0]) + ('b', 'a', 'r')`</li>    <li>最终结果是 `(4, '#', 'for', 1, [6, 0], 1, [6, 0], 'b', 'a', 'r')`。</li>  </ol><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">tup1 = (<span class="number">4</span>, <span class="string">&#x27;#&#x27;</span>, <span class="string">&#x27;for&#x27;</span>) + (<span class="number">1</span>, [<span class="number">6</span>, <span class="number">0</span>]) * <span class="number">2</span> + <span class="built_in">tuple</span>(<span class="string">&#x27;bar&#x27;</span>)</span><br><span class="line"><span class="built_in">print</span>(tup1)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>35. <code>a = [1, 2, 3, None, (), [], ]</code>，<code>print(len(a))</code> 的输出结果为( )</strong><br>A. 4<br>B. 5<br>C. 6<br>D. 7</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `len()` 函数返回列表中元素的数量。我们来数一下列表 `a` 中的元素：  <ol>    <li>`1` (整数)</li>    <li>`2` (整数)</li>    <li>`3` (整数)</li>    <li>`None` (NoneType)</li>    <li>`()` (空元组)</li>    <li>`[]` (空列表)</li>  </ol>  总共有 6 个元素，即使有些元素是空的或者 `None`，它们仍然算作独立的元素。<p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">a = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="literal">None</span>, (), [], ]</span><br><span class="line"><span class="built_in">print</span>(<span class="built_in">len</span>(a))</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>36. 以下不能创建一个字典的语句是：（）</strong><br>A. <code>d1 = &#123;&#39;a&#39;:[1,3,5],&#39;b&#39;:128&#125;</code><br>B. <code>d1 = dict(&#39;a&#39;=[1,2,3])</code><br>C. <code>d1 = dict.fromkeys([&#39;a&#39;,&#39;b&#39;,&#39;c&#39;])</code><br>D. <code>seq1 = [&#39;a&#39;,&#39;b&#39;]; seq2 = [1,2]; d1 = dict(zip(seq1,seq2))</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A</b>: 正确。使用花括号 `{}` 是创建字典的标准字面量语法。</li>    <li><b>B</b>: 错误。`dict()` 构造函数如果使用关键字参数来创建字典，那么关键字必须是合法的变量名，不能是字符串。`'a'` 是一个字符串，不是变量名，这会导致 `SyntaxError`。正确的写法是 `d1 = dict(a=[1,2,3])`。</li>    <li><b>C</b>: 正确。`dict.fromkeys()` 是一个类方法，用于从一个序列创建字典，所有键对应同一个值（默认为 `None`）。</li>    <li><b>D</b>: 正确。`zip()` 将两个序列打包成键值对，`dict()` 构造函数再将这些键值对转换为字典。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># A. Correct</span></span><br><span class="line">d1_A = &#123;<span class="string">&#x27;a&#x27;</span>:[<span class="number">1</span>,<span class="number">3</span>,<span class="number">5</span>],<span class="string">&#x27;b&#x27;</span>:<span class="number">128</span>&#125;</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;A: <span class="subst">&#123;d1_A&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># C. Correct</span></span><br><span class="line">d1_C = <span class="built_in">dict</span>.fromkeys([<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;C: <span class="subst">&#123;d1_C&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># D. Correct</span></span><br><span class="line">seq1 = [<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;d&#x27;</span>]</span><br><span class="line">seq2 = [<span class="number">123</span>,<span class="string">&#x27;second&#x27;</span>,<span class="literal">True</span>,[<span class="number">1</span>,<span class="number">3</span>,<span class="number">5</span>]]</span><br><span class="line">d1_D = <span class="built_in">dict</span>(<span class="built_in">zip</span>(seq1,seq2))</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;D: <span class="subst">&#123;d1_D&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># B (will raise SyntaxError)</span></span><br><span class="line"><span class="keyword">try</span>:</span><br><span class="line">    <span class="comment"># This line needs to be in a string to be evaluated,</span></span><br><span class="line">    <span class="comment"># as it&#x27;s a syntax error and would stop the script.</span></span><br><span class="line">    <span class="built_in">exec</span>(<span class="string">&quot;d1 = dict(&#x27;a&#x27;=[1,2,3])&quot;</span>)</span><br><span class="line"><span class="keyword">except</span> SyntaxError <span class="keyword">as</span> e:</span><br><span class="line">    <span class="built_in">print</span>(<span class="string">f&quot;Error for B: Invalid syntax&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>37. 下列语句结果为： ( )</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">a = [<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>]</span><br><span class="line">b = [<span class="number">4</span>,<span class="number">5</span>,<span class="number">6</span>]</span><br><span class="line"><span class="built_in">print</span>(a + <span class="number">3</span> * b)</span><br></pre></td></tr></table></figure><p>A. <code>[1,2,3,12,15,18]</code><br>B. <code>[1,2,3,4,5,6,4,5,6,4,5,6]</code><br>C. <code>[1,2,3,4,5,6,1,2,3,4,5,6]</code><br>D. 输出错误</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  运算符优先级决定了计算顺序。在 Python 中，乘法 `*` 的优先级高于加法 `+`。  <ol>    <li><b>`3 * b`</b>：首先执行列表的重复操作。列表 `b` 被重复 3 次，结果为 `[4, 5, 6, 4, 5, 6, 4, 5, 6]`。</li>    <li><b>`a + ...`</b>：然后执行列表的拼接操作。将列表 `a` 与上一步的结果拼接。</li>  </ol>  `[1, 2, 3] + [4, 5, 6, 4, 5, 6, 4, 5, 6]` 的结果是 `[1, 2, 3, 4, 5, 6, 4, 5, 6, 4, 5, 6]`。<p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">a = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]</span><br><span class="line">b = [<span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>]</span><br><span class="line">result = a + <span class="number">3</span> * b</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><h2 id="第四章：NumPy-数组与操作"><a href="#第四章：NumPy-数组与操作" class="headerlink" title="第四章：NumPy 数组与操作"></a>第四章：NumPy 数组与操作</h2><p><strong>1. 代码<code>arr=np.arange(1,10).reshape(3,3);arr[1:2,:].shape</code> 的输出是（ ）</strong><br>A. (2, 3)<br>B. (1, 2)<br>C. (1, 3)<br>D. (2, 2)</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`arr = np.arange(1,10).reshape(3,3)`</b>： 创建一个 3x3 的 NumPy 数组。</li>    <li><b>`arr[1:2,:]`</b>： 这是一个切片操作。        <ul>            <li>`1:2`：在第一个维度（行）上，选择索引为 1 的行。因为使用的是切片 `1:2` 而不是整数 `1`，所以结果会<b>保持其二维特性</b>。</li>            <li>`:`：在第二个维度（列）上，选择所有列。</li>        </ul>        因此，结果是一个 1 行 3 列的二维数组 `[[4, 5, 6]]`。    </li>    <li><b>`.shape`</b>：获取这个结果数组的形状，即 `(1, 3)`。</li>  </ul><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr = np.arange(<span class="number">1</span>,<span class="number">10</span>).reshape(<span class="number">3</span>,<span class="number">3</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Original array:\n<span class="subst">&#123;arr&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line">sliced_arr = arr[<span class="number">1</span>:<span class="number">2</span>,:]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Sliced array:\n<span class="subst">&#123;sliced_arr&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Shape of sliced array: <span class="subst">&#123;sliced_arr.shape&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>2. 代码<code>arr=np.arange(1,10).reshape(3,3);arr[[0,-1,-2]]</code> 的输出是（ ）</strong><br>A. <code>array([[1, 2, 3], [7, 8, 9],[4, 5, 6]])</code><br>B. <code>array([[7, 8, 9],[7, 8, 9],[4, 5, 6]])</code><br>C. <code>array([[1, 2, 3],[1, 2, 3], [4, 5, 6]])</code><br>D. <code>array([[7, 8, 9],[1, 2, 3],[4, 5, 6]])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`arr = np.arange(1,10).reshape(3,3)`</b>： 创建数组 `[[1,2,3], [4,5,6], [7,8,9]]`。</li>    <li><b>`arr[[0,-1,-2]]`</b>： 这是一个<b>花式索引 (Fancy Indexing)</b>。它使用一个整数列表来选择行，并且结果数组的行顺序将与索引列表中的顺序完全相同。        <ul>            <li>`0` 对应第一行：`[1, 2, 3]`</li>            <li>`-1` 对应最后一行：`[7, 8, 9]`</li>            <li>`-2` 对应倒数第二行：`[4, 5, 6]`</li>        </ul>    </li>  </ul>  因此，输出是 `array([[1, 2, 3], [7, 8, 9], [4, 5, 6]])`。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr = np.arange(<span class="number">1</span>,<span class="number">10</span>).reshape(<span class="number">3</span>,<span class="number">3</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Original array:\n<span class="subst">&#123;arr&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line">result = arr[[<span class="number">0</span>,-<span class="number">1</span>,-<span class="number">2</span>]]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Result of arr[[0,-1,-2]]:\n<span class="subst">&#123;result&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>3. 计算numpy中元素个数的方法（ ）</strong><br>A. <code>np.sqrt()</code><br>B. <code>np.size()</code><br>C. <code>np.identity()</code><br>D. <code>np.itemsize()</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `np.sqrt()`</b>：计算数组中每个元素的平方根。</li>    <li><b>B. `np.size()`</b>：返回数组中元素的总数量。也可以使用数组属性 `.size`。</li>    <li><b>C. `np.identity()`</b>：返回一个单位矩阵。</li>    <li><b>D. `np.itemsize()`</b>：返回数组中每个元素占用的字节数。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr = np.array([[<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>], [<span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>]])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Number of elements (np.size): <span class="subst">&#123;np.size(arr)&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Number of elements (arr.size): <span class="subst">&#123;arr.size&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>4. NumPy中没有以下哪个功能？（ ）</strong><br>A. 随机数生成<br>B. 矩阵计算<br>C. 生成DataFrame数据结构<br>D. 傅里叶变换</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. 随机数生成</b>：NumPy 的 `numpy.random` 模块提供了强大的随机数生成功能。</li>    <li><b>B. 矩阵计算</b>：NumPy 提供了矩阵乘法 (`@` 或 `np.dot()`) 和其他线性代数运算。</li>    <li><b>C. 生成DataFrame数据结构</b>：`DataFrame` 是 <b>Pandas</b> 库的核心数据结构，不是 NumPy 的。</li>    <li><b>D. 傅里叶变换</b>：NumPy 包含 `numpy.fft` 模块，用于执行傅里叶变换。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>5. 以下结果为TRUE的是（ ）</strong><br>A. <code>np.nan == np.nan</code><br>B. <code>np.inf &gt; np.nan</code><br>C. <code>0.3 == 3 * 0.1</code><br>D. <code>0 * np.nan != 0</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `np.nan == np.nan`</b>：`NaN` (Not a Number) 与任何值（包括它自己）的相等比较结果都是 `False`。</li>    <li><b>B. `np.inf > np.nan`</b>：任何涉及 `NaN` 的大小比较结果都是 `False`。</li>    <li><b>C. `0.3 == 3 * 0.1`</b>：由于浮点数精度问题，`3 * 0.1` 的结果是 `0.30000000000000004`，不精确等于 `0.3`，所以结果为 `False`。</li>    <li><b>D. `0 * np.nan != 0`</b>：        <ul>            <li>`0 * np.nan` 的结果是 `np.nan`。</li>            <li>表达式变为 `np.nan != 0`。</li>            <li>`NaN` 与任何值的不等比较结果都是 `True`。</li>        </ul>    </li>  </ul><p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;np.nan == np.nan: <span class="subst">&#123;np.nan == np.nan&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;np.inf &gt; np.nan: <span class="subst">&#123;np.inf &gt; np.nan&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;0.3 == 3 * 0.1: <span class="subst">&#123;<span class="number">0.3</span> == <span class="number">3</span> * <span class="number">0.1</span>&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;0 * np.nan != 0: <span class="subst">&#123;<span class="number">0</span> * np.nan != <span class="number">0</span>&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>6. 已知<code>arr=np.arange(9).reshape(3,3)</code>, 执行<code>arr.cumsum(axis=0)</code>得到的结果是（ ）</strong><br>A. 36<br>B. <code>array([3,12,21])</code><br>C. <code>array([[0,1,2],[3,5,7],[9,12,15]])</code><br>D. <code>array([[0,1,3],[3,7,12],[6,13,21]])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`arr = np.arange(9).reshape(3,3)`</b>：创建数组 `[[0,1,2], [3,4,5], [6,7,8]]`。</li>    <li><b>`arr.cumsum(axis=0)`</b>：`cumsum()` 计算累积和。`axis=0` 表示沿着第一个轴（行方向，即<b>向下</b>）对每一列独立计算累积和。        <ul>            <li>第0列: `[0, 0+3, (0+3)+6]` -> `[0, 3, 9]`</li>            <li>第1列: `[1, 1+4, (1+4)+7]` -> `[1, 5, 12]`</li>            <li>第2列: `[2, 2+5, (2+5)+8]` -> `[2, 7, 15]`</li>        </ul>    </li>  </ul>  将结果组合得到 `[[0,1,2],[3,5,7],[9,12,15]]`。<p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr = np.arange(<span class="number">9</span>).reshape(<span class="number">3</span>,<span class="number">3</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Original array:\n<span class="subst">&#123;arr&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line">result = arr.cumsum(axis=<span class="number">0</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Result of arr.cumsum(axis=0):\n<span class="subst">&#123;result&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>7. 设<code>bools=np.array([False,False,True,False])</code>,执行<code>bools.any()</code>和<code>bools.all()</code>得到的输出分别是（ ）</strong><br>A. True,False<br>B. True,True<br>C. False,True<br>D. False,False</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`bools.any()`</b>：检查数组中是否<b>至少有一个</b>元素为 `True`。因为数组中包含 `True`，所以结果是 `True`。</li>    <li><b>`bools.all()`</b>：检查数组中是否<b>所有元素</b>都为 `True`。因为数组中包含 `False`，所以结果是 `False`。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">bools = np.array([<span class="literal">False</span>, <span class="literal">False</span>, <span class="literal">True</span>, <span class="literal">False</span>])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;bools.any(): <span class="subst">&#123;bools.<span class="built_in">any</span>()&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;bools.all(): <span class="subst">&#123;bools.<span class="built_in">all</span>()&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>8. 假设<code>arr = np.array([[1, 2 ,3], [4, 5, 6]]).T</code>，下列哪项可计算arr每一行的平均值？（ ）</strong><br>A. <code>arr.mean()</code><br>B. <code>arr.mean(1)</code><br>C. <code>arr.mean(0)</code><br>D. <code>arr.mean(axis = 1)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`arr = np.array(...).T`</b>：创建的 `arr` 是一个 3x2 的数组：`[[1,4], [2,5], [3,6]]`。</li>    <li><b>`arr.mean()`</b>：计算整个数组所有元素的平均值。</li>    <li><b>`arr.mean(axis=0)`</b> 或 `arr.mean(0)`：沿着轴 0 (向下) 计算，得到每一<b>列</b>的平均值。</li>    <li><b>`arr.mean(axis=1)`</b> 或 `arr.mean(1)`：沿着轴 1 (向右) 计算，得到每一<b>行</b>的平均值。</li>  </ul>  选项 B 和 D 是等价的，都计算每一行的平均值。<p>  <strong>正确答案：</strong> B (或 D)</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr = np.array([[<span class="number">1</span>, <span class="number">2</span> ,<span class="number">3</span>], [<span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>]]).T</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Transposed array arr:\n<span class="subst">&#123;arr&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;\nMean of each row (arr.mean(axis=1)):\n<span class="subst">&#123;arr.mean(axis=<span class="number">1</span>)&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>9. NumPy中的<code>ndim</code>属性表示的意思是（ ）</strong><br>A. 元素类型<br>B. 秩<br>C. 每一维度的数量<br>D. 元素的值</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`dtype`</b>：表示数组中元素的数据类型。</li>    <li><b>`shape`</b>：一个元组，表示数组在每个维度上的大小（即每一维度的数量）。</li>    <li><b>`ndim`</b>：一个整数，表示数组的<b>维度数</b>（number of dimensions），也称为<b>秩 (rank)</b>。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr1d = np.array([<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>])</span><br><span class="line">arr2d = np.array([[<span class="number">1</span>, <span class="number">2</span>], [<span class="number">3</span>, <span class="number">4</span>]])</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;arr1d.ndim: <span class="subst">&#123;arr1d.ndim&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;arr2d.ndim: <span class="subst">&#123;arr2d.ndim&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>10. 根据输出结果，下列①处的代码应该为（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr = np.arange(<span class="number">12</span>).reshape(<span class="number">3</span>, <span class="number">4</span>)</span><br><span class="line"><span class="comment"># ①</span></span><br><span class="line"><span class="built_in">print</span>(arr)</span><br><span class="line"><span class="comment"># 输出：</span></span><br><span class="line"><span class="comment"># [[ 0  1  2  3]</span></span><br><span class="line"><span class="comment">#  [12 12  6  7]</span></span><br><span class="line"><span class="comment">#  [ 8  9 10 11]]</span></span><br></pre></td></tr></table></figure><p>A. <code>arr[1][:2] = 12</code><br>B. <code>arr[1][1:2] = 12</code><br>C. <code>arr[1,1:2] = 12</code><br>D. <code>arr[1,2] = 12</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  目标是将 `arr` 的第二行 `[4, 5, 6, 7]` 的前两个元素 `[4, 5]` 修改为 `12`。  <ul>    <li><b>A. `arr[1][:2] = 12`</b>：        <ul>            <li>`arr[1]` 得到第二行 `[4, 5, 6, 7]`。</li>            <li>`[:2]` 进一步切片得到 `[4, 5]`。</li>            <li>`= 12` 会通过广播将 `[4, 5]` 修改为 `[12, 12]`。符合目标。</li>        </ul>    </li>    <li><b>B. `arr[1][1:2] = 12`</b>：只修改了索引为 1 的元素 `5`。</li>    <li><b>C. `arr[1,1:2] = 12`</b>：等同于 B，只修改了 `[1,1]` 处的元素。</li>    <li><b>D. `arr[1,2] = 12`</b>：只修改了 `[1,2]` 处的元素 `6`。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr = np.arange(<span class="number">12</span>).reshape(<span class="number">3</span>, <span class="number">4</span>)</span><br><span class="line">arr[<span class="number">1</span>][:<span class="number">2</span>] = <span class="number">12</span></span><br><span class="line"><span class="built_in">print</span>(arr)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>11. <code>a = [1, 2, 3]</code>， <code>c = np.array(a)</code>，以下对<code>a</code>和<code>c</code>的操作，错误的是（ ）</strong><br>A. <code>c**2</code><br>B. <code>c + 1</code><br>C. <code>a*2</code><br>D. <code>a + 1</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `c**2`</b>：NumPy 数组支持元素级幂运算，结果为 `array([1, 4, 9])`。正确。</li>    <li><b>B. `c + 1`</b>：NumPy 数组支持与标量的广播运算，结果为 `array([2, 3, 4])`。正确。</li>    <li><b>C. `a*2`</b>：Python 列表的 `*` 运算符用于重复，结果为 `[1, 2, 3, 1, 2, 3]`。正确。</li>    <li><b>D. `a + 1`</b>：Python 列表的 `+` 运算符用于列表拼接，不能与整数相加，会引发 `TypeError`。错误。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>12. numpy中向量转成矩阵使用( )</strong><br>A. <code>reshape</code><br>B. <code>reval</code><br>C. <code>arange</code><br>D. <code>random</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `reshape`</b>：用于改变数组的形状，可以将一维数组（向量）转换为多维数组（矩阵）。</li>    <li><b>B. `reval`</b>：不是 NumPy 中的标准函数。</li>    <li><b>C. `arange`</b>：用于创建等差序列数组。</li>    <li><b>D. `random`</b>：是 NumPy 中用于生成随机数的模块。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">vec = np.arange(<span class="number">6</span>) <span class="comment"># 向量</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Original vector (shape <span class="subst">&#123;vec.shape&#125;</span>):\n<span class="subst">&#123;vec&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line">matrix = vec.reshape(<span class="number">2</span>, <span class="number">3</span>) <span class="comment"># 转换为矩阵</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;\nMatrix after reshape (shape <span class="subst">&#123;matrix.shape&#125;</span>):\n<span class="subst">&#123;matrix&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>13. <code>data1=[6,7.5,8,0,1];arr1=np.array(data1)</code>则<code>arr1</code>的输出结果是：( )</strong><br>A. <code>array([6. , 7.5, 8. , 0. , 1. ])</code><br>B. <code>array([6 , 7, 8 , 0 , 1 ])</code><br>C. <code>array([6 , 8, 8. , 0. , 1. ])</code><br>D. <code>array([6 , 7.5, 8 , 0 , 1 ])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `np.array()` 从列表创建数组时，会自动推断数据类型 (`dtype`)。由于输入列表 `data1` 中包含浮点数 (`7.5`)，为了保持数据精度，NumPy 会将整个数组的类型提升为浮点数（通常是 `float64`）。因此，所有的整数也会被转换为浮点数。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">data1 = [<span class="number">6</span>, <span class="number">7.5</span>, <span class="number">8</span>, <span class="number">0</span>, <span class="number">1</span>]</span><br><span class="line">arr1 = np.array(data1)</span><br><span class="line"><span class="built_in">print</span>(arr1)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;dtype of arr1: <span class="subst">&#123;arr1.dtype&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>14. 下列代码的输出是( )</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">data = np.random.randn(<span class="number">3</span>, <span class="number">4</span>)</span><br><span class="line">data1 = data[<span class="number">1</span>].copy()</span><br><span class="line">data1[<span class="number">0</span>:<span class="number">2</span>] = <span class="number">12</span></span><br><span class="line">data1[<span class="number">2</span>:<span class="number">4</span>] = <span class="number">13</span></span><br><span class="line"><span class="built_in">print</span>(data1)</span><br></pre></td></tr></table></figure><p>A. <code>[12. 12. 13. 13.]</code><br>B. <code>[12. 12. 12. 13.]</code><br>C. <code>[[12. 12.] [13. 13.]]</code><br>D. 发生错误，没有输出</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`data = np.random.randn(3, 4)`</b>：创建一个 3x4 的随机浮点数数组。</li>    <li><b>`data1 = data[1].copy()`</b>：获取 `data` 的第二行并<b>创建其副本</b> `data1`。`data1` 是一个包含 4 个元素的一维浮点数数组。</li>    <li><b>`data1[0:2] = 12`</b>：通过广播将 `data1` 的前两个元素赋值为 `12.`。</li>    <li><b>`data1[2:4] = 13`</b>：通过广播将 `data1` 的后两个元素赋值为 `13.`。</li>  </ol>  最终 `data1` 变为 `[12. 12. 13. 13.]`。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">data1 = np.random.randn(<span class="number">4</span>) <span class="comment"># 模拟一个4元素的一维数组</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Initial data1: <span class="subst">&#123;data1&#125;</span>&quot;</span>)</span><br><span class="line">data1[<span class="number">0</span>:<span class="number">2</span>] = <span class="number">12</span></span><br><span class="line">data1[<span class="number">2</span>:<span class="number">4</span>] = <span class="number">13</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Final data1:   <span class="subst">&#123;data1&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>15. <code>arr=np.arange(12).reshape(4,3)</code>，切片操作<code>arr[[1],:3]</code>返回的结果是（ ）</strong><br>A. <code>array([[0,1, 2]])</code><br>B. <code>array([[3, 4]])</code><br>C. <code>array([[1, 2]])</code><br>D. <code>array([[3, 4, 5]])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`arr = np.arange(12).reshape(4,3)`</b>：创建数组 `[[0,1,2],[3,4,5],[6,7,8],[9,10,11]]`。</li>    <li><b>`arr[[1],:3]`</b>：这是一个混合索引。        <ul>            <li>`[1]`：在行上使用花式索引，即使只选择一行，也会<b>保持二维特性</b>。</li>            <li>`:3`：在列上选择所有三列。</li>        </ul>    </li>  </ul>  因此，结果是选择索引为 1 的行，并保持其二维形式，即 `array([[3, 4, 5]])`。<p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr = np.arange(<span class="number">12</span>).reshape(<span class="number">4</span>,<span class="number">3</span>)</span><br><span class="line">result = arr[[<span class="number">1</span>],:<span class="number">3</span>]</span><br><span class="line"><span class="built_in">print</span>(result)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Shape of result: <span class="subst">&#123;result.shape&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>16. 对于一个numpy对象<code>data = np.arange(12).reshape(4, 3)</code>，下列代码可以得到<code>[[ 7] [10]]</code>切片的是（ ）</strong><br>A. <code>data[2:4, 1:2]</code><br>B. <code>data[2:4][1:2]</code><br>C. <code>data[2:4, 1:3]</code><br>D. <code>data[2:3, 1:2]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  目标是选择 `data` 中索引为 `(2,1)` 的 `7` 和索引为 `(3,1)` 的 `10`，并保持列的维度。  <ul>    <li><b>A. `data[2:4, 1:2]`</b>：        <ul>            <li>`2:4`：选择行索引 2 和 3。</li>            <li>`1:2`：选择列索引 1。</li>        </ul>        这个组合精确地选择了目标元素，并返回一个 2x1 的数组 `[[7], [10]]`。符合目标。    </li>    <li><b>B. `data[2:4][1:2]`</b>：先取行 `2,3` 得到 `[[6,7,8],[9,10,11]]`，再取这个新数组的行 `1` 得到 `[[9,10,11]]`。不符。</li>    <li><b>C. `data[2:4, 1:3]`</b>：选择了行 `2,3` 和列 `1,2`，结果是 `[[7,8],[10,11]]`。不符。</li>    <li><b>D. `data[2:3, 1:2]`</b>：只选择了行 `2` 和列 `1`，结果是 `[[7]]`。不符。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">data = np.arange(<span class="number">12</span>).reshape(<span class="number">4</span>, <span class="number">3</span>)</span><br><span class="line"><span class="built_in">print</span>(data[<span class="number">2</span>:<span class="number">4</span>, <span class="number">1</span>:<span class="number">2</span>])</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>17. 以下可以创建数组<code>[1.,3.,5.]</code>的是（ ）</strong><br>A. <code>numpy.arange(1,7)</code><br>B. <code>numpy.arange(1.,7)</code><br>C. <code>numpy.arange(1.,7,2)</code><br>D. <code>numpy.arange(1.,5.,2)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `np.arange(start, stop, step)` 创建一个从 `start` 开始，到 `stop` (不包含)结束，步长为 `step` 的数组。  <ul>    <li><b>A. `numpy.arange(1,7)`</b>：`[1, 2, 3, 4, 5, 6]`</li>    <li><b>B. `numpy.arange(1.,7)`</b>：`[1., 2., 3., 4., 5., 6.]`</li>    <li><b>C. `numpy.arange(1.,7,2)`</b>：从 1.0 开始，步长为 2，到 7 之前。序列为 `1.0`, `3.0`, `5.0`。符合目标。</li>    <li><b>D. `numpy.arange(1.,5.,2)`</b>：从 1.0 开始，步长为 2，到 5.0 之前。序列为 `1.0`, `3.0`。不符。</li>  </ul><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"><span class="built_in">print</span>(np.arange(<span class="number">1.</span>,<span class="number">7</span>,<span class="number">2</span>))</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>18. 如果 <code>x = np.array([[1., 2.], [4., 5.]])</code>, 则<code>print(x*x)</code>的结果为（ ）</strong><br>A. <code>[[1. 2.] [4. 5.]]</code><br>B. <code>[[ 1.  4.] [16. 25.]]</code><br>C. <code>[[ 9. 12.] [24. 33.]]</code><br>D. <code>[[ 1.  8.] [ 8. 25.]]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  在 NumPy 中，`*` 运算符表示<b>元素级 (element-wise)</b> 的乘法，而不是矩阵乘法。这意味着数组中对应位置的元素会相乘。  <pre>  [[1.*1., 2.*2.],   [4.*4., 5.*5.]]  </pre>  结果为 `[[1., 4.], [16., 25.]]`。<p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">x = np.array([[<span class="number">1.</span>, <span class="number">2.</span>], [<span class="number">4.</span>, <span class="number">5.</span>]])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;Element-wise multiplication (x * x):&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(x * x)</span><br><span class="line"></span><br><span class="line"><span class="comment"># For comparison, matrix multiplication:</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\nMatrix multiplication (x @ x):&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(x @ x)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>19. 代码 <code>arr1=np.arange(10); arr2=arr1[5:8]; arr2[:]=123; print(arr1)</code> 的输出是（ ）</strong><br>A. <code>array([ 0, 1, 2, 3, 4, 123, 6, 7, 8, 9])</code><br>B. <code>array([ 0, 1, 2, 3, 4, 123, 123, 123, 8, 9])</code><br>C. <code>array([ 0, 1, 2, 3, 4, 5, 123, 7, 8, 9])</code><br>D. <code>array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`arr2 = arr1[5:8]`</b>：在 NumPy 中，数组的切片返回的是原数组的<b>视图 (view)</b>，而不是副本。`arr2` 是 `arr1` 中 `[5, 6, 7]` 部分的视图。</li>    <li><b>`arr2[:] = 123`</b>：这会修改 `arr2` 视图中的所有元素。</li>    <li>由于 `arr2` 是 `arr1` 的视图，对 `arr2` 的修改会直接反映到 `arr1` 对应的位置上。所以，`arr1` 中索引 5, 6, 7 的元素都变成了 123。</li>  </ol><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr1 = np.arange(<span class="number">10</span>)</span><br><span class="line">arr2 = arr1[<span class="number">5</span>:<span class="number">8</span>]</span><br><span class="line">arr2[:] = <span class="number">123</span></span><br><span class="line"><span class="built_in">print</span>(arr1)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>20. 已知<code>arr=np.arange(1,10).reshape(3,3)</code>,执行<code>arr[:,:1]</code>得到的是（ ）</strong><br>A. <code>array([[1]])</code><br>B. <code>array([1,4,7])</code><br>C. <code>array([1,2,3])</code><br>D. <code>array([[1],[4],[7]])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `arr[:,:1]` 是一个切片操作。  <ul>    <li>`:`：在行上，选择所有行。</li>    <li>`:1`：在列上，选择从开始到索引 1 (不包含)的列，即只选择第 0 列。</li>  </ul>  因为在列的维度上使用的是切片 (`:1`) 而不是单个整数 (`0`)，所以结果会<b>保留列的维度</b>。因此，它返回一个 3 行 1 列的二维数组。<p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr = np.arange(<span class="number">1</span>,<span class="number">10</span>).reshape(<span class="number">3</span>,<span class="number">3</span>)</span><br><span class="line">result = arr[:,:<span class="number">1</span>]</span><br><span class="line"><span class="built_in">print</span>(result)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Shape: <span class="subst">&#123;result.shape&#125;</span>&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 对比使用整数索引</span></span><br><span class="line">result_int = arr[:,<span class="number">0</span>]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;\nResult of arr[:,0]: <span class="subst">&#123;result_int&#125;</span>&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Shape: <span class="subst">&#123;result_int.shape&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>21. 已知<code>c= np.arange(24).reshape(3,4,2)</code> 那么<code>c.sum(axis = 0)</code>所得的结果为（ ）</strong><br>A. <code>array([[12, 16],[44, 48],[76, 80]])</code><br>B. <code>array([[ 1, 5, 9, 13],[17, 21, 25, 29],[33, 37, 41, 45]])</code><br>C. <code>array([[24, 27], [30, 33],[36, 39],[42, 45]])</code><br>D. <code>array([[12, 14, 16, 18],[20, 22, 24, 26],[28, 30, 32, 34]])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>`c` 的形状是 `(3, 4, 2)`，可以看作 3 个 4x2 的“层”。</li>    <li>`c.sum(axis=0)` 表示沿着第一个轴（“层”的方向）进行求和。这意味着会将所有层中对应位置的元素相加，结果数组的形状将是 `(4, 2)`。</li>    <li>例如，结果的 `[0,0]` 位置是 `c[0,0,0] + c[1,0,0] + c[2,0,0]` = `0 + 8 + 16 = 24`。</li>    <li>结果的 `[0,1]` 位置是 `c[0,0,1] + c[1,0,1] + c[2,0,1]` = `1 + 9 + 17 = 27`。以此类推。</li>  </ul><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">c = np.arange(<span class="number">24</span>).reshape(<span class="number">3</span>,<span class="number">4</span>,<span class="number">2</span>)</span><br><span class="line">result = c.<span class="built_in">sum</span>(axis=<span class="number">0</span>)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>22. 下列对于<code>ndarray</code>的运算属性的叙述，错误的是：（ ）</strong><br>A. <code>.shape</code>表示<code>ndarray</code>对象的尺度，对于矩阵，表示它有几行几列。<br>B. <code>.size</code>表示<code>ndarray</code>对象元素的个数。<br>C. <code>.type</code>表示<code>ndarray</code>对象的元素类型。<br>D. <code>.itemsize</code>表示<code>ndarray</code>对象中每个元素的大小，以字节为单位。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `.shape`：正确，表示数组的维度。</li>    <li>B. `.size`：正确，表示元素的总数。</li>    <li>C. `.type`：错误。表示元素类型的属性是 <b>`.dtype`</b>。</li>    <li>D. `.itemsize`：正确，表示每个元素占用的字节数。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>23. 假设<code>arr = np.array([[1,2 ,3], [4, 5, 6]])</code>，下列关于arr的叙述，错误的是：（ ）</strong><br>A. 执行<code>arr[:]</code>，输出为<code>array([[1, 2, 3],[4, 5, 6]])</code>。<br>B. 执行<code>arr[0:10]</code>，会报错。<br>C. 执行<code>arr[:][:1]</code>输出结果与执行<code>arr[:,:1]</code>输出结果不相同。<br>D. 执行<code>arr[1,1] = 1</code>，<code>arr</code>输出结果为<code>array([[1, 2, 3],[4, 1, 6]])</code>。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确。`arr[:]` 选择所有行，返回原数组视图。</li>    <li>B: 错误。NumPy 切片中，超出范围的索引<b>不会报错</b>，它只会取到数组的末尾。`arr[0:10]` 会返回整个数组。</li>    <li>C: 正确。`arr[:][:1]` 返回第一行 `[[1, 2, 3]]`。`arr[:,:1]` 返回第一列 `[[1], [4]]`。</li>    <li>D: 正确。`arr[1,1] = 1` 修改了指定位置的元素。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr = np.array([[<span class="number">1</span>,<span class="number">2</span> ,<span class="number">3</span>], [<span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>]])</span><br><span class="line"><span class="built_in">print</span>(arr[<span class="number">0</span>:<span class="number">10</span>]) <span class="comment"># Demonstrates it does not error</span></span><br></pre></td></tr></table></figure></p></details><hr><p><strong>24. 假设<code>arr = np.array([[1,2 ,3], [4, 5, 6]])</code>，下列关于arr的叙述，错误的是：（ ）</strong><br>A. <code>arr[arr&lt;5] = 0</code>, <code>arr</code>输出结果为<code>array([[0, 0, 0],[0, 5, 6]])</code>。<br>B. <code>arr[arr&lt;5]</code>，输出结果为<code>array([1, 2, 3, 4])</code>。<br>C. <code>arr[~arr&lt;4]</code>，输出结果为<code>array([4, 5, 6])</code>。<br>D. <code>arr[[0],[0,1]]</code>，输出结果为<code>array([1, 2])</code>。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确。布尔索引赋值，将所有小于5的元素设为0。</li>    <li>B: 正确。布尔索引，返回所有小于5的元素组成的一维数组。</li>    <li>C: 错误。`~arr<4` 的语法有误。它会先对整数数组 `arr` 进行按位取反，再与4比较，结果不是预期的逻辑非。正确的逻辑非应为 `~(arr < 4)`。</li>    <li>D: 正确。花式索引，选择坐标为 `(0,0)` 和 `(0,1)` 的元素。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>25. 对于下面代码，运行之后得到的结果为（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">arr = np.arange(<span class="number">5</span>)</span><br><span class="line">arr_slice1 = arr[<span class="number">0</span>:<span class="number">3</span>]</span><br><span class="line">arr_slice1[<span class="number">0</span>] = <span class="number">6</span></span><br><span class="line"><span class="built_in">print</span>(arr) <span class="comment"># 第一个输出</span></span><br><span class="line">arr_slice2 = arr[<span class="number">0</span>:<span class="number">3</span>].copy()</span><br><span class="line">arr_slice2[<span class="number">0</span>] = <span class="number">0</span></span><br><span class="line"><span class="built_in">print</span>(arr) <span class="comment"># 第二个输出</span></span><br></pre></td></tr></table></figure><p>A. <code>[0,1,2,3,4]</code> ; <code>[0,1,2,3,4]</code><br>B. <code>[6,1,2,3,4]</code> ; <code>[6,1,2,3,4]</code><br>C. <code>[0,1,2,3,4]</code> ; <code>[6,1,2,3,4]</code><br>D. <code>[6,1,2,3,4]</code> ; <code>[0,1,2,3,4]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`arr_slice1 = arr[0:3]`</b>：`arr_slice1` 是 `arr` 的<b>视图</b>。</li>    <li><b>`arr_slice1[0] = 6`</b>：修改视图会影响原数组。`arr` 变为 `[6, 1, 2, 3, 4]`。</li>    <li>第一个 `print(arr)` 输出 `[6 1 2 3 4]`。</li>    <li><b>`arr_slice2 = arr[0:3].copy()`</b>：`arr_slice2` 是 `arr` 切片的<b>副本</b>。</li>    <li><b>`arr_slice2[0] = 0`</b>：修改副本<b>不会</b>影响原数组 `arr`。</li>    <li>第二个 `print(arr)` 输出时，`arr` 仍是 `[6 1 2 3 4]`。</li>  </ol><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>26. 对于<code>np.sort()</code>方法，以下说法正确的是（ ）</strong><br>A. 该方法不允许传递参数<br>B. 该方法是对原数组按位置排序<br>C. 该方法返回的是已经排序好的数组拷贝<br>D. 该方法不适用于多维数组</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`np.sort(arr)`</b> 是一个函数，它返回原数组 `arr` 的一个<b>已排序的副本</b>，不改变原数组。</li>    <li><b>`arr.sort()`</b> 是一个方法，它对数组 `arr` 进行<b>原地排序</b>，不返回值。</li>  </ul>  因此，C 是正确的描述。`np.sort()` 可以接受 `axis` 等参数，并且适用于多维数组。<p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>27. 下面代码的输出结果是 （ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">arr=np.arange(<span class="number">12</span>).reshape(<span class="number">3</span>,<span class="number">4</span>)</span><br><span class="line">arr[<span class="number">1</span>,:].shape</span><br></pre></td></tr></table></figure><p>A. (4,1)<br>B. (1,)<br>C. (4,)<br>D. (1,4)</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`arr[1,:]`</b>：这是一个索引和切片操作。</li>    <li>`1`：在行上使用<b>单个整数索引</b>选择索引为 1 的行。</li>    <li>当使用单个整数索引选择某个维度时，该维度会从结果中被移除（<b>降维</b>）。</li>  </ul>  所以 `arr[1,:]` 的结果是一个包含 4 个元素的一维数组 `[4, 5, 6, 7]`，其形状为 `(4,)`。<p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>28. 下面代码的输出结果是 （ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line">sample1 = [[<span class="number">1</span>,<span class="number">1</span>,<span class="number">1</span>],[<span class="number">2</span>,<span class="number">2</span>,<span class="number">2</span>],[<span class="number">3</span>,<span class="number">3</span>,<span class="number">3</span>]]</span><br><span class="line">sample2 = np.array([[<span class="number">1</span>,<span class="number">1</span>,<span class="number">1</span>],[<span class="number">2</span>,<span class="number">2</span>,<span class="number">2</span>],[<span class="number">3</span>,<span class="number">3</span>,<span class="number">3</span>]])</span><br><span class="line">arr1 = np.array(sample1)</span><br><span class="line">arr2 = np.array(sample2)</span><br><span class="line">sample1[<span class="number">1</span>] = [-<span class="number">2</span>,-<span class="number">2</span>,-<span class="number">2</span>]</span><br><span class="line">sample2[<span class="number">1</span>] = [-<span class="number">2</span>,-<span class="number">2</span>,-<span class="number">2</span>]</span><br><span class="line"><span class="built_in">print</span>(arr1)</span><br><span class="line"><span class="built_in">print</span>(arr2)</span><br></pre></td></tr></table></figure><p>A. <code>array([[1,1,1],[-2,-2,-2],[3,3,3]])</code> 和 <code>array([[1,1,1],[-2,-2,-2],[3,3,3]])</code><br>B. <code>array([[1,1,1],[2,2,2],[3,3,3]])</code> 和 <code>array([[1,1,1],[-2,-2,-2],[3,3,3]])</code><br>C. <code>array([[1,1,1],[2,2,2],[3,3,3]])</code> 和 <code>array([[1,1,1],[2,2,2],[3,3,3]])</code><br>D. <code>array([[1,1,1],[-2,-2,-2],[3,3,3]])</code> 和 <code>array([[1,1,1],[2,2,2],[3,3,3]])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <b>标准 NumPy 行为</b>：  <ul>    <li><b>`arr1 = np.array(sample1)`</b>：当从 Python 列表创建 `ndarray` 时，`np.array()` 会<b>复制数据</b>。`arr1` 是 `sample1` 的一个独立副本。</li>    <li><b>`arr2 = np.array(sample2)`</b>：当从一个 `ndarray` 创建另一个 `ndarray` 时，`np.array()` 默认也会<b>复制数据</b>。`arr2` 是 `sample2` 的一个独立副本。</li>    <li>因此，后续对 `sample1` 和 `sample2` 的修改<b>不会影响</b> `arr1` 和 `arr2`。</li>    <li>`arr1` 和 `arr2` 都会保持其初始值 `[[1,1,1],[2,2,2],[3,3,3]]`。</li>  </ul>  <b>题目意图分析</b>：  本题的选项 C 符合标准的 NumPy 行为。选项 A 暗示 `np.array()` 创建的是视图或某种链接，这在默认情况下是错误的。在选择题中，应遵循标准行为。<p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">sample1 = [[<span class="number">1</span>,<span class="number">1</span>,<span class="number">1</span>],[<span class="number">2</span>,<span class="number">2</span>,<span class="number">2</span>],[<span class="number">3</span>,<span class="number">3</span>,<span class="number">3</span>]]</span><br><span class="line">sample2 = np.array([[<span class="number">1</span>,<span class="number">1</span>,<span class="number">1</span>],[<span class="number">2</span>,<span class="number">2</span>,<span class="number">2</span>],[<span class="number">3</span>,<span class="number">3</span>,<span class="number">3</span>]])</span><br><span class="line">arr1 = np.array(sample1)</span><br><span class="line">arr2 = np.array(sample2)</span><br><span class="line">sample1[<span class="number">1</span>] = [-<span class="number">2</span>,-<span class="number">2</span>,-<span class="number">2</span>]</span><br><span class="line">sample2[<span class="number">1</span>,:] = [-<span class="number">2</span>,-<span class="number">2</span>,-<span class="number">2</span>] <span class="comment"># Note: use slice for ndarray modification</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;Final arr1:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(arr1)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\nFinal arr2:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(arr2)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>29. 下面代码的输出结果是（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">a=np.array( [[[<span class="number">1</span>,<span class="number">1</span>],[<span class="number">2</span>,<span class="number">2</span>],[<span class="number">3</span>,<span class="number">3</span>]],</span><br><span class="line">             [[<span class="number">4</span>,<span class="number">4</span>],[<span class="number">5</span>,<span class="number">5</span>],[<span class="number">6</span>,<span class="number">6</span>]],</span><br><span class="line">             [[<span class="number">7</span>,<span class="number">7</span>],[<span class="number">8</span>,<span class="number">8</span>],[<span class="number">9</span>,<span class="number">9</span>]],</span><br><span class="line">             [[<span class="number">10</span>,<span class="number">10</span>],[<span class="number">11</span>,<span class="number">11</span>],[<span class="number">12</span>,<span class="number">12</span>]]])</span><br><span class="line">a.mean(<span class="number">0</span>)</span><br></pre></td></tr></table></figure><p>A. <code>[[[ 1 1] [ 2 2] [ 3 3]] [[ 4 4] [ 5 5] [ 6 6]] ...]</code><br>B. <code>[[5.5 5.5] [6.5 6.5] [7.5 7.5]]</code><br>C. <code>[[ 2.  2.] [ 5.  5.] [ 8.  8.] [11. 11.]]</code><br>D. <code>[[ 1.  2.  3.] [ 4.  5.  6.] ...]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>`a` 的形状是 `(4, 3, 2)`，可以看作 4 个 3x2 的“层”。</li>    <li>`a.mean(0)` (或 `a.mean(axis=0)`) 表示沿着第一个轴（“层”的方向）计算平均值。结果数组的形状将是 `(3, 2)`。</li>    <li>例如，结果的 `[0,0]` 位置是 `(1 + 4 + 7 + 10) / 4 = 5.5`。</li>    <li>结果的 `[1,0]` 位置是 `(2 + 5 + 8 + 11) / 4 = 6.5`。以此类推。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">a=np.array( [[[<span class="number">1</span>,<span class="number">1</span>],[<span class="number">2</span>,<span class="number">2</span>],[<span class="number">3</span>,<span class="number">3</span>]],</span><br><span class="line">             [[<span class="number">4</span>,<span class="number">4</span>],[<span class="number">5</span>,<span class="number">5</span>],[<span class="number">6</span>,<span class="number">6</span>]],</span><br><span class="line">             [[<span class="number">7</span>,<span class="number">7</span>],[<span class="number">8</span>,<span class="number">8</span>],[<span class="number">9</span>,<span class="number">9</span>]],</span><br><span class="line">             [[<span class="number">10</span>,<span class="number">10</span>],[<span class="number">11</span>,<span class="number">11</span>],[<span class="number">12</span>,<span class="number">12</span>]]])</span><br><span class="line"><span class="built_in">print</span>(a.mean(<span class="number">0</span>))</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>30. 下面代码的输出结果是( )</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">arr1 = np.array([<span class="string">&#x27;Mike&#x27;</span>, <span class="string">&#x27;Bob&#x27;</span>])</span><br><span class="line">arr2 = np.array([<span class="string">&#x27;Bob&#x27;</span>, <span class="string">&#x27;Alice&#x27;</span>])</span><br><span class="line"><span class="built_in">print</span>(np.union1d(arr1, arr2))</span><br></pre></td></tr></table></figure><p>A. <code>[&#39;Alice&#39; &#39;Bob&#39; &#39;Mike&#39;]</code><br>B. <code>[&#39;Alice&#39;, &#39;Bob&#39;, &#39;Mike&#39;]</code><br>C. <code>[&#39;Mike&#39; &#39;Bob&#39; &#39;Alice&#39;]</code><br>D. <code>[&#39;Mike&#39;, &#39;Bob&#39;, &#39;Alice&#39;]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `np.union1d()` 函数计算两个一维数组的<b>并集</b>，即返回两个数组中所有<b>唯一的元素</b>，并且结果是<b>排序后</b>的。  <ul>    <li>两个数组的唯一元素是 `'Mike'`, `'Bob'`, `'Alice'`。</li>    <li>按字母顺序排序后是 `'Alice'`, `'Bob'`, `'Mike'`。</li>  </ul>  NumPy 数组打印时，元素之间通常用空格分隔。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr1 = np.array([<span class="string">&#x27;Mike&#x27;</span>, <span class="string">&#x27;Bob&#x27;</span>])</span><br><span class="line">arr2 = np.array([<span class="string">&#x27;Bob&#x27;</span>, <span class="string">&#x27;Alice&#x27;</span>])</span><br><span class="line"><span class="built_in">print</span>(np.union1d(arr1, arr2))</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>31. 输入<code>np.abs(12+5j)</code>的结果为？ （ ）</strong><br>A. 12<br>B. 13<br>C. 5<br>D. 17</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `np.abs()` 用于计算数字的绝对值。对于复数 `a + bj`，其绝对值（也称为模）是 `sqrt(a**2 + b**2)`。  <ul>    <li>`a = 12` (实部)</li>    <li>`b = 5` (虚部)</li>    <li>绝对值 = `sqrt(12**2 + 5**2)` = `sqrt(144 + 25)` = `sqrt(169)` = `13`。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"><span class="built_in">print</span>(np.<span class="built_in">abs</span>(<span class="number">12</span>+<span class="number">5j</span>))</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>32. 假设<code>x</code>是长度为<code>m</code>的向量，<code>y</code>是长度为<code>n</code>的向量，则输入 <code>X,Y=np.meshgrid(x,y)</code> 最终生成的矩阵<code>X</code>和<code>Y</code>的维度是 ( )</strong><br>A. <code>m,n</code><br>B. <code>m*n, n*m</code><br>C. <code>m*n, m*n</code><br>D. <code>n*m, n*m</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `np.meshgrid(x, y)` 用于从一维坐标数组 `x` (长度m) 和 `y` (长度n) 中生成二维网格坐标矩阵。  <ul>    <li>返回的第一个矩阵 `X`，其每一行都是 `x` 向量的重复，共有 `n` 行。所以 `X` 的维度是 `(n, m)`。</li>    <li>返回的第二个矩阵 `Y`，其每一列都是 `y` 向量的重复，共有 `m` 列。所以 `Y` 的维度也是 `(n, m)`。</li>  </ul>  D选项中的`nm`表示`n`行`m`列，是正确的。<p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">m = <span class="number">4</span> <span class="comment"># length of x</span></span><br><span class="line">n = <span class="number">3</span> <span class="comment"># length of y</span></span><br><span class="line">x = np.arange(m)</span><br><span class="line">y = np.arange(n)</span><br><span class="line">X, Y = np.meshgrid(x, y)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Shape of X: <span class="subst">&#123;X.shape&#125;</span>&quot;</span>) <span class="comment"># (n, m) -&gt; (3, 4)</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Shape of Y: <span class="subst">&#123;Y.shape&#125;</span>&quot;</span>) <span class="comment"># (n, m) -&gt; (3, 4)</span></span><br></pre></td></tr></table></figure></p></details><hr><p><strong>33. 以下程序的运行结果是（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">x = np.array([<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>,<span class="number">4</span>,<span class="number">5</span>], dtype = np.int8)</span><br><span class="line"><span class="built_in">print</span> (x.itemsize)</span><br></pre></td></tr></table></figure><p>A. 1<br>B. 8<br>C. 56<br>D. 64</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`dtype = np.int8`</b>：明确指定数组的数据类型为 8 位整数 (`int8`)。</li>    <li><b>`x.itemsize`</b>：返回数组中<b>每个元素</b>占用的大小（以<b>字节</b>为单位）。</li>  </ul>  8 位 (bit) 等于 1 字节 (byte)。因此，`itemsize` 的结果是 1。<p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>34. 已知<code>x=[3,5,7]</code>，那么执行语句<code>x[len(x): ]=[1,2]</code>之后，x的值为（ ）</strong><br>A. <code>[3,5,7,1,2]</code><br>B. <code>[3,5,7,1]</code><br>C. <code>[3,5,7]</code><br>D. <code>[1,2]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  这是一个 Python 列表的切片赋值操作。  <ul>    <li>`len(x)` 是 `3`。</li>    <li>`x[3:]` 表示从索引 3 开始到末尾的切片，对于原列表 `x` 来说，这是一个空切片。</li>    <li>将一个列表赋值给一个空切片，等同于在那个位置插入新列表的所有元素。在这里，相当于在列表末尾追加 `[1,2]`。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">x = [<span class="number">3</span>,<span class="number">5</span>,<span class="number">7</span>]</span><br><span class="line">x[<span class="built_in">len</span>(x):] = [<span class="number">1</span>,<span class="number">2</span>]</span><br><span class="line"><span class="built_in">print</span>(x)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>35. <code>arr = np.arange(32).reshape((8,4)) + 1</code>；<code>arr[[1,5,7,2],[0,3,1,2]]</code>输出的结果是：</strong><br>A. <code>array([ 5, 24, 30, 11])</code><br>B. <code>array([ 4, 23, 29, 10])</code><br>C. <code>array([[ 5,  8, ...]])</code><br>D. <code>array([[ 5,  6, ...]])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  这是一个<b>花式索引 (Fancy Indexing)</b>，使用两个等长的整数列表作为索引。它会选择对应坐标的单个元素，并返回一个一维数组。  <ul>    <li>`arr = np.arange(32).reshape((8,4)) + 1` 创建一个 8x4 的数组，元素从 1 到 32。</li>    <li>它会选择以下坐标的元素：        <ul>            <li>`(1, 0)` -> 值为 `5`</li>            <li>`(5, 3)` -> 值为 `24`</li>            <li>`(7, 1)` -> 值为 `30`</li>            <li>`(2, 2)` -> 值为 `11`</li>        </ul>    </li>  </ul>  因此，结果是 `array([5, 24, 30, 11])`。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr = np.arange(<span class="number">32</span>).reshape((<span class="number">8</span>,<span class="number">4</span>)) + <span class="number">1</span></span><br><span class="line">result = arr[[<span class="number">1</span>,<span class="number">5</span>,<span class="number">7</span>,<span class="number">2</span>],[<span class="number">0</span>,<span class="number">3</span>,<span class="number">1</span>,<span class="number">2</span>]]</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>36. 已知<code>c= np.arange(24).reshape(3,4,2)</code> 那么<code>c.sum(axis = 0)</code>所得的结果为（ ）</strong><br>A. <code>array([[12, 16],[44, 48],[76, 80]])</code><br>B. <code>array([[ 1, 5, ...]])</code><br>C. <code>array([[24, 27], [30, 33],[36, 39],[42, 45]])</code><br>D. <code>array([[12, 14, ...]])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  此题与第 21 题相同。  <ul>    <li>`c` 的形状是 `(3, 4, 2)`，可以看作 3 个 4x2 的“层”。</li>    <li>`c.sum(axis=0)` 表示沿着第一个轴（“层”的方向）进行求和。结果数组的形状将是 `(4, 2)`。</li>    <li>例如，结果的 `[0,0]` 位置是 `c[0,0,0] + c[1,0,0] + c[2,0,0]` = `0 + 8 + 16 = 24`。</li>    <li>结果的 `[0,1]` 位置是 `c[0,0,1] + c[1,0,1] + c[2,0,1]` = `1 + 9 + 17 = 27`。以此类推。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>37. <code>a = np.arange(20).reshape(4,5)</code>; <code>a[[0,2,3],[1,2,3]]</code> 输出结果是（ ）</strong><br>A. <code>array([[ 1, 2, 3], [11, 12, 13], [16, 17, 18]])</code><br>B. <code>array([ 1, 12, 18])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  这是一个<b>花式索引 (Fancy Indexing)</b>。它会选择对应坐标的单个元素，并返回一个一维数组。  <ul>    <li>`a = np.arange(20).reshape(4,5)` 创建一个 4x5 的数组。</li>    <li>它会选择以下坐标的元素：        <ul>            <li>`(0, 1)` -> 值为 `1`</li>            <li>`(2, 2)` -> 值为 `12`</li>            <li>`(3, 3)` -> 值为 `18`</li>        </ul>    </li>  </ul>  因此，结果是 `array([1, 12, 18])`。<p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">a = np.arange(<span class="number">20</span>).reshape(<span class="number">4</span>,<span class="number">5</span>)</span><br><span class="line">result = a[[<span class="number">0</span>,<span class="number">2</span>,<span class="number">3</span>],[<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>]]</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>38. 对<code>array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])</code>，<code>array[:, :-1]</code>的结果是</strong><br>A. <code>array([[1, 2, 3], [4 5, 6]])</code><br>B. <code>array([[1, 2], [4, 5]])</code><br>C. <code>array([[1, 2], [4, 5], [7, 8]])</code><br>D. <code>array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `array[:, :-1]` 是一个切片操作。  <ul>    <li>`:`：在行上，选择所有行。</li>    <li>`:-1`：在列上，选择从开始到倒数第一个元素之前（<b>不包含</b>倒数第一个元素）。</li>  </ul>  这个操作会从每一行中移除最后一列。<p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr = np.array([[<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>], [<span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>], [<span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>]])</span><br><span class="line">result = arr[:, :-<span class="number">1</span>]</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>39. 有下面4×6的二维数组：<code>arr= np.arange(24).reshape(4,6)</code> 则 <code>arr[[3, -2]][:, [1, 0, 3]]</code> 的输出结果为：</strong><br>A. <code>array([[13, 12, 14], [19, 18, 20]])</code><br>B. <code>array([[13, 12, 15], [19, 18, 21]])</code><br>C. <code>array([[19, 18, 20], [13, 12, 14]])</code><br>D. <code>array([[19, 18, 21], [13, 12, 15]])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  这是两次连续的索引操作。  <ol>    <li><b>`arr[[3, -2]]`</b>：第一次花式索引，选择行。        <ul>            <li>索引 `3` 是第4行：`[18, 19, 20, 21, 22, 23]`</li>            <li>索引 `-2` 是倒数第2行：`[12, 13, 14, 15, 16, 17]`</li>        </ul>        得到临时数组 `temp_arr`：`[[18, 19, 20, 21, 22, 23], [12, 13, 14, 15, 16, 17]]`    </li>    <li><b>`temp_arr[:, [1, 0, 3]]`</b>：第二次索引。        <ul>            <li>`:` 选择所有行。</li>            <li>`[1, 0, 3]` 选择列，并按此顺序排列。</li>        </ul>        从 `temp_arr` 中取出第1列 `[19, 13]`，第0列 `[18, 12]`，第3列 `[21, 15]`，组合得到 `[[19, 18, 21], [13, 12, 15]]`。    </li>  </ol><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>40. <code>arr=np.array([1.2, 2.4, 3.8, 4.5], dtype=np.int32); print(arr)</code> 输出的结果为（ ）</strong><br>A. <code>array([1, 2, 3, 4])</code><br>B. <code>[1, 2, 3, 4]</code><br>C. <code>[1, 2, 4, 5]</code><br>D. <code>array([1, 2, 4, 5])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <b>`dtype=np.int32`</b> 明确指定了数组的数据类型为 32 位整数。当从一个浮点数列表创建整数数组时，所有浮点数的小数部分都会被<b>截断</b>（直接舍弃，不进行四舍五入）。  <ul>    <li>`1.2` -> `1`</li>    <li>`2.4` -> `2`</li>    <li>`3.8` -> `3`</li>    <li>`4.5` -> `4`</li>  </ul>  因此，`arr` 的内容将是 `[1, 2, 3, 4]`，并且打印时会以 `array(...)` 形式显示。<p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>41. 执行以下代码的结果是( )</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">arr = np.arange(<span class="number">5</span>)</span><br><span class="line">arr_slice = arr[<span class="number">2</span>:<span class="number">4</span>]</span><br><span class="line">arr_slice = <span class="number">10086</span></span><br><span class="line"><span class="built_in">print</span>(arr)</span><br></pre></td></tr></table></figure><p>A. <code>array([0, 1, 2, 3, 4])</code><br>B. <code>array([0, 1, 10086, 10086, 4])</code><br>C. <code>array([0, 1, 10086, 10086, 10086])</code><br>D. <code>array([0, 1, 10086, 4])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`arr_slice = arr[2:4]`</b>：`arr_slice` 是 `arr` 的一个视图，指向 `[2, 3]`。</li>    <li><b>`arr_slice = 10086`</b>：<b>关键点</b>：这行代码不是修改视图内部的元素，而是将 `arr_slice` 这个<b>变量本身</b>重新赋值为一个新的整数 `10086`。</li>    <li>这条赋值语句<b>切断</b>了 `arr_slice` 变量与原数组视图的链接。</li>    <li>因此，原始数组 `arr` 没有被修改。</li>  </ol>  要修改原数组，应该使用 `arr_slice[:] = 10086`。<p>  <strong>正确答案：</strong> A</p></details><h2 id="第五章：Pandas-核心功能"><a href="#第五章：Pandas-核心功能" class="headerlink" title="第五章：Pandas 核心功能"></a>第五章：Pandas 核心功能</h2><p><strong>1. 下列哪个函数用来展示DataFrame的基础信息和它的统计数据（ ）</strong><br>A. <code>dataFrame.describe()</code><br>B. <code>dataFrame.head()</code><br>C. <code>dataFrame.info()</code><br>D. <code>dataFrame.values</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `dataFrame.describe()`</b>：生成描述性<b>统计数据</b>，包括计数、均值、标准差、最小值、最大值和四分位数，非常符合题意。</li>    <li><b>B. `dataFrame.head()`</b>：显示前几行数据，用于快速预览。</li>    <li><b>C. `dataFrame.info()`</b>：提供DataFrame的<b>基础信息</b>摘要，如索引、列、非空值数量和内存使用情况，但统计数据较少。</li>    <li><b>D. `dataFrame.values`</b>：返回DataFrame中的数据，是一个NumPy数组。</li>  </ul>  `describe()` 是最全面地提供“统计数据”的方法。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;col1&#x27;</span>: [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>], <span class="string">&#x27;col2&#x27;</span>: [<span class="number">10</span>, <span class="number">20</span>, <span class="number">30</span>, <span class="number">40</span>, np.nan]&#125;)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;DataFrame.describe():&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df.describe())</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\nDataFrame.info():&quot;</span>)</span><br><span class="line">df.info()</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>2. 以下时间不能被<code>pd.to_datetime()</code>函数转化为<code>xxxx-xx-xx</code>格式的是（ ）</strong><br>A. ‘01 Jan 2010’<br>B. ‘02-02-2011’<br>C. ‘20120303’<br>D. 都可以</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `pd.to_datetime()` 函数非常强大，能够自动识别并解析多种常见的日期和时间字符串格式。  <ul>    <li><b>A. '01 Jan 2010'</b>：(日 月 年) 格式，可被解析。</li>    <li><b>B. '02-02-2011'</b>：(月-日-年 或 日-月-年) 格式，可被解析。</li>    <li><b>C. '20120303'</b>：(YYYYMMDD) 格式，可被解析。</li>  </ul>  所有给出的字符串都可以被 `pd.to_datetime()` 成功解析。<p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(pd.to_datetime(<span class="string">&#x27;01 Jan 2010&#x27;</span>))</span><br><span class="line"><span class="built_in">print</span>(pd.to_datetime(<span class="string">&#x27;02-02-2011&#x27;</span>))</span><br><span class="line"><span class="built_in">print</span>(pd.to_datetime(<span class="string">&#x27;20120303&#x27;</span>))</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>3. 对于一个Series对象而言，若其中某一行含有缺失值NaN，在使用命令<code>sort_values()</code>之后，该行将会（ ）</strong><br>A. 自动被删除<br>B. 移到最前面<br>C. 移到最后面<br>D. 位置不作改变</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  当对 Pandas Series 使用 `sort_values()` 方法进行排序时，可以通过 `na_position` 参数控制缺失值 (`NaN`) 的位置。该参数的默认值是 `'last'`，这意味着缺失值会被放在排序结果的末尾。<p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">s = pd.Series([<span class="number">10</span>, np.nan, <span class="number">5</span>, <span class="number">20</span>])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;Original Series:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(s)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\nSorted Series (NaNs at the end by default):&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(s.sort_values())</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>4. 下列不属于DataFrame构造函数的有效输入的是：（ ）</strong><br>A. Series构成的字典<br>B. 字典构成的字典<br>C. 字典或者元组构成的列表<br>D. 字典或者Series构成的元组</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  Pandas DataFrame 构造函数 `pd.DataFrame()` 支持多种数据结构作为输入。  <ul>    <li><b>A. Series构成的字典</b>：有效。外层字典键为列名，Series为列数据。</li>    <li><b>B. 字典构成的字典</b>：有效。外层字典键为列名，内层字典键为行索引。</li>    <li><b>C. 字典构成的列表</b>：有效。每个字典代表一行。</li>    <li><b>D. 字典或者Series构成的元组</b>：无效。`pd.DataFrame()` 的 `data` 参数期望的是一个可迭代的结构（如列表），而不是一个元组直接作为容器。直接传入一个由字典或Series构成的元组通常会引发错误或产生非预期的结果。</li>  </ul><p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># A: Valid</span></span><br><span class="line">df_a = pd.DataFrame(&#123;<span class="string">&#x27;col1&#x27;</span>: pd.Series([<span class="number">1</span>, <span class="number">2</span>])&#125;)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;From Dict of Series:\n&quot;</span>, df_a)</span><br><span class="line"></span><br><span class="line"><span class="comment"># C: Valid (list of dicts)</span></span><br><span class="line">df_c = pd.DataFrame([&#123;<span class="string">&#x27;a&#x27;</span>: <span class="number">1</span>, <span class="string">&#x27;b&#x27;</span>: <span class="number">2</span>&#125;, &#123;<span class="string">&#x27;a&#x27;</span>: <span class="number">3</span>, <span class="string">&#x27;c&#x27;</span>: <span class="number">4</span>&#125;])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\nFrom List of Dicts:\n&quot;</span>, df_c)</span><br><span class="line"></span><br><span class="line"><span class="comment"># D: Invalid or unexpected behavior</span></span><br><span class="line"><span class="keyword">try</span>:</span><br><span class="line">  data_d = (&#123;<span class="string">&#x27;a&#x27;</span>: <span class="number">1</span>&#125;, &#123;<span class="string">&#x27;b&#x27;</span>: <span class="number">2</span>&#125;)</span><br><span class="line">  df_d = pd.DataFrame(data_d)</span><br><span class="line">  <span class="built_in">print</span>(<span class="string">&quot;\nFrom Tuple of Dicts:\n&quot;</span>, df_d)</span><br><span class="line"><span class="keyword">except</span> Exception <span class="keyword">as</span> e:</span><br><span class="line">  <span class="built_in">print</span>(<span class="string">f&quot;\nError from Tuple of Dicts: <span class="subst">&#123;e&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>5. 对于一个DataFrame对象，里面有一列数据名称叫做<code>year</code>，下列哪一条语句不能成功筛选出<code>year</code>这一列（ ）</strong><br>A. <code>frame.year</code><br>B. <code>frame[&#39;year&#39;]</code><br>C. <code>frame.T.iloc[0]</code><br>D. <code>frame.loc[&#39;year&#39;]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `frame.year`</b>：属性访问，如果列名是有效的 Python 标识符，则可行。</li>    <li><b>B. `frame['year']`</b>：字典式索引，通用且可靠的列选择方法。</li>    <li><b>C. `frame.T.iloc[0]`</b>：转置后，原列变成行。如果 `year` 是第一列，那么转置后它就是第一行，可以通过 `iloc[0]` 选中。可行。</li>    <li><b>D. `frame.loc['year']`</b>：`loc` 默认按<b>行标签</b>进行选择。除非 DataFrame 的行索引中恰好有一个标签是 `'year'`，否则此操作会因找不到行标签而报错。它不是用来选择列的。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>6. 假设<code>frame = pd.DataFrame([[1,2],[3,4]])</code>，以下操作可以将<code>frame</code>的行索引，列索引都改变为<code>‘a’</code>， <code>‘b’</code>的是：（ ）</strong><br>A. <code>frame.reindex([&#39;a&#39;,&#39;b&#39;])</code><br>B. <code>frame.reindex(columns = [&#39;a&#39;,&#39;b&#39;])</code><br>C. <code>frame.reindex(columns = [&#39;a&#39;,&#39;b&#39;], index = [&#39;a&#39;,&#39;b&#39;])</code><br>D. <code>frame.loc[[&#39;a&#39;, &#39;b&#39;], [&#39;a&#39;, &#39;b&#39;]]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `frame.reindex(['a','b'])`</b>：默认只改变行索引。</li>    <li><b>B. `frame.reindex(columns = ['a','b'])`</b>：只改变列索引。</li>    <li><b>C. `frame.reindex(columns = ['a','b'], index = ['a','b'])`</b>：`reindex()` 方法允许同时指定 `index` (行) 和 `columns` (列) 参数，可以同时改变二者。</li>    <li><b>D. `frame.loc[...]`</b>：`loc` 是用于按标签<b>选择</b>数据，而不是改变索引结构。</li>  </ul><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">frame = pd.DataFrame([[<span class="number">1</span>,<span class="number">2</span>],[<span class="number">3</span>,<span class="number">4</span>]])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;Original DataFrame:\n&quot;</span>, frame)</span><br><span class="line"></span><br><span class="line">result = frame.reindex(columns = [<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>], index = [<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\nResult of reindex on both axes:\n&quot;</span>, result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>7. 已知<code>myarr= np.arange(12).reshape(3,4)</code>，下列会报错的是（ ）</strong><br>A. <code>myarr[[0,1]]</code><br>B. <code>myarr[[0,1],[1]]</code><br>C. <code>myarr[[0,1],[1,2]]</code><br>D. <code>myarr[[0,1],[1,2,3]]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  花式索引 (Fancy Indexing) 中，如果同时提供行和列的索引列表，NumPy 期望这两个列表的<b>长度相同</b>，用于选择 `(row, col)` 对的元素。  <ul>    <li><b>A. `myarr[[0,1]]`</b>：只提供行索引，选择第 0 和第 1 行。有效。</li>    <li><b>B. `myarr[[0,1],[1]]`</b>：行索引列表长度为 2，列索引列表长度为 1。长度不匹配，会引发 `IndexError`。</li>    <li><b>C. `myarr[[0,1],[1,2]]`</b>：两个列表长度都为 2。有效。选择 `(0,1)` 和 `(1,2)` 处的元素。</li>    <li><b>D. `myarr[[0,1],[1,2,3]]`</b>：行索引列表长度为 2，列索引列表长度为 3。长度不匹配，会引发 `IndexError`。</li>  </ul>  B 和 D 都会报错，但 D 的长度差异更大。<p>  <strong>正确答案：</strong> D (或者 B，两者都因长度不匹配而报错)</p></details><hr><p><strong>8. <code>obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=[&#39;d&#39;, &#39;b&#39;, &#39;a&#39;, &#39;c&#39;])</code>；<code>obj.index=[&#39;a&#39;, &#39;d&#39;, &#39;b&#39;, &#39;e&#39;]</code>；<code>obj[&#39;a&#39;]</code>的输出结果是（ ）</strong><br>A. a -5.3<br>B. a 4.5<br>C. a 7.2<br>D. a 3.6</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`obj = pd.Series(...)`</b>：创建初始 Series。</li>    <li><b>`obj.index=['a', 'd', 'b', 'e']`</b>：这是对 Series 的 `index` 属性进行<b>直接重新赋值</b>。新的索引列表会按顺序与原 Series 的值进行对应。        <ul>            <li>第一个值 `4.5` 的新索引是 `'a'`。</li>            <li>第二个值 `7.2` 的新索引是 `'d'`。</li>            <li>第三个值 `-5.3` 的新索引是 `'b'`。</li>            <li>第四个值 `3.6` 的新索引是 `'e'`。</li>        </ul>    </li>    <li><b>`obj['a']`</b>：在修改后的 Series 中，通过新标签 `'a'` 访问，得到的值是 `4.5`。</li>  </ol><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">obj = pd.Series([<span class="number">4.5</span>, <span class="number">7.2</span>, -<span class="number">5.3</span>, <span class="number">3.6</span>], index=[<span class="string">&#x27;d&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;c&#x27;</span>])</span><br><span class="line">obj.index = [<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;d&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;e&#x27;</span>]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;Series after re-assigning index:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(obj)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;\nValue for index &#x27;a&#x27;: <span class="subst">&#123;obj[<span class="string">&#x27;a&#x27;</span>]&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>9. 下列代码的输出是（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">data2 = pd.Series(np.arange(<span class="number">5</span>), index = [<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>, <span class="string">&#x27;d&#x27;</span>, <span class="string">&#x27;e&#x27;</span>])</span><br><span class="line">data2[<span class="string">&#x27;b&#x27;</span>: <span class="string">&#x27;d&#x27;</span>] = <span class="number">2.</span></span><br><span class="line"><span class="built_in">print</span>(data2)</span><br></pre></td></tr></table></figure><p>A. <code>a 0.0 b 2.0 c 2.0 d 2.0 e 4.0</code><br>B. <code>a 1.0 b 2.0 c 2.0 d 2.0 e 5.0</code><br>C. <code>a 0.0 b 2.0 c 2.0 d 3.0 e 4.0</code><br>D. <code>a 1.0 b 2.0 c 2.0 d 2.0 e 4.0</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`data2 = pd.Series(...)`</b>：创建 Series `a:0, b:1, c:2, d:3, e:4`。</li>    <li><b>`data2['b': 'd']`</b>：在 Pandas 中，使用标签进行切片是<b>包含结束标签</b>的。所以它会选择索引为 `'b'`, `'c'`, `'d'` 的元素。</li>    <li><b>`= 2.`</b>：将这些选中的元素（原值为 `1, 2, 3`）赋值为浮点数 `2.0`。因为赋值的是浮点数，整个 Series 的数据类型 (`dtype`) 会被提升为 `float64`。</li>  </ol>  最终结果是 `a:0.0, b:2.0, c:2.0, d:2.0, e:4.0`。<p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>10. 下列对pandas中的索引对象的叙述，错误的是：（ ）</strong><br>A. 索引对象是不可变的，因此用户是无法修改索引对象的。<br>B. 可以用 <code>&#39;pop&#39; in frame.columns</code> 查看pop是否为DataFrame对象frame中的列。<br>C. 在构造Series或者DataFrame时，所使用的任意数组或者标签序列都可以在内部转化为索引对象。<br>D. 与python集合一样，pandas索引也不可以包含重复标签。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. 正确。Index 对象一旦创建，其元素不可修改，这保证了数据结构的安全。</li>    <li>B. 正确。`frame.columns` 是一个 Index 对象，可以使用 `in` 运算符检查成员。</li>    <li>C. 正确。Pandas 会自动将传入的标签序列转换为 `pd.Index` 对象。</li>    <li>D. 错误。与 Python 的 `set` 不同，Pandas 的 Index <b>可以包含重复的标签</b>。</li>  </ul><p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">s_dup = pd.Series([<span class="number">10</span>, <span class="number">20</span>, <span class="number">30</span>], index=[<span class="string">&#x27;x&#x27;</span>, <span class="string">&#x27;x&#x27;</span>, <span class="string">&#x27;y&#x27;</span>])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;Series with duplicate index is allowed:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(s_dup)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\nSelecting duplicate label &#x27;x&#x27; returns multiple values:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(s_dup[<span class="string">&#x27;x&#x27;</span>])</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>11. 执行<code>frame = pd.DataFrame([[1, 2, 3], [3, 4, 6]]); frame.drop(0, axis = 1, inplace = False); print(frame)</code>，输出结果为：（ ）</strong><br>A. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/1.png" alt="这里填写图片1的描述"><br>B. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/2.png" alt="这里填写图片1的描述"><br>C. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/3.png" alt="这里填写图片1的描述"><br>D. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/4.png" alt="这里填写图片1的描述"></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`frame.drop(0, axis=1, ...)`</b>：`axis=1` 表示删除<b>列</b>，标签为 `0` 的列被选中。</li>    <li><b>`inplace = False`</b>：这是关键。它表示该操作<b>不会修改</b>原始的 `frame` 对象，而是会返回一个删除了列的新 DataFrame。</li>    <li>因为 `drop` 操作的结果没有被赋给任何变量，所以它被丢弃了。</li>    <li><b>`print(frame)`</b>：最后打印的是原始的 `frame`，它没有被改变。</li>  </ul>  因此，输出结果是原始的 DataFrame。<p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line">frame = pd.DataFrame([[<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>],[<span class="number">3</span>,<span class="number">4</span>,<span class="number">6</span>]])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(frame)</span><br><span class="line"></span><br><span class="line"><span class="comment"># drop 操作的结果没有被保存，原始 frame 不变</span></span><br><span class="line">frame.drop(<span class="number">0</span>, axis = <span class="number">1</span>, inplace = <span class="literal">False</span>)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n执行 drop 操作后，再次打印 frame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(frame)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>12. 对于一个新的DataFrame对象，删除名字为’score’的这一列的操作是（ ）</strong><br>A. <code>frame.drop(&#39;score&#39;)</code><br>B. <code>frame.drop(frame.T.drop(&#39;score&#39;).T)</code><br>C. <code>del frame(&#39;score&#39;, axis = 1)</code><br>D. <code>del frame[&#39;score&#39;]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `frame.drop('score')` 默认删除<b>行</b> (`axis=0`)，不是列。</li>    <li>B. 语法过于复杂且不标准。</li>    <li>C. `del` 是 Python 关键字，不是函数，`del ...(...)` 是语法错误。</li>    <li>D. `del frame['score']` 是使用 `del` 关键字删除 DataFrame 中指定列的标准且简洁的方法。</li>  </ul><p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">frame = pd.DataFrame(&#123;<span class="string">&#x27;score&#x27;</span>: [<span class="number">10</span>, <span class="number">20</span>], <span class="string">&#x27;team&#x27;</span>: [<span class="string">&#x27;A&#x27;</span>, <span class="string">&#x27;B&#x27;</span>]&#125;)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;Original DataFrame:\n&quot;</span>, frame)</span><br><span class="line"><span class="keyword">del</span> frame[<span class="string">&#x27;score&#x27;</span>]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\nDataFrame after `del frame[&#x27;score&#x27;]`:\n&quot;</span>, frame)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>13. 已知<code>df=pd.DataFrame(...)</code>, 执行<code>df.sum()</code>得到的结果是（ ）</strong><br>A. <code>a 1.0 b 5.0 c 0.0 d 9.0</code><br>B. <code>one 7.0 two 8.0</code><br>C. <code>15.0</code><br>D. <code>one 7.0 two 15.0</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`df.sum()`</b>：对于 DataFrame，`sum()` 方法默认沿着 `axis=0`（即按<b>列</b>）进行求和。</li>    <li>在求和过程中，默认会跳过缺失值 (`NaN`)。</li>    <li><b>'one' 列</b>: `1.0 + 2.0 + 4.0 = 7.0`。</li>    <li><b>'two' 列</b>: `3.0 + 5.0 = 8.0`。</li>  </ul>  结果是一个 Series，其索引是原 DataFrame 的列名，值是各列的和。<p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">df = pd.DataFrame([[<span class="number">1</span>,np.nan],[<span class="number">2</span>,<span class="number">3</span>],[np.nan,np.nan],[<span class="number">4</span>,<span class="number">5</span>]],</span><br><span class="line">                  index=[<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;d&#x27;</span>],</span><br><span class="line">                  columns=[<span class="string">&#x27;one&#x27;</span>,<span class="string">&#x27;two&#x27;</span>])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;Original DataFrame:\n&quot;</span>, df)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\nResult of df.sum():&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df.<span class="built_in">sum</span>())</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>14. 以下哪个嵌套字典能生成目标DataFrame对象（ ）</strong></p><pre>     Num  Val2019   1    22020   3    4</pre><p>A. <code>&#123;&#39;2019&#39;:&#123;&#39;Num&#39;:1, &#39;Val&#39;:2&#125;, &#39;2020&#39;:&#123;&#39;Num&#39;:3, &#39;Val&#39;:4&#125;&#125;</code><br>B. <code>&#123;&#39;Num&#39;:&#123;2019:1, 2020:3&#125;, &#39;Val&#39;:&#123;2019:2, 2020:4&#125;&#125;</code><br>C. <code>&#123;&#123;1,2&#125;:...&#125;`D. 不能通过嵌套字典产生<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  当使用嵌套字典构建 DataFrame 时，<b>外层字典的键成为列名</b>，<b>内层字典的键成为行索引</b>。  <ul>    <li>目标 DataFrame 的列名是 `['Num', 'Val']`，行索引是 `[2019, 2020]`。</li>    <li><b>A</b>: 外层键是 `'2019', '2020'`，会成为列名。不符。</li>    <li><b>B</b>: 外层键是 `'Num', 'Val'`，会成为列名。内层键是 `2019, 2020`，会成为行索引。完全匹配。</li>    <li><b>C</b>: 语法错误，集合不能作为字典的键。</li>  </ul>  **正确答案：** B  **代码示例：**  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">data_B = &#123;<span class="string">&#x27;Num&#x27;</span>:&#123;<span class="number">2019</span>:<span class="number">1</span>, <span class="number">2020</span>:<span class="number">3</span>&#125;, <span class="string">&#x27;Val&#x27;</span>:&#123;<span class="number">2019</span>:<span class="number">2</span>, <span class="number">2020</span>:<span class="number">4</span>&#125;&#125;</span><br><span class="line">df_B = pd.DataFrame(data_B)</span><br><span class="line"><span class="built_in">print</span>(df_B)</span><br></pre></td></tr></table></figure></details>---**15. 关于DataFrame排序，以下方法是按照列标签的降序排序的是（ ）**A. `frame.sort_index(axis=0,ascending=True)`B. `frame.sort_index(axis=0,ascending=False)`C. `frame.sort_index(axis=1,ascending=False)`D. `frame.sort_index(axis=1,ascending=True)`<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `DataFrame.sort_index()` 方法用于根据索引标签进行排序。  <ul>    <li><b>`axis=1`</b> (或 `'columns'`) 表示按<b>列标签</b>排序。</li>    <li><b>`ascending=False`</b> 表示<b>降序</b>排序。</li>  </ul>  因此，选项 C 完全符合“按照列标签的降序排序”的要求。  **正确答案：** C  **代码示例：**  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">frame = pd.DataFrame(columns=[<span class="string">&#x27;c&#x27;</span>, <span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;Original columns:&quot;</span>, frame.columns.tolist())</span><br><span class="line"></span><br><span class="line">sorted_frame = frame.sort_index(axis=<span class="number">1</span>, ascending=<span class="literal">False</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;Sorted columns:&quot;</span>, sorted_frame.columns.tolist())</span><br></pre></td></tr></table></figure></details>---**16. 下面代码，返回的结果为（ ）**<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">data = np.arange(<span class="number">16</span>).reshape(<span class="number">4</span>,<span class="number">4</span>)</span><br><span class="line">df1 = pd.DataFrame(data)</span><br><span class="line">df2 = pd.DataFrame(df1)</span><br><span class="line">df3 = pd.DataFrame(data)</span><br><span class="line">df4 = pd.DataFrame(data)</span><br><span class="line"><span class="built_in">print</span>(df1 <span class="keyword">is</span> df2, df1.index <span class="keyword">is</span> df2.index, df3.index <span class="keyword">is</span> df4.index)</span><br></pre></td></tr></table></figure>A. `True True True`B. `False True False`C. `True False True`D. `False False False`<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `is` 运算符检查两个变量是否引用内存中的同一个对象。  <ul>    <li><b>`df1 is df2`</b>：`pd.DataFrame(another_df)` 默认会创建数据的副本，所以 `df1` 和 `df2` 是两个不同的 DataFrame 对象。结果为 <b>`False`</b>。</li>    <li><b>`df1.index is df2.index`</b>：`df1` 和 `df2` 的索引都是默认的 `RangeIndex`。Pandas 会对这些相同的不可变索引对象进行内部缓存和复用以节省内存。所以它们很可能指向同一个对象。结果为 <b>`True`</b>。</li>    <li><b>`df3.index is df4.index`</b>：根据题目选项，这里假设 `df3` 和 `df4` 的索引没有被复用，是两个独立的对象（尽管内容相同）。这在某些 Pandas 版本或特定情况下可能发生。结果为 <b>`False`</b>。</li>  </ul>  综合起来是 `False, True, False`。  **正确答案：** B</details>---**17. pandas中Series的默认数据类型是（ ）**A. float64B. int64C. objectD. bool<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  Pandas Series 的数据类型 (`dtype`) 是根据其包含的数据自动推断的，没有一个固定的“默认值”。但 `float64` 是最常见的推断类型之一，因为它具有很好的兼容性：  <ul>    <li>如果数据中包含浮点数，`dtype` 会是 `float64`。</li>    <li>如果数据中包含整数和缺失值 `NaN`，`dtype` 也会被提升为 `float64`，因为 `NaN` 是一个浮点数类型的值。</li>  </ul>  考虑到处理真实世界数据时缺失值的普遍性，`float64` 成为了事实上的“默认”数值类型。  **正确答案：** A</details>---**18. 下列说法错误的是（ ）**A. pandas中的索引对象是不可变的，因此用户无法修改索引对象。B. 在DataFrame中，reindex可改变行索引、列索引、也可同时改变二者。C. 在reindex方法的参数中，method=‘ffill’为后向填充，‘bfill’为前向填充。D. 普通的python切片是不包含尾部的，Series切片包含尾部。<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. 正确。Index 对象不可变。</li>    <li>B. 正确。`reindex` 可通过 `index` 和 `columns` 参数作用于两个轴。</li>    <li>C. 错误。<b>`ffill`</b> (forward-fill) 是<b>前向</b>填充；<b>`bfill`</b> (backward-fill) 是<b>后向</b>填充。描述正好相反。</li>    <li>D. 正确。Python 切片 `[a:b]` 不包含 `b`；Pandas <b>标签</b>切片 `['a':'b']` 包含 `'b'`。</li>  </ul>  **正确答案：** C</details>---**19. 下列哪种方法是计算两个索引的交集？( )**A. `difference`B. `intersection`C. `union`D. `append`<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  Pandas Index 对象提供了类似集合的运算方法。  <ul>    <li>`A. difference()`：差集</li>    <li><b>B. `intersection()`</b>：<b>交集</b></li>    <li>`C. union()`：并集</li>    <li>`D. append()`：用于拼接，不是集合运算。</li>  </ul>  **正确答案：** B  **代码示例：**  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">idx1 = pd.Index([<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>])</span><br><span class="line">idx2 = pd.Index([<span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>, <span class="string">&#x27;d&#x27;</span>])</span><br><span class="line"><span class="built_in">print</span>(idx1.intersection(idx2))</span><br><span class="line"><span class="comment"># 输出: Index([&#x27;b&#x27;, &#x27;c&#x27;], dtype=&#x27;object&#x27;)</span></span><br></pre></td></tr></table></figure></details>---**20. `obj=pd.Series(np.arange(4),index=['x1','x2','x4','x3'])`，`obj['x1':'x3']`的输出结果是（ ）**A. `x1 0 x2 1 dtype: int32`B. `x1 0 x2 1 x4 2 x3 3 dtype: int32`C. `x1 0 x3 3 dtype: int32`D. `x1 0 x2 1 x4 2 x3 3 dtype: int32`<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>Series 的索引是 `['x1', 'x2', 'x4', 'x3']`，这是一个<b>无序</b>的索引。</li>    <li>当对一个 Series 使用标签切片时，它会包含开始和结束标签。</li>    <li>对于无序索引，切片会返回从开始标签到结束标签之间所有<b>按原始位置顺序</b>的元素。</li>    <li>`'x1'` 是第一个元素，`'x3'` 是最后一个元素，因此 `'x1':'x3'` 的切片会包含所有元素。</li>  </ul>  **正确答案：** B  **代码示例：**  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">obj = pd.Series(np.arange(<span class="number">4</span>), index=[<span class="string">&#x27;x1&#x27;</span>,<span class="string">&#x27;x2&#x27;</span>,<span class="string">&#x27;x4&#x27;</span>,<span class="string">&#x27;x3&#x27;</span>])</span><br><span class="line"><span class="built_in">print</span>(obj[<span class="string">&#x27;x1&#x27;</span>:<span class="string">&#x27;x3&#x27;</span>])</span><br></pre></td></tr></table></figure></details>---**21. 下面语句能输出DataFrame第一列前三行的数据的是（ ）**<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># data 和 frame 的定义...</span></span><br></pre></td></tr></table></figure>A. `print(frame.state[:2])`B. `print(frame.iloc[0:2,[0]])`C. `print(frame.loc[0:2,'state'])`D. `print(frame.loc[0:3,'state'])`<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A</b>: `[:2]` 选择前两行。不符。</li>    <li><b>B</b>: `iloc[0:2,...]` 选择前两行。不符。</li>    <li><b>C</b>: `loc[0:2,...]` 对整数行索引进行标签切片时，是<b>包含结束索引</b>的，所以 `0:2` 会选择行 `0, 1, 2` (前三行)。`'state'` 选择了第一列。符合。</li>    <li><b>D</b>: `loc[0:3,...]` 选择前四行。不符。</li>  </ul>  **正确答案：** C  **代码示例：**  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">data = &#123;<span class="string">&#x27;state&#x27;</span>: [<span class="string">&#x27;Ohio&#x27;</span>, <span class="string">&#x27;Ohio&#x27;</span>, <span class="string">&#x27;Ohio&#x27;</span>, <span class="string">&#x27;Nevada&#x27;</span>], <span class="string">&#x27;year&#x27;</span>: [<span class="number">2000</span>, <span class="number">2001</span>, <span class="number">2002</span>, <span class="number">2001</span>]&#125;</span><br><span class="line">frame = pd.DataFrame(data)</span><br><span class="line"><span class="built_in">print</span>(frame.loc[<span class="number">0</span>:<span class="number">2</span>, <span class="string">&#x27;state&#x27;</span>])</span><br></pre></td></tr></table></figure></details>---**22. 已知 `s2=pd.Series(...)`，下列不正确的排序方法是：（ ）**A. `s2.sort_index(ascending=False)`B. `s2.sort_index(axis=1)`C. `s2.sort_index(axis=0)`<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>Pandas Series 是一维数据结构，它只有一个轴，即 `axis=0`（行轴）。</li>    <li>A: 按行索引降序排序，有效。</li>    <li><b>B: `axis=1` 表示列轴，对于 Series 来说是不存在的。尝试在 `axis=1` 上排序会引发 `ValueError`。</b></li>    <li>C: 按行索引升序排序（默认行为），有效。</li>  </ul>  **正确答案：** B</details>---**23. pandas中，用于表示缺失值的是( )**A. `[空]`B. `NaN`C. `Null`D. `None`<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>在 Pandas 和 NumPy 中，表示缺失值的标准标记是 <b>`NaN` (Not a Number)</b>。</li>    <li>`NaN` 是一个特殊的浮点数值，因此当一个整数列中出现缺失值时，该列的 `dtype` 通常会被转换为 `float`。</li>    <li>虽然 Pandas 也能识别 Python 的 `None` 对象作为缺失值，但它在内部通常会将其转换为 `NaN`（对于数值类型）或 `NaT`（对于日期时间类型）。</li>  </ul>  **正确答案：** B</details>---**24. 有下面DataFrame，**<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">data = pd.DataFrame(np.arange(<span class="number">16</span>).reshape((<span class="number">4</span>,<span class="number">4</span>)),</span><br><span class="line">                    columns = [<span class="string">&#x27;one&#x27;</span>, <span class="string">&#x27;two&#x27;</span>, <span class="string">&#x27;three&#x27;</span>, <span class="string">&#x27;four&#x27;</span>])</span><br></pre></td></tr></table></figure>**下列代码中能输出结果（如下图）的是（ ）**![这里填写图片1的描述](https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python数据分析选择题整理/5.png)A. `data[three > 5]`B. `data[' three ' > 5]`C. `data[data['three'] > 6]`D. `data[2:3]`<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  目标是筛选出 `'three'` 列的值大于 6 的所有行。  <ul>    <li><b>A, B</b>: 语法错误。不能直接在索引中进行这样的比较。</li>    <li><b>C. `data[data['three'] > 6]`</b>：        <ul>            <li>`data['three']` 获取 'three' 列，其值为 `[2, 6, 10, 14]`。</li>            <li>`data['three'] > 6` 生成一个布尔 Series `[False, False, True, True]`。</li>            <li>`data[...]` 使用这个布尔 Series 作为<b>行</b>索引，会筛选出布尔值为 `True` 的行，即索引为 2 和 3 的行。这正确地选择了所需的行。</li>        </ul>    </li>    <li><b>D. `data[2:3]`</b>：这是一个行切片，只选择了第 2 行，不符合要求。</li>  </ul>  **正确答案：** C  **代码示例：**  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">data = pd.DataFrame(np.arange(<span class="number">16</span>).reshape((<span class="number">4</span>,<span class="number">4</span>)),</span><br><span class="line">                    columns = [<span class="string">&#x27;one&#x27;</span>, <span class="string">&#x27;two&#x27;</span>, <span class="string">&#x27;three&#x27;</span>, <span class="string">&#x27;four&#x27;</span>])</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(data)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行选项 C 的代码</span></span><br><span class="line">result = data[data[<span class="string">&#x27;three&#x27;</span>] &gt; <span class="number">6</span>]</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n筛选后的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></details>---**25. `aSer = pd.Series([1,3,5], index = ['a', 'b', 'c'])`,以下哪一项不能获取第0个和第2个元素（ ）**A. `aSer[[0,2]]`B. `aSer[['a','c']]`C. `aSer[['0','c']]`D. 以上都可以<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `aSer[[0,2]]`</b>：使用<b>整数位置</b>列表进行索引，选择位置 0 和 2 的元素。有效。</li>    <li><b>B. `aSer[['a','c']]`</b>：使用<b>标签</b>列表进行索引，选择标签 'a' 和 'c' 的元素。有效。</li>    <li><b>C. `aSer[['0','c']]`</b>：使用标签列表进行索引。Series 的索引中没有 `'0'` 这个<b>字符串标签</b>，因此会引发 `KeyError`。</li>  </ul>  **正确答案：** C</details>---**26. `obj2a = pd.Series(...)`，`obja=pd.Series(...)`，以下表述错误的是（ ）**A. 执行：`obja['a':'h']` 输出：`a 4 b 7 c -5 d 1`B. 执行：`obj2a['a':'h']` 输出：`a 7 c -5 d 1`C. 执行：`obja['a':'d']` 输出：`a 4 b 7 c -5 d 1`D. 执行：`obj2a['a':'f']` 输出：`a 7 c -5 f 1`<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>`obja` 的索引 `['a','b','c','d']` 是<b>有序的</b>。</li>    <li>`obj2a` 的索引 `['d','a','c','f']` 是<b>无序的</b>。</li>  </ul>  分析 B:  <ul>    <li>`obj2a['a':'h']`：对无序索引进行切片，从标签 `'a'` 开始，到标签 `'h'` 结束。</li>    <li>因为 `'h'` 不在索引中，切片会到 Series 的末尾。</li>    <li>它会从 `'a'` 开始，按原始位置顺序取到末尾，即 `'a'`, `'c'`, `'f'`。</li>    <li>结果应为 `a 7, c -5, f 1`。</li>    <li>选项 B 的输出是 `a 7, c -5, d 1`，其中值和标签 `d 1` 都是错误的。因此此表述错误。</li>  </ul>  **正确答案：** B</details>## 第六章：数据输入输出与接口**1. `Response`对象的`json`方法返回的是（ ）**A. JSON对象B. 字典C. DataFrameD. Series<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `requests` 库的 `Response` 对象的 `.json()` 方法用于解析响应体中的 JSON 格式数据。它会将 JSON 字符串反序列化为对应的 Python 对象。  <ul>    <li>一个 JSON 对象 (`&#123;...&#125;`) 会被解析为 Python 的<b>字典 (`dict`)</b>。</li>    <li>一个 JSON 数组 (`[...]`) 会被解析为 Python 的<b>列表 (`list`)</b>。</li>  </ul>  在给出的选项中，“字典”是 JSON 对象在 Python 中最直接的对应形式。  **正确答案：** B  **代码示例：**  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> requests</span><br><span class="line"></span><br><span class="line"><span class="comment"># 这是一个返回 JSON 数组的公共 API 示例</span></span><br><span class="line"><span class="comment"># 数组中的每个元素都是一个 JSON 对象</span></span><br><span class="line">url = <span class="string">&#x27;https://api.github.com/repos/pandas-dev/pandas/issues&#x27;</span> </span><br><span class="line"><span class="keyword">try</span>:</span><br><span class="line">  resp = requests.get(url)</span><br><span class="line">  resp.raise_for_status() <span class="comment"># 如果请求失败则抛出异常</span></span><br><span class="line"></span><br><span class="line">  <span class="comment"># .json() 方法将 JSON 响应体解析为 Python 对象</span></span><br><span class="line">  data = resp.json() </span><br><span class="line"></span><br><span class="line">  <span class="built_in">print</span>(<span class="string">f&quot;data 的类型是: <span class="subst">&#123;<span class="built_in">type</span>(data)&#125;</span>&quot;</span>) <span class="comment"># 通常是 list 或 dict</span></span><br><span class="line">  </span><br><span class="line">  <span class="comment"># 检查 data 是否为非空列表，并查看其第一个元素的类型</span></span><br><span class="line">  <span class="keyword">if</span> <span class="built_in">isinstance</span>(data, <span class="built_in">list</span>) <span class="keyword">and</span> data:</span><br><span class="line">      <span class="built_in">print</span>(<span class="string">f&quot;列表中第一个元素的类型是: <span class="subst">&#123;<span class="built_in">type</span>(data[<span class="number">0</span>])&#125;</span>&quot;</span>)</span><br><span class="line"><span class="keyword">except</span> requests.exceptions.RequestException <span class="keyword">as</span> e:</span><br><span class="line">  <span class="built_in">print</span>(<span class="string">f&quot;请求失败: <span class="subst">&#123;e&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></details>---**2. 以下表示输出的数据结构是 列->值 的形式的式子是（ ）**A. `data.to_json(orient='columns')`B. `data.to_json(orient='records')`C. `data.to_json(orient='index')`D. `data.to_json(orient='split')`<details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  Pandas DataFrame 的 `.to_json()` 方法中，`orient` 参数控制输出 JSON 的结构。  <ul>    <li><b>`orient='columns'`</b>：输出为 `&#123;列: &#123;行索引: 值&#125;&#125;</code> 的形式。</li><br>    <li><b><code>orient=&#39;records&#39;</code></b>：输出为 <code>[&#123;列1: 值, 列2: 值&#125;, ...]</code> 的形式。这是一个列表，其中每个字典代表 DataFrame 的一行，键是列名，值是该行对应的数据。这完全符合“列-&gt;值”的描述。</li><br>    <li><b><code>orient=&#39;index&#39;</code></b>：输出为 <code>&#123;行索引: &#123;列: 值&#125;&#125;</code> 的形式。</li><br>    <li><b><code>orient=&#39;split&#39;</code></b>：输出为 <code>&#123;index: [...], columns: [...], data: [[...]]&#125;</code> 的形式。</li><br>  </ul></p><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;col1&#x27;</span>: [<span class="number">1</span>, <span class="number">2</span>], <span class="string">&#x27;col2&#x27;</span>: [<span class="number">3</span>, <span class="number">4</span>]&#125;)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df)</span><br><span class="line"></span><br><span class="line"><span class="comment"># orient=&#x27;records&#x27; 输出为 [&#123;列: 值&#125;, ...] 的形式</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\norient=&#x27;records&#x27; 的输出:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df.to_json(orient=<span class="string">&#x27;records&#x27;</span>, indent=<span class="number">4</span>))</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>3. 以下对<code>read_csv/read_table</code>函数参数叙述错误的是（ ）</strong><br>A. <code>skiprows</code>表示从文件开头处起，需要跳过的行数或者行号列表。<br>B. <code>na_values</code>指定需要用NA替换的值序列。<br>C. <code>sep</code>或<code>delimiter</code>指定用于分隔每行字段的字符序列或者正则表达式。<br>D. <code>names</code> 是结果的列名列表，它不可以和<code>header</code>参数一起用。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `skiprows`：叙述正确。</li>    <li>B. `na_values`：叙述正确。</li>    <li>C. `sep` 或 `delimiter`：叙述正确。</li>    <li>D. `names` 和 `header`：叙述<b>错误</b>。这两个参数<b>可以一起使用</b>。当同时指定时，`names` 提供的列名会覆盖从 `header` 指定的行中推断出的列名。</li>  </ul><p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> io</span><br><span class="line"></span><br><span class="line">csv_content = <span class="string">&quot;&quot;&quot;a,b,c</span></span><br><span class="line"><span class="string">1,2,3</span></span><br><span class="line"><span class="string">4,5,6</span></span><br><span class="line"><span class="string">&quot;&quot;&quot;</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 示例: names 和 header 可以一起使用</span></span><br><span class="line"><span class="comment"># header=0 表示文件的第0行是旧的列名行（会被跳过）</span></span><br><span class="line"><span class="comment"># names=[...] 提供了新的列名</span></span><br><span class="line">df = pd.read_csv(io.StringIO(csv_content), names=[<span class="string">&#x27;col_A&#x27;</span>, <span class="string">&#x27;col_B&#x27;</span>, <span class="string">&#x27;col_C&#x27;</span>], header=<span class="number">0</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;names 和 header 同时使用的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>4. 以下对于csv文件<code>ex2.csv</code>的读取和操作，错误的是：（ ）</strong><br>A. <code>pd.read_csv(&#39;ex2.csv&#39;,header=None)</code>。<br>B. <code>pd.read_csv(&#39;ex2.csv&#39;,header=1)</code><br>C. <code>pd.read_csv(&#39;ex2.csv&#39;,names=[&#39;a&#39;, &#39;b&#39;, &#39;c&#39;, &#39;d&#39;, &#39;index&#39;], header = None)</code><br>D. <code>pd.read_csv(&#39;ex2.csv&#39;,names=[&#39;a&#39;, &#39;b&#39;, &#39;c&#39;, &#39;d&#39;, &#39;index&#39;], header = [0,1])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  假设 `ex2.csv` 是一个没有列头的文件。  <ul>    <li>A: `header=None` 是读取无列头文件的正确方式，Pandas 会自动生成整数列名。有效。</li>    <li>B: `header=1` 会将文件的第二行（索引为1）作为列头。有效。</li>    <li>C: `names=[...]` 和 `header=None` 结合，为无列头文件指定列名。有效。</li>    <li>D: `names=[...]` 和 `header=[0,1]` 存在冲突。`header=[0,1]` 告诉 Pandas 从文件的前两行创建多级列索引，而 `names` 提供的是一个单级（扁平）的列名列表。这两个指令不兼容，会导致 `ValueError`。</li>  </ul><p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> io</span><br><span class="line"></span><br><span class="line"><span class="comment"># 模拟 ex2.csv 内容</span></span><br><span class="line">csv_content = <span class="string">&quot;&quot;&quot;1,2,3,4,hello</span></span><br><span class="line"><span class="string">5,6,7,8,world</span></span><br><span class="line"><span class="string">9,10,11,12,foo</span></span><br><span class="line"><span class="string">&quot;&quot;&quot;</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 尝试执行选项D的操作，它会报错</span></span><br><span class="line"><span class="keyword">try</span>:</span><br><span class="line">  df_D = pd.read_csv(io.StringIO(csv_content), </span><br><span class="line">                       names=[<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>, <span class="string">&#x27;d&#x27;</span>, <span class="string">&#x27;index&#x27;</span>], </span><br><span class="line">                       header=[<span class="number">0</span>,<span class="number">1</span>])</span><br><span class="line"><span class="keyword">except</span> ValueError <span class="keyword">as</span> e:</span><br><span class="line">  <span class="built_in">print</span>(<span class="string">f&quot;执行选项 D 时发生错误: <span class="subst">&#123;e&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>5. 以下对<code>read_csv/read_table</code>函数参数叙述错误的是（ ）</strong><br>A. <code>skiprows</code>表示从文件开头处起，需要跳过的行数或者行号列表。<br>B. <code>na_values</code>指定需要用NA替换的值序列。<br>C. <code>sep</code>或<code>delimiter</code>指定用于分隔每行字段的字符序列或者正则表达式。<br>D. <code>names</code> 是结果的列名列表，它不可以和<code>header</code>参数一起用。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  此题与第 3 题完全相同。  <ul>    <li>A. `skiprows`：叙述正确。</li>    <li>B. `na_values`：叙述正确。</li>    <li>C. `sep` 或 `delimiter`：叙述正确。</li>    <li>D. `names` 和 `header`：叙述<b>错误</b>。这两个参数<b>可以一起使用</b>。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>6. 下面关于<code>read_csv/read_table</code>函数参数的说法，错误的是（ ）</strong><br>A. <code>skiprows=0</code>表明要跳过第一行<br>B. <code>na_values</code>是需要用NA替换的值序列<br>C. <code>chunksize</code>是用于迭代的块的大小<br>D. <code>encoding</code>是Unicode文本编码</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `skiprows=N` 表示跳过文件开头的 `N` 行。因此，`skiprows=0` 表示<b>不跳过任何行</b>。这个叙述是<b>错误</b>的。要跳过第一行，应使用 `skiprows=1` 或 `skiprows=[0]`。</li>    <li>B. `na_values`：叙述正确。</li>    <li>C. `chunksize`：叙述正确，用于分块读取大文件。</li>    <li>D. `encoding`：叙述正确，用于指定文件编码。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> io</span><br><span class="line"></span><br><span class="line">csv_content = <span class="string">&quot;&quot;&quot;col1,col2</span></span><br><span class="line"><span class="string">1,2</span></span><br><span class="line"><span class="string">3,4</span></span><br><span class="line"><span class="string">&quot;&quot;&quot;</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># skiprows=0 表示不跳过任何行</span></span><br><span class="line">df_skip0 = pd.read_csv(io.StringIO(csv_content), skiprows=<span class="number">0</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;skiprows=0 的结果 (未跳过):&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df_skip0)</span><br><span class="line"></span><br><span class="line"><span class="comment"># skiprows=1 表示跳过第一行</span></span><br><span class="line">df_skip1 = pd.read_csv(io.StringIO(csv_content), skiprows=<span class="number">1</span>, header=<span class="literal">None</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\nskiprows=1 的结果 (已跳过):&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df_skip1)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>7. 假设 <code>ex.csv</code> 文件为同目录下的 csv 文件，文件内容为：</strong><br><img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/6.png" alt="这里填写图片1的描述"><br><strong>下列哪一段语句可以得到以下的结果：（ ）</strong></p><p><img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/7.png" alt="这里填写图片1的描述"></p><p>A. <code>f = pd.read_csv(&#39;ex.csv&#39;, skiprows = [1, 3, 4], index_col = &#39;message&#39;)</code><br>B. <code>f = pd.read_csv(&#39;ex.csv&#39;, skiprows = [1, 3, 4], index = &#39;message&#39;)</code><br>C. <code>f = pd.read_csv(&#39;ex.csv&#39;, skiprows = [2, 4, 5], index_col = &#39;message&#39;)</code><br>D. <code>f = pd.read_csv(&#39;ex.csv&#39;, skiprows = [2, 4, 5], index = &#39;message&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  要从给定的 `ex.csv` 文件得到目标 DataFrame，需要进行以下操作：  <ol>    <li><b>处理列名</b>：文件的第一行 `a,b,c,d,message` 应该作为列名。这是 `pd.read_csv` 的默认行为 (`header=0`)。</li>    <li><b>跳过注释行</b>：文件中有三行注释（`#this is a line` 等）。我们需要跳过它们。这些行在文件中的行号（从0开始计数）分别是 <b>1, 3, 4</b>。因此，需要使用 `skiprows=[1, 3, 4]` 参数。</li>    <li><b>设置行索引</b>：目标 DataFrame 使用 `message` 列的值作为行索引。这需要使用 `index_col='message'` 参数。</li>  </ol>  现在我们分析选项：  <ul>    <li><b>A</b>: `skiprows=[1, 3, 4]` 正确地跳过了所有注释行，`index_col='message'` 正确地设置了索引。此选项正确。</li>    <li><b>B</b>: 使用了错误的参数名 `index`，应该是 `index_col`。</li>    <li><b>C</b>: `skiprows=[2, 4, 5]` 跳过了错误的的行，会导致数据丢失。</li>    <li><b>D</b>: `skiprows` 和 `index` 参数都错误。</li>  </ul>  另外，`read_csv` 函数有一个更简洁的方法来处理注释行，即使用 `comment='#'` 参数，它会自动忽略所有以 `#` 开头的行。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> io</span><br><span class="line"></span><br><span class="line"><span class="comment"># 模拟 ex.csv 文件内容</span></span><br><span class="line">csv_content = <span class="string">&quot;&quot;&quot;a,b,c,d,message</span></span><br><span class="line"><span class="string">#this is a line</span></span><br><span class="line"><span class="string">1,2,3,4,hello</span></span><br><span class="line"><span class="string">#this is another line</span></span><br><span class="line"><span class="string">#this is the third line</span></span><br><span class="line"><span class="string">5,6,7,8,world</span></span><br><span class="line"><span class="string">9,10,11,12,foo</span></span><br><span class="line"><span class="string">&quot;&quot;&quot;</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 使用选项 A 的代码</span></span><br><span class="line"><span class="comment"># skiprows=[1, 3, 4] 表示跳过文件的第2、4、5行（行号从0开始）</span></span><br><span class="line"><span class="comment"># index_col=&#x27;message&#x27; 表示使用 &#x27;message&#x27; 列作为行索引</span></span><br><span class="line">f = pd.read_csv(io.StringIO(csv_content), </span><br><span class="line">                skiprows=[<span class="number">1</span>, <span class="number">3</span>, <span class="number">4</span>], </span><br><span class="line">                index_col=<span class="string">&#x27;message&#x27;</span>)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;使用 skiprows 参数的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(f)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 更简洁的方法是使用 comment 参数</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n使用 comment 参数的等效结果:&quot;</span>)</span><br><span class="line">f_comment = pd.read_csv(io.StringIO(csv_content), </span><br><span class="line">                        comment=<span class="string">&#x27;#&#x27;</span>, </span><br><span class="line">                        index_col=<span class="string">&#x27;message&#x27;</span>)</span><br><span class="line"><span class="built_in">print</span>(f_comment)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>8. 如何使得下图名为 <code>data</code> 的 <code>DataFrame</code> 中的第二行第二个数字 <code>1</code> 变为空值。（ ）</strong></p><p><img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/8.png" alt="这里填写图片1的描述"></p><p>A. <code>data[1, &#39;b&#39;] = None</code><br>B. <code>data[1][&#39;b&#39;] = None</code><br>C. <code>data[&#39;b&#39;, 1] = None</code><br>D. <code>data[&#39;b&#39;][1] = None</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  目标是将 DataFrame `data` 中<b>行索引为 `1`</b>，<b>列标签为 `'b'`</b> 的元素（值为 `1`）变为空值。  <ul>    <li><b>A. `data[1, 'b'] = None`</b>：`df[row, col]` 这种语法不是 Pandas `[]` 运算符的标准用法，它更像是 NumPy 的索引方式。在 Pandas 中，这通常会尝试寻找一个名为 `(1, 'b')` 的列，从而导致 `KeyError`。正确的做法是使用 `.loc` 或 `.iloc`，例如 `data.loc[1, 'b'] = None`。</li>    <li><b>B. `data[1]['b'] = None`</b>：这是链式索引。第一步 `data[1]` 会尝试选择列标签为 `1` 的列，但该 DataFrame 的列标签是 `'a', 'b', 'c', 'd'`，所以会引发 `KeyError`。</li>    <li><b>C. `data['b', 1] = None`</b>：与 A 类似，这是无效的索引语法，会引发 `KeyError`。</li>    <li><b>D. `data['b'][1] = None`</b>：这是有效的链式索引。        <ul>            <li>第一步 `data['b']` 会正确地选择列名为 `'b'` 的那一列，返回一个 Series。</li>            <li>第二步 `[1]` 会对这个返回的 Series 按行索引 `1` 进行选择，定位到目标元素。</li>            <li>赋值操作会修改这个元素。因为 `data['b']` 通常是原 DataFrame 的一个视图（view），所以修改它会反映到原始的 `data` 对象上。</li>        </ul>    </li>  </ul><p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中所示的 DataFrame</span></span><br><span class="line">data = pd.DataFrame(&#123;</span><br><span class="line">    <span class="string">&#x27;a&#x27;</span>: [<span class="literal">None</span>, <span class="literal">None</span>, <span class="literal">None</span>],</span><br><span class="line">    <span class="string">&#x27;b&#x27;</span>: [<span class="string">&#x27;Num&#x27;</span>, <span class="number">1</span>, <span class="string">&#x27;a&#x27;</span>],</span><br><span class="line">    <span class="string">&#x27;c&#x27;</span>: [<span class="string">&#x27;Alpha&#x27;</span>, <span class="number">2</span>, <span class="string">&#x27;b&#x27;</span>],</span><br><span class="line">    <span class="string">&#x27;d&#x27;</span>: [<span class="string">&#x27;c&#x27;</span>, <span class="number">3</span>, <span class="string">&#x27;c&#x27;</span>]</span><br><span class="line">&#125;)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(data)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 使用副本进行测试，以免影响原始 data</span></span><br><span class="line">df_copy = data.copy()</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行选项 D 的操作</span></span><br><span class="line"><span class="comment"># np.nan 是 Pandas 中表示缺失值的标准方式</span></span><br><span class="line">df_copy[<span class="string">&#x27;b&#x27;</span>][<span class="number">1</span>] = np.nan </span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n选项 D 操作后的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df_copy)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>9. pandas中的<code>read_table</code>函数的默认分隔符为( )</strong><br>A. <code>\n</code><br>B. <code>\t</code><br>C. <code>\a</code><br>D. <code>\v</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `pd.read_table()` 是一个为读取制表符分隔文件（Tab-Separated Values, TSV）设计的便捷函数。它的默认分隔符是制表符，即 `\t`。  它在功能上等同于 `pd.read_csv(..., sep='\t')`。<p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> io</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建一个使用制表符分隔的字符串数据</span></span><br><span class="line">tsv_content = <span class="string">&quot;&quot;&quot;col1\tcol2</span></span><br><span class="line"><span class="string">1\thello</span></span><br><span class="line"><span class="string">2\tworld</span></span><br><span class="line"><span class="string">&quot;&quot;&quot;</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 使用 read_table 读取，它默认使用 \t 作为分隔符</span></span><br><span class="line">df = pd.read_table(io.StringIO(tsv_content))</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;使用 read_table 读取的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>10. 以下哪个函数参数可以用于跳过某些指定行打印输出？( )</strong><br>A. <code>skiprows</code><br>B. <code>delimiter</code><br>C. <code>nrows</code><br>D. <code>squeeze</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `skiprows`</b>：此参数专门用于在读取文件时跳过指定的行。可以是一个整数（跳过文件开头N行）或一个行号列表（跳过特定的行）。</li>    <li>B. `delimiter`：用于指定字段分隔符。</li>    <li>C. `nrows`：用于限制<b>读取的总行数</b>，而不是跳过。</li>    <li>D. `squeeze`：用于在可能的情况下将单列DataFrame压缩为Series。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> io</span><br><span class="line"></span><br><span class="line">csv_content = <span class="string">&quot;&quot;&quot;line 0</span></span><br><span class="line"><span class="string">line 1 (skip this)</span></span><br><span class="line"><span class="string">line 2</span></span><br><span class="line"><span class="string">line 3 (skip this)</span></span><br><span class="line"><span class="string">line 4</span></span><br><span class="line"><span class="string">&quot;&quot;&quot;</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 使用 skiprows 跳过指定的第1行和第3行 (索引从0开始)</span></span><br><span class="line">df = pd.read_csv(io.StringIO(csv_content), skiprows=[<span class="number">1</span>, <span class="number">3</span>], header=<span class="literal">None</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;使用 skiprows 跳过行 1 和 3 之后的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>11. 对于一些比较大的文件，我们想要一次读取一小部分，或者每次迭代一小部分。如果只是想要读取前5行（不读取整个文件），以下哪个选项是最佳选择：（ ）</strong><br>A. <code>pd.read_csv(&#39;../examples/ex6.csv&#39;, chunksize=5)</code><br>B. <code>pd.read_csv(&#39;../examples/ex6.csv&#39;, nrows=5)</code><br>C. <code>pd.read_csv(&#39;../examples/ex6.csv&#39;, rows=5)</code><br>D. <code>pd.read_csv(&#39;../examples/ex6.csv&#39;, size=5)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `chunksize=5`：返回一个迭代器，用于分块处理大文件，而不是直接返回前5行。</li>    <li><b>B. `nrows=5`</b>：此参数专门用于只读取文件的前 `N` 行，并直接返回一个包含这 `N` 行的 DataFrame。这是最高效、最直接的方法。</li>    <li>C. `rows=5`：`rows` 不是 `pd.read_csv()` 的有效参数。</li>    <li>D. `size=5`：`size` 不是 `pd.read_csv()` 的有效参数。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> io</span><br><span class="line"></span><br><span class="line"><span class="comment"># 模拟一个大文件</span></span><br><span class="line">csv_content = <span class="string">&quot;\n&quot;</span>.join([<span class="string">f&quot;<span class="subst">&#123;i&#125;</span>,<span class="subst">&#123;i*<span class="number">2</span>&#125;</span>&quot;</span> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">100</span>)])</span><br><span class="line"></span><br><span class="line"><span class="comment"># 使用 nrows=5 直接读取前5行数据</span></span><br><span class="line">df = pd.read_csv(io.StringIO(csv_content), nrows=<span class="number">5</span>, header=<span class="literal">None</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;使用 nrows=5 读取的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>12. 下列参数用于描述行终止符的是:( )</strong><br>A. <code>delimiter</code><br>B. <code>lineterminator</code><br>C. <code>quotechar</code><br>D. <code>quoting</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  这些参数常用于 Python 的 `csv` 模块，Pandas 在文件I/O中也支持它们。  <ul>    <li>A. `delimiter`：字段之间的分隔符，如逗号 `,`。</li>    <li><b>B. `lineterminator`</b>：<b>行终止符</b>，即用来分隔行的字符序列，默认为 `\r\n` 或 `\n`。</li>    <li>C. `quotechar`：用于包围特殊字段的引用字符，如双引号 `"`。</li>    <li>D. `quoting`：控制引用行为的常量。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>13. 有以下文件 <code>ex5.csv</code>，读取后 <code>data</code> 的内容如下图所示：</strong></p><p><img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/9.png" alt="这里填写图片1的描述"></p><p><strong>执行代码：</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> sys</span><br><span class="line">data.to_csv(sys.stdout, index=<span class="literal">False</span>, header=<span class="literal">False</span>, columns=[<span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>, <span class="string">&#x27;a&#x27;</span>])</span><br></pre></td></tr></table></figure><p><strong>控制台的打印的文本结果为：（ ）</strong></p><div style="display: flex; justify-content: space-around; font-family: monospace; white-space: pre;">  <div><b>A.</b><br>1,2,3.0<br>5,6,<br>9,10,11.0</div>  <div><b>B.</b><br>2,1,3.0<br>6,5,<br>10,9,11.0</div>  <div><b>C.</b><br>3.0,2,1<br>,6,5<br>11.0,10,9</div>  <div><b>D.</b><br>2,3.0,1<br>6,,5<br>10,11.0,9</div></div><br><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `data.to_csv(...)` 方法用于将 DataFrame 写入 CSV 格式。我们来分析各个参数：  <ul>    <li><b>`sys.stdout`</b>：表示将输出直接打印到控制台，而不是写入文件。</li>    <li><b>`index=False`</b>：表示不写入 DataFrame 的行索引（即 `0, 1, 2`）。</li>    <li><b>`header=False`</b>：表示不写入 DataFrame 的列名。</li>    <li><b>`columns=['b', 'c', 'a']`</b>：指定<b>只写入 'b', 'c', 'a' 这三列</b>，并且<b>按照这个顺序</b>排列。</li>  </ul>  根据这些参数，程序会按行处理，并按 `b, c, a` 的顺序输出值：  <ul>    <li><b>第0行</b>: `b`是`2`, `c`是`3.0`, `a`是`1`。输出：`2,3.0,1`</li>    <li><b>第1行</b>: `b`是`6`, `c`是`NaN` (输出为空字符串), `a`是`5`。输出：`6,,5`</li>    <li><b>第2行</b>: `b`是`10`, `c`是`11.0`, `a`是`9`。输出：`10,11.0,9`</li>  </ul>  将这些行组合起来，得到的结果与选项 D 完全匹配。<p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"><span class="keyword">import</span> sys</span><br><span class="line"></span><br><span class="line"><span class="comment"># 模拟题目中的 DataFrame</span></span><br><span class="line">data = pd.DataFrame(&#123;</span><br><span class="line">    <span class="string">&#x27;something&#x27;</span>: [<span class="string">&#x27;one&#x27;</span>, <span class="string">&#x27;two&#x27;</span>, <span class="string">&#x27;three&#x27;</span>],</span><br><span class="line">    <span class="string">&#x27;a&#x27;</span>: [<span class="number">1</span>, <span class="number">5</span>, <span class="number">9</span>],</span><br><span class="line">    <span class="string">&#x27;b&#x27;</span>: [<span class="number">2</span>, <span class="number">6</span>, <span class="number">10</span>],</span><br><span class="line">    <span class="string">&#x27;c&#x27;</span>: [<span class="number">3.0</span>, np.nan, <span class="number">11.0</span>],</span><br><span class="line">    <span class="string">&#x27;d&#x27;</span>: [<span class="number">4</span>, <span class="number">8</span>, <span class="number">12</span>],</span><br><span class="line">    <span class="string">&#x27;message&#x27;</span>: [np.nan, <span class="string">&#x27;world&#x27;</span>, <span class="string">&#x27;foo&#x27;</span>]</span><br><span class="line">&#125;)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(data)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行题目中的 to_csv 操作</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n控制台打印结果:&quot;</span>)</span><br><span class="line">data.to_csv(sys.stdout, index=<span class="literal">False</span>, header=<span class="literal">False</span>, columns=[<span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>, <span class="string">&#x27;a&#x27;</span>])</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>14. 读入文件’File.csv’。自定义列名为’a’,’b’,’c’.( )</strong><br>A. <code>pd.read_csv(&#39;File.csv&#39;,&#39;a&#39;,&#39;b&#39;,&#39;c&#39;)</code><br>B. <code>pd.read_csv(&#39;File.csv&#39;,names=[&#39;a&#39;,&#39;b&#39;,&#39;c&#39;])</code><br>C. <code>pd.read_csv(&#39;File.csv&#39;,column=[&#39;a&#39;,&#39;b&#39;,&#39;c&#39;])</code><br>D. <code>pd.read_csv(&#39;File.csv&#39;,[&#39;a&#39;,&#39;b&#39;,&#39;c&#39;])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  在 `pd.read_csv()` 函数中，用于为结果 DataFrame 自定义列名的正确参数是 `names`。  <ul>    <li>A, D: 将列名作为位置参数传入是错误的语法。</li>    <li>B: `names=['a','b','c']` 是正确的关键字参数用法。</li>    <li>C: `column` 不是 `pd.read_csv()` 的有效参数（应为 `names`）。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> io</span><br><span class="line"></span><br><span class="line"><span class="comment"># 模拟一个没有列头的CSV文件</span></span><br><span class="line">csv_content = <span class="string">&quot;1,2,3\n4,5,6&quot;</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 使用 names 参数自定义列名</span></span><br><span class="line">df = pd.read_csv(io.StringIO(csv_content), names=[<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;使用 names 参数自定义列名的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>15. 以下使用pandas读取csv文件的操作，会报错的是（ ）</strong><br>A. <code>pd.read_csv(&#39;../examples/ex1.csv&#39;,header=None)</code><br>B. <code>pd.read_csv(&#39;../examples/ex1.csv&#39;,names=None)</code><br>C. <code>pd.read_csv(&#39;../examples/ex1.csv&#39;,header=[&#39;a&#39;,&#39;b&#39;,&#39;c&#39;,&#39;d&#39;,&#39;e&#39;])</code><br>D. <code>pd.read_csv(&#39;../examples/ex1.csv&#39;,names=[&#39;a&#39;,&#39;b&#39;,&#39;c&#39;,&#39;d&#39;,&#39;e&#39;])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `header=None`：有效。将文件第一行也作为数据读取，并使用默认整数列名。</li>    <li>B. `names=None`：有效。这是默认行为，会尝试从文件第一行推断列名。</li>    <li><b>C. `header=[...]`</b>：<b>错误</b>。`header` 参数期望的是一个<b>整数</b>或<b>整数列表</b>（指定作为列名的行号），而不是一个字符串列表。传入字符串列表会引发 `TypeError`。</li>    <li>D. `names=[...]`：有效。使用提供的列表作为列名。</li>  </ul><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> io</span><br><span class="line"></span><br><span class="line">csv_content = <span class="string">&quot;a,b,c\n1,2,3&quot;</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 尝试执行选项C的操作，它会报错</span></span><br><span class="line"><span class="keyword">try</span>:</span><br><span class="line">  df = pd.read_csv(io.StringIO(csv_content), header=[<span class="string">&#x27;x&#x27;</span>, <span class="string">&#x27;y&#x27;</span>, <span class="string">&#x27;z&#x27;</span>])</span><br><span class="line"><span class="keyword">except</span> TypeError <span class="keyword">as</span> e:</span><br><span class="line">  <span class="built_in">print</span>(<span class="string">f&quot;执行选项 C 时发生错误: <span class="subst">&#123;e&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>16. 以下对于csv文件<code>examples/ex2.csv</code>的读取和操作，错误的是：（ ）</strong><br>A. <code>pd.read_csv(r&#39;examples/ex2.csv&#39;,header=None)</code>。<br>B. <code>pd.read_csv(r&#39;examples/ex2.csv&#39;,header=1)</code><br>C. <code>pd.read_csv(r&#39;examples/ex2.csv&#39;,names=[&#39;a&#39;, &#39;b&#39;, &#39;c&#39;, &#39;d&#39;, &#39;index&#39;], header = None)</code><br>D. <code>pd.read_csv(r&#39;examples/ex2.csv&#39;,names=[&#39;a&#39;, &#39;b&#39;, &#39;c&#39;, &#39;d&#39;, &#39;index&#39;], header = [0,1])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  此题与第 4 题完全相同。  `names=[...]` 和 `header=[0,1]` 存在冲突。`header=[0,1]` 告诉 Pandas 从文件的前两行创建多级列索引，而 `names` 提供的是一个单级（扁平）的列名列表。这两个指令不兼容，会导致 `ValueError`。<p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>17. 以下函数中，可以从txt文件中读取数据的是（ ）</strong><br>A. <code>read_csv</code><br>B. <code>read_sql</code><br>C. <code>read_html</code><br>D. <code>read_excel</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `read_csv()`</b>：虽然名称是 "csv"，但它是一个通用的文本文件读取函数。通过指定 `sep` (分隔符) 参数，它可以读取任何类型的分隔符文件，包括常见的 `.txt` 文件（如制表符分隔、空格分隔等）。</li>    <li>B. `read_sql()`：用于从 SQL 数据库读取。</li>    <li>C. `read_html()`：用于从 HTML 文件或 URL 中读取表格。</li>    <li>D. `read_excel()`：用于读取 Excel 文件。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> io</span><br><span class="line"></span><br><span class="line"><span class="comment"># 模拟一个以制表符分隔的 .txt 文件内容</span></span><br><span class="line">txt_content = <span class="string">&quot;name\tscore\nAlice\t95\nBob\t88&quot;</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 使用 read_csv 读取 .txt 文件，并指定分隔符为制表符 `\t`</span></span><br><span class="line">df = pd.read_csv(io.StringIO(txt_content), sep=<span class="string">&#x27;\t&#x27;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;使用 read_csv 读取 .txt 文件的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df)</span><br></pre></td></tr></table></figure></p></details><h2 id="第七章：数据清洗与转换"><a href="#第七章：数据清洗与转换" class="headerlink" title="第七章：数据清洗与转换"></a>第七章：数据清洗与转换</h2><p><strong>1. 在<code>replace()</code>方法的使用中，下列不正确的是（ ）</strong><br>A. <code>replace(-2, 999)</code><br>B. <code>replace([-1, -2], np.nan)</code><br>C. <code>replace([-2, -4], [np.nan, 999])</code><br>D. <code>replace(np.nan, [-1, -2])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  Pandas 的 `.replace()` 方法用于替换值，其用法有多种。  <ul>    <li>A: `replace(to_replace, value)` - 将单个值 `-2` 替换为单个值 `999`。有效。</li>    <li>B: `replace([list], value)` - 将列表 `[-1, -2]` 中的所有值都替换为单个值 `np.nan`。有效。</li>    <li>C: `replace([list1], [list2])` - 将列表1中的值按位置对应替换为列表2中的值，要求两个列表等长。有效。</li>    <li>D: `replace(value, [list])` - <b>无效</b>。`.replace()` 方法不支持用一个具体的值去替换为一个值列表。`to_replace` 是单个值时，`value` 也必须是单个值。</li>  </ul><p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">s = pd.Series([<span class="number">1</span>, -<span class="number">1</span>, <span class="number">2</span>, -<span class="number">2</span>, <span class="number">3</span>, -<span class="number">4</span>, np.nan])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 Series:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(s)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 尝试执行选项 D 的操作，它会报错</span></span><br><span class="line"><span class="keyword">try</span>:</span><br><span class="line">  s.replace(np.nan, [-<span class="number">1</span>, -<span class="number">2</span>])</span><br><span class="line"><span class="keyword">except</span> Exception <span class="keyword">as</span> e:</span><br><span class="line">  <span class="built_in">print</span>(<span class="string">f&quot;\n执行选项 D 时发生错误: <span class="subst">&#123;e&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>2. DataFrame的（ ）方法返回一个布尔值的Series,这个Series反应的是每一行是否存在重复。</strong><br>A. <code>duplicated</code><br>B. <code>fillna</code><br>C. <code>replace</code><br>D. <code>drop_duplicates</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `duplicated()`</b>：此方法专门用于识别重复项。它会返回一个布尔值的 Series，`True` 表示该行是重复的（即与之前出现过的某行完全相同），`False` 表示不是。</li>    <li>B. `fillna()`：用于填充缺失值。</li>    <li>C. `replace()`：用于替换指定的值。</li>    <li>D. `drop_duplicates()`：用于<b>删除</b>重复行，返回的是一个清理后的 DataFrame，而不是布尔 Series。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;col1&#x27;</span>: [<span class="string">&#x27;A&#x27;</span>, <span class="string">&#x27;B&#x27;</span>, <span class="string">&#x27;A&#x27;</span>, <span class="string">&#x27;C&#x27;</span>], <span class="string">&#x27;col2&#x27;</span>: [<span class="number">1</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">3</span>]&#125;)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df)</span><br><span class="line"></span><br><span class="line"><span class="comment"># duplicated() 返回一个布尔 Series</span></span><br><span class="line">is_duplicate = df.duplicated()</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\ndf.duplicated() 的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(is_duplicate)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>3. 已知代码<code>import numpy as np;import pandas as pd; string_data = pd.Series([&#39;aardvark&#39;,1, np.nan, &#39;avocado&#39;])</code>，下列将<code>string_data</code>中的值1替换为NaN的操作正确的是：（ ）</strong><br>A. <code>string_data[1] = None</code><br>B. <code>string_data[1] = np.nan</code><br>C. <code>string_data[1] = NA</code><br>D. <code>string_data[1] = nan</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  目标是将 Series 中索引为 1 的元素（值为整数 `1`）替换为缺失值。  <ul>    <li>A. `string_data[1] = None`：在 Pandas 中，将 `None` 赋值给一个元素是表示缺失的有效方式，Pandas 内部通常会将其处理为 `np.nan`。有效。</li>    <li>B. `string_data[1] = np.nan`：`np.nan` 是 Pandas 和 NumPy 中表示缺失值的标准方式。这是最直接、最明确的做法。有效。</li>    <li>C. `string_data[1] = NA`：`NA` 在标准的 Python 或 NumPy 环境中未定义，会引发 `NameError`。无效。</li>    <li>D. `string_data[1] = nan`：与 `NA` 类似，`nan` 也未定义，会引发 `NameError`。无效。</li>  </ul>  选项 A 和 B 都能实现目标，但 B (`np.nan`) 是在数据分析领域表示缺失值更通用和标准的方式。<p>  <strong>正确答案：</strong> B (或 A，但 B 更标准)</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line">string_data = pd.Series([<span class="string">&#x27;aardvark&#x27;</span>, <span class="number">1</span>, np.nan, <span class="string">&#x27;avocado&#x27;</span>])</span><br><span class="line">s_copy = string_data.copy()</span><br><span class="line"></span><br><span class="line"><span class="comment"># 使用 np.nan 进行替换</span></span><br><span class="line">s_copy[<span class="number">1</span>] = np.nan</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;使用 np.nan 替换后的 Series:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(s_copy)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>4. 以下返回的是<code>data</code>的视图的是（ ）</strong><br>A. <code>data.dropna()</code><br>B. <code>data[data.notnull()]</code><br>C. <code>data.iloc[[0,2,4]]</code><br>D. <code>data[1:3]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  在 Pandas 中，返回<b>视图 (view)</b> 还是<b>副本 (copy)</b> 是一个重要的概念。视图是原始数据的“窗口”，修改视图会影响原始数据。副本是全新的数据，修改副本不影响原始数据。  <ul>    <li>A. `data.dropna()`：删除行/列的操作需要创建新的数据结构，返回的是副本。</li>    <li>B. `data[data.notnull()]`：布尔索引，需要根据条件筛选并可能重组数据，返回的是副本。</li>    <li>C. `data.iloc[[0,2,4]]`：花式索引（使用列表进行索引），返回的是副本。</li>    <li>D. `data[1:3]`：<b>基础切片 (slicing)</b> 操作通常返回的是原始数据的<b>视图</b>。</li>  </ul><p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">data = pd.DataFrame(&#123;<span class="string">&#x27;col&#x27;</span>: <span class="built_in">range</span>(<span class="number">5</span>)&#125;)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 获取切片（视图）</span></span><br><span class="line">data_slice = data[<span class="number">1</span>:<span class="number">3</span>]</span><br><span class="line"></span><br><span class="line"><span class="comment"># 修改视图</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;修改前，原始 data 的第1行:&quot;</span>, data.iloc[<span class="number">1</span>][<span class="string">&#x27;col&#x27;</span>])</span><br><span class="line">data_slice.iloc[<span class="number">0</span>, <span class="number">0</span>] = <span class="number">999</span> <span class="comment"># 修改视图的第一个元素</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 观察原始 data 是否被修改</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;修改后，原始 data 的第1行:&quot;</span>, data.iloc[<span class="number">1</span>][<span class="string">&#x27;col&#x27;</span>])</span><br><span class="line"><span class="comment"># 输出 999，证明 data_slice 是一个视图</span></span><br></pre></td></tr></table></figure></p></details><hr><p><strong>5. <code>data=pd.DataFrame([[2,2,2,NA],[1.,NA,NA,NA],[NA,NA,NA,NA],[NA,1,1,NA]])</code>，下列哪个方法能删掉值全为NA的列？（ ）</strong><br>A. <code>data.dropna()</code><br>B. <code>data.dropna(how=&#39;all&#39;)</code><br>C. <code>data.dropna(axis=1,how=&#39;all&#39;)</code><br>D. <code>data.dropna(axis=1,how=&#39;any&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  （假设 `NA` 指的是 `np.nan`）  `.dropna()` 方法用于删除含有缺失值的行或列。  <ul>    <li>要删除<b>列</b>，需要设置参数 `axis=1`。</li>    <li>要删除<b>所有值都为 `NaN`</b> 的列，需要设置参数 `how='all'`。</li>  </ul>  分析选项：  <ul>    <li>A: 默认删除<b>任何</b>有 `NaN` 的<b>行</b>。</li>    <li>B: 默认删除<b>所有值都为 `NaN`</b> 的<b>行</b>。</li>    <li>C: `axis=1` 表示对列操作，`how='all'` 表示删除所有值都为 `NaN` 的列。这完全符合题目要求。</li>    <li>D: `axis=1` 表示对列操作，`how='any'` 表示删除任何有 `NaN` 的列。</li>  </ul><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">data = pd.DataFrame([</span><br><span class="line">    [<span class="number">2</span>, <span class="number">2</span>, <span class="number">2</span>, np.nan],</span><br><span class="line">    [<span class="number">1.</span>, np.nan, np.nan, np.nan],</span><br><span class="line">    [np.nan, np.nan, np.nan, np.nan],</span><br><span class="line">    [np.nan, <span class="number">1</span>, <span class="number">1</span>, np.nan]</span><br><span class="line">])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(data)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 删除所有值都为 NaN 的列</span></span><br><span class="line">result = data.dropna(axis=<span class="number">1</span>, how=<span class="string">&#x27;all&#x27;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n删除全为 NaN 的列之后:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>6. <code>data = pd.Series([1., np.nan, 2., np.nan, -1000., 3.])</code>，以下对于<code>data</code>的操作，输出结果相同的是：（ ）</strong><br>① <code>data.replace(np.nan, 0)</code> ② <code>data.fillna(0)</code> ③ <code>data.replace([np.nan, -1000], [0, -1000])</code> ④ <code>data.replace(&#123;np.nan: 0&#125;)</code><br>A. ①<br>B. ①②<br>C. ①②③<br>D. ①②③④</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  我们来逐一分析每个操作，看它们是否都将 `np.nan` 替换为 `0`，且不改变其他值。  <ul>    <li>① `data.replace(np.nan, 0)`：将所有 `np.nan` 替换为 `0`。</li>    <li>② `data.fillna(0)`：`fillna` 是专门用于填充 `NaN` 的方法，用 `0` 填充。</li>    <li>③ `data.replace([np.nan, -1000], [0, -1000])`：将 `np.nan` 替换为 `0`，并将 `-1000` 替换为 `-1000`（即-1000保持不变）。</li>    <li>④ `data.replace({np.nan: 0})`：使用字典进行替换，将键 `np.nan` 替换为值 `0`。</li>  </ul>  所有这四个操作最终都会得到相同的结果：`[1., 0., 2., 0., -1000., 3.]`。<p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>7. 对于<code>data = pd.Series([1., NA, 5., NA, 6.])</code>，使用<code>fillna(data.mean())</code>之后，原来NA处的代码处应该填入什么数字？（ ）</strong><br>A. 5., 6.<br>B. 1., 5.<br>C. 4., 4.<br>D. 2.4, 2.4</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  （假设 `NA` 指的是 `np.nan`）  <ol>    <li><b>计算平均值</b>：`data.mean()` 会忽略 `NaN` 值，计算其余值的平均数。        <br>`(1.0 + 5.0 + 6.0) / 3 = 12.0 / 3 = 4.0`。</li>    <li><b>填充缺失值</b>：`data.fillna(4.0)` 会将 Series 中所有的 `NaN` 值替换为 `4.0`。</li>  </ol>  因此，原来是 `NaN` 的位置都会被填入 `4.0`。<p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">data = pd.Series([<span class="number">1.</span>, np.nan, <span class="number">5.</span>, np.nan, <span class="number">6.</span>])</span><br><span class="line"></span><br><span class="line"><span class="comment"># 计算平均值并填充</span></span><br><span class="line">filled_data = data.fillna(data.mean())</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;填充后的 Series:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(filled_data)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>8. 假设字符串<code>val = &#39;a,b,guido&#39;</code>，下列叙述错误的是：（ ）</strong><br>A. <code>val.index(&#39;,&#39;)</code>返回1，<code>val.find(&#39;,&#39;)</code>返回1.<br>B. <code>&#39;|&#39;.join(val)</code>输出结果为 <code>&#39;a|b|guido&#39;</code>。<br>C. <code>val.count(&#39;,&#39;)</code>返回2.<br>D. <code>val.rfind(&#39;,&#39;)</code>返回3.</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: `index(',')` 和 `find(',')` 都返回子字符串第一次出现的索引。第一个 `,` 在索引 `1` 处。正确。</li>    <li>B: `str.join(iterable)` 会将可迭代对象中的<b>每个元素</b>用 `str` 连接。当对字符串 `val` 使用时，它会遍历 `val` 的<b>每个字符</b>。结果是 `'a|,|,|b|,|,|g|u|i|d|o'`。因此，该叙述<b>错误</b>。</li>    <li>C: `count(',')` 计算 `,` 出现的次数，结果是 `2`。正确。</li>    <li>D: `rfind(',')` 返回子字符串最后一次出现的索引。第二个 `,` 在索引 `3` 处。正确。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>9. 对于pandas中的分箱操作，下列说法错误的是（ ）</strong><br>A. <code>pd.value_counts()</code>函数是输出分箱结果中每个区间所对应的计数<br>B. 可以通过向labels选项传递一个列表或数组来传入自定义的箱名<br>C. <code>qcut</code>是基于样本分位数进行分箱的函数<br>D. <code>qcut</code>函数可以传入整数代替显式的箱边来获取等长的箱，而<code>cut</code>函数却不能</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确。`pd.cut` 或 `pd.qcut` 返回一个 Categorical 对象，对其使用 `pd.value_counts()` 可以统计每个箱子的数量。</li>    <li>B: 正确。`labels` 参数用于为生成的箱子命名。</li>    <li>C: 正确。`qcut` 是 "quantile-based cut"，即基于分位数的分箱，它会尝试使每个箱子包含相同数量的数据点（等频）。</li>    <li>D: <b>错误</b>。`qcut` 可以传入整数 `k` 来创建 `k` 个等频的箱子。<b>`cut` 也可以传入整数 `k`</b>，它会根据数据的最大值和最小值将数据范围等分成 `k` 个<b>等宽</b>的箱子。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>10. 以下哪个数据清洗方法能将数据按照元素进行转换（ ）</strong><br>A. <code>duplicated</code><br>B. <code>map</code><br>C. <code>fillna</code><br>D. <code>dropna</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `duplicated()`：用于识别重复项，返回布尔值。</li>    <li><b>B. `map()`</b>：Series 的 `.map()` 方法可以接受一个函数或一个字典，并对 Series 中的<b>每个元素</b>应用这个映射关系，从而实现元素级的转换。</li>    <li>C. `fillna()`：仅用于填充缺失值。</li>    <li>D. `dropna()`：用于删除含有缺失值的行或列。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line">s = pd.Series([<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">1</span>])</span><br><span class="line"></span><br><span class="line"><span class="comment"># 使用字典进行映射转换</span></span><br><span class="line">mapping_dict = &#123;<span class="number">1</span>: <span class="string">&#x27;Good&#x27;</span>, <span class="number">2</span>: <span class="string">&#x27;Medium&#x27;</span>, <span class="number">3</span>: <span class="string">&#x27;Excellent&#x27;</span>&#125;</span><br><span class="line">s_mapped = s.<span class="built_in">map</span>(mapping_dict)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;使用 map() 进行元素转换后的 Series:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(s_mapped)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>11. 怎么查看一份数据中某一列的数据格式？（例如<code>df[&quot;年份&quot;]</code>）（ ）</strong><br>A. <code>df[&quot;年份&quot;].dtype()</code><br>B. <code>df[&quot;年份&quot;].astype()</code><br>C. <code>df[&quot;年份&quot;].values</code><br>D. 以上都不对</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `df["年份"].dtype()`：错误。`.dtype` 是一个<b>属性</b>，不是方法，所以后面不应加括号 `()`。</li>    <li>B. `df["年份"].astype()`：错误。`.astype()` 是一个<b>方法</b>，用于<b>转换</b>数据类型，而不是查看。</li>    <li>C. `df["年份"].values`：错误。`.values` 是一个属性，返回该列数据的 NumPy 数组表示，而不是数据类型。</li>  </ul>  正确的查看方式是使用属性 `df["年份"].dtype`。由于所有给出的选项都是错误的，所以 D 是正确答案。<p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;年份&#x27;</span>: [<span class="number">2020</span>, <span class="number">2021</span>]&#125;)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 正确的查看方式</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;正确的方式:&quot;</span>, df[<span class="string">&quot;年份&quot;</span>].dtype)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 尝试选项A会报错</span></span><br><span class="line"><span class="keyword">try</span>:</span><br><span class="line">  df[<span class="string">&quot;年份&quot;</span>].dtype()</span><br><span class="line"><span class="keyword">except</span> TypeError <span class="keyword">as</span> e:</span><br><span class="line">  <span class="built_in">print</span>(<span class="string">f&quot;\n选项A的错误: <span class="subst">&#123;e&#125;</span>&quot;</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>12. 对于一些Python内建字符串的方法，以下说法错误的是（ ）</strong><br>A. <code>split</code>方法可以将字符串按照传入的子字符进行拆分<br>B. <code>find</code>方法用于检测子字符串<br>C. <code>count</code>方法用于返回某个特定子字符串在字符串中出现的次数<br>D. <code>index</code>方法在字符串中没有找到时返回-1</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: `split()` 拆分字符串。正确。</li>    <li>B: `find()` 查找子字符串并返回索引。正确。</li>    <li>C: `count()` 统计子字符串出现次数。正确。</li>    <li>D: <b>错误</b>。如果 `index()` 方法在字符串中没有找到子字符串，它会<b>引发 `ValueError` 异常</b>。返回 `-1` 的是 `find()` 方法。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>13. 下列代码的输出是（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">data = pd.DataFrame(&#123;<span class="string">&#x27;one&#x27;</span>: [<span class="number">3</span>, <span class="number">4</span>] * <span class="number">2</span> + [<span class="number">4</span>],</span><br><span class="line">                     <span class="string">&#x27;two&#x27;</span>: [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>]&#125;)</span><br><span class="line"><span class="built_in">print</span>(data)</span><br></pre></td></tr></table></figure><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">   one  two</span><br><span class="line">0    3    1</span><br><span class="line">1    4    2</span><br><span class="line">2    3    3</span><br><span class="line">3    4    4</span><br><span class="line">4    4    5</span><br></pre></td></tr></table></figure><p>B.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">   one  two</span><br><span class="line">0    3    1</span><br><span class="line">1    4    2</span><br><span class="line">2    3    3</span><br><span class="line">3    4    4</span><br></pre></td></tr></table></figure><p>C.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">0    3    1</span><br><span class="line">1    4    2</span><br><span class="line">2    3    3</span><br><span class="line">3    4    4</span><br><span class="line">4    4    5</span><br></pre></td></tr></table></figure><p>D.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">0    3    1</span><br><span class="line">1    4    2</span><br><span class="line">2    3    3</span><br><span class="line">3    4    4</span><br></pre></td></tr></table></figure><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li>分析 `one` 列的数据：Python 列表操作 `[3, 4] * 2` 得到 `[3, 4, 3, 4]`，再与 `[4]` 拼接得到 `[3, 4, 3, 4, 4]`。该列共有5个元素。</li>    <li>分析 `two` 列的数据：`[1, 2, 3, 4, 5]`。该列也有5个元素。</li>    <li>`pd.DataFrame({...})` 会根据字典创建 DataFrame。字典的键 `'one'` 和 `'two'` 会成为列名，Pandas 会自动生成一个从 0 开始的默认行索引。</li>    <li>`print(data)` 会将包含列名和行索引的完整 DataFrame 打印出来。</li>  </ol>  选项 A 的输出格式和内容完全匹配。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行题目中的代码</span></span><br><span class="line">data = pd.DataFrame(&#123;<span class="string">&#x27;one&#x27;</span>: [<span class="number">3</span>, <span class="number">4</span>] * <span class="number">2</span> + [<span class="number">4</span>],</span><br><span class="line">                     <span class="string">&#x27;two&#x27;</span>: [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>]&#125;)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 打印 DataFrame，结果会包含列名和行索引</span></span><br><span class="line"><span class="built_in">print</span>(data)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>14. 下列代码代表什么意思？（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">data = pd.DataFrame(&#123;<span class="string">&#x27;k1&#x27;</span>: [<span class="string">&#x27;one&#x27;</span>, <span class="string">&#x27;two&#x27;</span>] * <span class="number">3</span> + [<span class="string">&#x27;two&#x27;</span>],</span><br><span class="line">                     <span class="string">&#x27;k2&#x27;</span>: [<span class="number">1</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">4</span>]&#125;)</span><br><span class="line"><span class="built_in">print</span>(data[data.duplicated(keep=<span class="string">&#x27;last&#x27;</span>)])</span><br></pre></td></tr></table></figure><p>A. 将data中的值筛选一遍，将没有重复的值输出<br>B. 将data中第一个重复的值输出<br>C. 将data中最后一个筛选的值输出<br>D. 将data中除了最后一个重复的值之外的重复值进行输出</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`data.duplicated(keep='last')`</b>：`.duplicated()` 方法用于识别重复行。参数 `keep='last'` 表示对于一组重复的行，它会将<b>最后一次出现</b>的行标记为 `False`（非重复），而将<b>之前所有出现</b>的行都标记为 `True`（重复）。</li>    <li><b>`data[...]`</b>：使用上面生成的布尔 Series 进行索引，会筛选出所有被标记为 `True` 的行。</li>  </ul>  因此，这段代码的含义是：筛选并输出那些是重复的、但又不是该重复项最后一次出现的行。这与选项 D 的描述“将data中除了最后一个重复的值之外的重复值进行输出”完全一致。<p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>15. <code>string_data = pd.Series([&#39;aardvark&#39;, &#39;artichoke&#39;, np.nan, &#39;avocado&#39;])</code>，<code>string_data.notnull()</code>的结果是（ ）</strong><br>A. <code>0 aardvark 1 artichoke ...</code><br>B. <code>0 aardvark 1 artichoke 2 avocado</code><br>C. <code>0 True 1 True 2 False 3 True</code><br>D. <code>0 True 1 True 2 True</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `.notnull()` 方法返回一个布尔值的 Series，用于指示原 Series 中的每个元素是否<b>不是</b>缺失值。  <ul>    <li>`'aardvark'` 不是缺失值 -> `True`</li>    <li>`'artichoke'` 不是缺失值 -> `True`</li>    <li>`np.nan` 是缺失值 -> `False`</li>    <li>`'avocado'` 不是缺失值 -> `True`</li>  </ul>  所以结果是一个 `[True, True, False, True]` 的布尔 Series，并带有相应的索引。<p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">string_data = pd.Series([<span class="string">&#x27;aardvark&#x27;</span>, <span class="string">&#x27;artichoke&#x27;</span>, np.nan, <span class="string">&#x27;avocado&#x27;</span>])</span><br><span class="line"><span class="built_in">print</span>(string_data.notnull())</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>16. 代码<code>data=pd.DataFrame(&#123;&#39;k1&#39;:[&#39;one&#39;,&#39;two&#39;]*2+[&#39;two&#39;], &#39;k2&#39;:[1,2,3,3,3]&#125;)</code>，<code>data.drop_duplicates()</code>的输出为（ ）</strong></p><p>A. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/10.png" alt="这里填写图片1的描述"><br>B. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/11.png" alt="这里填写图片1的描述"><br>C. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/12.png" alt="这里填写图片1的描述"><br>D. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/13.png" alt="这里填写图片1的描述"></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>创建 DataFrame</b>：首先，我们分析 `data` 的内容。        <ul>            <li>`'k1'` 列为 `['one', 'two', 'one', 'two', 'two']`。</li>            <li>`'k2'` 列为 `[1, 2, 3, 3, 3]`。</li>            <li>组合后的 `data` 如下：<pre>   k1  k20  one   11  two   22  one   33  two   3  &lt;-- 重复行第一次出现4  two   3  &lt;-- 重复行第二次出现</pre></li>        </ul>    </li>    <li><b>执行 `drop_duplicates()`</b>：该方法用于删除重复的行。        <ul>            <li>默认参数 `keep='first'` 表示对于一组重复的行，会<b>保留第一次出现</b>的行，并删除所有后续的重复行。</li>            <li>在此例中，行 `('two', 3)` 在索引 `3` 和 `4` 处重复。`drop_duplicates()` 会保留索引为 `3` 的行，并删除索引为 `4` 的行。</li>        </ul>    </li>    <li><b>最终结果</b>：操作后的 DataFrame 会包含索引为 `0, 1, 2, 3` 的行，这与图片 A 的内容完全一致。</li>  </ol><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 DataFrame</span></span><br><span class="line">data = pd.DataFrame(&#123;<span class="string">&#x27;k1&#x27;</span>:[<span class="string">&#x27;one&#x27;</span>,<span class="string">&#x27;two&#x27;</span>]*<span class="number">2</span>+[<span class="string">&#x27;two&#x27;</span>], </span><br><span class="line">                     <span class="string">&#x27;k2&#x27;</span>:[<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>,<span class="number">3</span>,<span class="number">3</span>]&#125;)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(data)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行去重操作</span></span><br><span class="line">result = data.drop_duplicates()</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n执行 drop_duplicates() 之后的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>17. 已知<code>df=pd.DataFrame([[1,None,None],[4,None,6],[7,8,9]])</code>，执行<code>df.dropna(thresh=2)</code>得到的结果是（ ）</strong></p><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">   0    1    2</span><br><span class="line">0  1.0  NaN  NaN</span><br><span class="line">1  4.0  NaN  6.0</span><br><span class="line">2  7.0  8.0  9.0</span><br></pre></td></tr></table></figure><p>B.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">     0    1    2</span><br><span class="line">1  4.0  NaN  6.0</span><br><span class="line">2  7.0  8.0  9.0</span><br></pre></td></tr></table></figure><p>C.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">     0    1    2</span><br><span class="line">2  7.0  8.0  9.0</span><br></pre></td></tr></table></figure><p>D.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">     0    1    2</span><br><span class="line">0  1.0  NaN  NaN</span><br><span class="line">2  7.0  8.0  9.0</span><br></pre></td></tr></table></figure><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>创建 DataFrame</b>：首先，`df` 被创建如下（`None` 会被转换为 `np.nan`）：<pre>   0    1    20  1.0  NaN  NaN1  4.0  NaN  6.02  7.0  8.0  9.0</pre></li>    <li><b>执行 `df.dropna(thresh=2)`</b>：      <ul>        <li><code>.dropna()</code> 方法用于删除含有缺失值的行或列（默认对行操作）。</li>        <li>参数 <code>thresh=2</code> 设定了一个阈值，表示<b>保留</b>那些<b>至少有 2 个</b>非缺失值的行。</li>      </ul>    </li>    <li><b>逐行分析</b>：      <ul>        <li><b>第0行</b> `[1.0, NaN, NaN]`：只有 1 个非缺失值。`1 < 2`，不满足条件，因此被<b>删除</b>。</li>        <li><b>第1行</b> `[4.0, NaN, 6.0]`：有 2 个非缺失值。`2 >= 2`，满足条件，因此被<b>保留</b>。</li>        <li><b>第2行</b> `[7.0, 8.0, 9.0]`：有 3 个非缺失值。`3 >= 2`，满足条件，因此被<b>保留</b>。</li>      </ul>    </li>    <li><b>最终结果</b>：操作后只剩下第 1 行和第 2 行，与选项 B 的内容完全一致。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 DataFrame</span></span><br><span class="line">df = pd.DataFrame([[<span class="number">1</span>, <span class="literal">None</span>, <span class="literal">None</span>], [<span class="number">4</span>, <span class="literal">None</span>, <span class="number">6</span>], [<span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>]])</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行 dropna 操作</span></span><br><span class="line">result = df.dropna(thresh=<span class="number">2</span>)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n执行 df.dropna(thresh=2) 之后的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>18. <code>data=pd.DataFrame([[1.0, 2.0, 3.0], [1.0, NA, NA], [NA, NA, NA]])</code></strong><br><strong>则 <code>cleaned=data.dropna()</code> 的输出结果是：（ ）</strong></p><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">     0    1    2</span><br><span class="line">0  1.0  2.0  3.0</span><br></pre></td></tr></table></figure><p>B.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">     0    1    2</span><br><span class="line">0  1.0  2.0  3.0</span><br><span class="line">1  1.0  NaN  NaN</span><br></pre></td></tr></table></figure><p>C.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">     0    1    2</span><br><span class="line">0  1.0  2.0  3.0</span><br><span class="line">1  1.0  NaN  NaN</span><br><span class="line">2  NaN  NaN  NaN</span><br></pre></td></tr></table></figure><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  （假设 `NA` 指的是 `np.nan`）  <ul>    <li><b>创建 DataFrame</b>：`data` 的内容如下：<pre>     0    1    20  1.0  2.0  3.01  1.0  NaN  NaN2  NaN  NaN  NaN</pre></li>    <li><b>执行 `cleaned = data.dropna()`</b>：      <ul>        <li><code>.dropna()</code> 方法的默认行为是 `axis=0` (对行操作) 和 `how='any'` (删除任何包含 `NaN` 的行)。</li>      </ul>    </li>    <li><b>逐行分析</b>：      <ul>        <li><b>第0行</b> `[1.0, 2.0, 3.0]`：不包含 `NaN`，因此被<b>保留</b>。</li>        <li><b>第1行</b> `[1.0, NaN, NaN]`：包含 `NaN`，因此被<b>删除</b>。</li>        <li><b>第2行</b> `[NaN, NaN, NaN]`：包含 `NaN`，因此被<b>删除</b>。</li>      </ul>    </li>    <li><b>最终结果</b>：操作后只剩下第 0 行，与选项 A 的内容完全一致。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 DataFrame</span></span><br><span class="line">data = pd.DataFrame([[<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>], [<span class="number">1.0</span>, np.nan, np.nan], [np.nan, np.nan, np.nan]])</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(data)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行 dropna 操作</span></span><br><span class="line">cleaned = data.dropna()</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n执行 data.dropna() 之后的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(cleaned)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>19. 下列代码输出为：（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">a = <span class="literal">None</span></span><br><span class="line">b = np.nan</span><br><span class="line">c = <span class="string">&#x27; &#x27;</span></span><br><span class="line">d = pd.Series([a,b,c,])</span><br><span class="line">d.isnull()</span><br></pre></td></tr></table></figure><p>A. <code>0 True 1 True 2 False dtype: bool</code><br>B. <code>0 True 1 True 2 True dtype: bool</code><br>C. <code>0 False 1 False 2 True dtype: bool</code><br>D. (其他结果)</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `.isnull()` 方法用于检测 Series 中的每个元素是否是缺失值。  <ul>    <li>`None`：在 Pandas 中被视作缺失值，返回 `True`。</li>    <li>`np.nan`：是标准的缺失值表示，返回 `True`。</li>    <li>`' '`：这是一个包含一个空格的<b>字符串</b>。它是一个有效的数据，不是缺失值，返回 `False`。</li>  </ul>  因此，结果是一个 `[True, True, False]` 的布尔 Series。<p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>20. 假设 <code>data = pd.DataFrame([[1., 6.5, 3.], [1., NA, NA], [NA, NA, NA], [NA, 6.5, 3.]])</code></strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">data.dropna()                     ①</span><br><span class="line">data.dropna(how=<span class="string">&#x27;all&#x27;</span>)            ②</span><br><span class="line">data.dropna(axis=<span class="number">1</span>, how=<span class="string">&#x27;all&#x27;</span>)    ③</span><br><span class="line">data.dropna(axis=<span class="number">1</span>)               ④</span><br></pre></td></tr></table></figure><p><strong>以上①②③④4个操作，哪个操作后得到的结果如下图：（ ）</strong><br><img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/14.png" alt="这里填写图片1的描述"></p><p>A. ①<br>B. ②<br>C. ③<br>D. ④</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  （假设 `NA` 指的是 `np.nan`）  <p>首先，我们分析题目给出的目标结果，它保留了原始 DataFrame 的第 0 行和第 3 行，删除了第 1 行和第 2 行。现在我们逐一分析每个操作的实际效果：</p>  <ul>    <li><b>① `data.dropna()`</b>：这是 <code>data.dropna(axis=0, how='any')</code> 的简写。它会删除<b>任何</b>包含 `NaN` 的<b>行</b>。这会删除第1、2、3行，只保留第0行。<b>不符合目标。</b></li>    <li><b>② `data.dropna(how='all')`</b>：这是 <code>data.dropna(axis=0, how='all')</code> 的简写。它会删除<b>所有值都为 `NaN`</b> 的<b>行</b>。这会删除第2行，保留第0、1、3行。<b>不符合目标。</b></li>    <li><b>③ `data.dropna(axis=1, how='all')`</b>：这会删除<b>所有值都为 `NaN`</b> 的<b>列</b>。在原始数据中，没有一列是所有值都为 `NaN` 的，所以这个操作会返回原始的 DataFrame，不会删除任何行或列。<b>不符合目标。</b></li>    <li><b>④ `data.dropna(axis=1)`</b>：这是 <code>data.dropna(axis=1, how='any')</code> 的简写。它会删除<b>任何</b>包含 `NaN` 的<b>列</b>。由于每一列都至少有一个 `NaN`，这个操作会删除所有列，返回一个空的 DataFrame。<b>不符合目标。</b></li>  </ul>  <p><b>结论</b>：根据标准的 Pandas <code>dropna</code> 行为，<b>没有一个选项能直接得到图示的结果</b>。这道题可能存在设计错误，或者目标图片与选项不匹配。</p>  <p>要得到图示的结果（保留行0和行3），可以使用 <code>data.dropna(thresh=2)</code>，它会保留至少有2个非缺失值的行。</p><p>  <strong>正确答案：</strong> C (根据题目提供，但与标准行为及图示结果不符)</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 DataFrame</span></span><br><span class="line">data = pd.DataFrame([[<span class="number">1.</span>, <span class="number">6.5</span>, <span class="number">3.</span>], [<span class="number">1.</span>, np.nan, np.nan], </span><br><span class="line">                     [np.nan, np.nan, np.nan], [np.nan, <span class="number">6.5</span>, <span class="number">3.</span>]])</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(data)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n--- 逐个分析选项的实际输出 ---&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n① data.dropna() 的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(data.dropna())</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n② data.dropna(how=&#x27;all&#x27;) 的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(data.dropna(how=<span class="string">&#x27;all&#x27;</span>))</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n③ data.dropna(axis=1, how=&#x27;all&#x27;) 的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(data.dropna(axis=<span class="number">1</span>, how=<span class="string">&#x27;all&#x27;</span>))</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n④ data.dropna(axis=1) 的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(data.dropna(axis=<span class="number">1</span>))</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n--- 能得到目标结果的正确代码 ---&quot;</span>)</span><br><span class="line">correct_result = data.dropna(thresh=<span class="number">2</span>)</span><br><span class="line"><span class="built_in">print</span>(correct_result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>21. 以下代码的输出结果为（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">df = pd.DataFrame(np.arange(<span class="number">9</span>).reshape(-<span class="number">1</span>, <span class="number">3</span>))</span><br><span class="line">df.iloc[:<span class="number">2</span>, <span class="number">1</span>] = np.nan</span><br><span class="line">df.iloc[:<span class="number">1</span>, <span class="number">2</span>] = np.nan</span><br><span class="line">df.dropna(thresh=<span class="number">3</span>)</span><br></pre></td></tr></table></figure><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">     0    1    2</span><br><span class="line">0  0.0  NaN  NaN</span><br><span class="line">1  3.0  NaN  5.0</span><br><span class="line">2  6.0  7.0  8.0</span><br></pre></td></tr></table></figure><p>B.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">     0    1    2</span><br><span class="line">1  3.0  NaN  5.0</span><br><span class="line">2  6.0  7.0  8.0</span><br></pre></td></tr></table></figure><p>C.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">     0    1    2</span><br><span class="line">2  6.0  7.0  8.0</span><br></pre></td></tr></table></figure><p>D. (空 DataFrame)</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>创建 DataFrame</b>：`df` 被创建为 3x3 的数组：<pre>   0  1  20  0  1  21  3  4  52  6  7  8</pre></li>    <li><b>第一次修改</b>：`df.iloc[:2, 1] = np.nan` 将第 0 行和第 1 行的第 1 列设为 `NaN`。</li>    <li><b>第二次修改</b>：`df.iloc[:1, 2] = np.nan` 将第 0 行的第 2 列设为 `NaN`。</li>    <li><b>修改后的 `df`</b> 如下：<pre>     0    1    20  0.0  NaN  NaN1  3.0  NaN  5.02  6.0  7.0  8.0</pre></li>    <li><b>执行 `df.dropna(thresh=3)`</b>：      <ul>        <li>该操作会删除<b>非缺失值</b>数量<b>小于 3</b> 的行。</li>        <li><b>第0行</b>：有 1 个非缺失值。`1 < 3`，<b>删除</b>。</li>        <li><b>第1行</b>：有 2 个非缺失值。`2 < 3`，<b>删除</b>。</li>        <li><b>第2行</b>：有 3 个非缺失值。`3 >= 3`，<b>保留</b>。</li>      </ul>    </li>    <li><b>最终结果</b>：操作后只剩下第 2 行，与选项 C 的内容完全一致。</li>  </ol><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建并修改 DataFrame</span></span><br><span class="line">df = pd.DataFrame(np.arange(<span class="number">9</span>).reshape(-<span class="number">1</span>, <span class="number">3</span>))</span><br><span class="line">df.iloc[:<span class="number">2</span>, <span class="number">1</span>] = np.nan</span><br><span class="line">df.iloc[:<span class="number">1</span>, <span class="number">2</span>] = np.nan</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;修改后的 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行 dropna 操作</span></span><br><span class="line">result = df.dropna(thresh=<span class="number">3</span>)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n执行 df.dropna(thresh=3) 之后的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>22. 以下对于<code>duplicated</code>方法和<code>drop_duplicates</code>方法的叙述，错误的是：（ ）</strong><br>A. <code>duplicated</code>返回的是一个布尔值Series，反映每一行是否与之前出现过的行相同。<br>B. 对于DataFrame对象<code>data</code>，<code>data.drop_duplicates()</code>的结果与<code>data[data.duplicated()]</code>相同。<br>C. <code>duplicated</code>方法和<code>drop_duplicates</code>方法默认都是保留第一个观测到的值。<br>D. <code>drop_duplicates</code>方法中传入参数<code>keep = &#39;last&#39;</code>将会保留重复行里面最后一个观测值。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确。`duplicated()` 用于识别重复。</li>    <li>B: <b>错误</b>。`data.drop_duplicates()` 是<b>去重</b>，返回去重后的数据。而 `data[data.duplicated()]` 是<b>筛选</b>，只返回那些被标记为重复的行。两者结果几乎相反。</li>    <li>C: 正确。两者默认的 `keep` 参数都是 `'first'`。</li>    <li>D: 正确。`keep='last'` 会保留重复项的最后一次出现。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>23. <code>data = pd.Series(...)</code>，以下对于<code>data</code>的操作，输出结果相同的是：（ ）</strong><br>(此题与第6题完全相同)<br>A. ①<br>B. ①②<br>C. ①②③<br>D. ①②③④</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  所有这四个操作最终都会得到相同的结果：将 `Series` 中的 `np.nan` 值替换为 `0`，而不改变其他数值。<p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>24. 运行下列代码，输出的结果为（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">ser = pd.Series([<span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">0</span>])</span><br><span class="line"><span class="keyword">match</span> = &#123;<span class="number">1</span>: <span class="string">&#x27;positive&#x27;</span>, -<span class="number">1</span>: <span class="string">&#x27;negative&#x27;</span>&#125;</span><br><span class="line">ser.<span class="built_in">map</span>(<span class="keyword">match</span>)</span><br></pre></td></tr></table></figure><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line">0    positive</span><br><span class="line">1    negative</span><br><span class="line">2    negative</span><br><span class="line">3    positive</span><br><span class="line">4    positive</span><br><span class="line">5    positive</span><br><span class="line">6         NaN</span><br><span class="line">dtype: object</span><br></pre></td></tr></table></figure><p>B.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line">0    positive</span><br><span class="line">1    negative</span><br><span class="line">2    negative</span><br><span class="line">3    positive</span><br><span class="line">4    positive</span><br><span class="line">5    positive</span><br><span class="line">6           0</span><br><span class="line">dtype: object</span><br></pre></td></tr></table></figure><p>C. 报错</p><p>D.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">0    positive</span><br><span class="line">1    negative</span><br><span class="line">2    negative</span><br><span class="line">3    positive</span><br><span class="line">4    positive</span><br><span class="line">5    positive</span><br><span class="line">dtype: object</span><br></pre></td></tr></table></figure><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`ser.map(match)`</b>：<code>.map()</code> 方法会根据传入的字典 `match` 对 `ser` 中的每个元素进行转换。</li>    <li>如果 `ser` 中的元素在 `match` 字典的键中能找到，则将其替换为对应的值。</li>    <li>如果 `ser` 中的元素<b>不在</b> `match` 字典的键中，则该位置的值将变为 <b>`NaN` (缺失值)</b>。</li>  </ul>  <p>让我们逐个元素分析：</p>  <ul>    <li><code>1</code> 存在于 `match` 的键中，映射为 `'positive'`。</li>    <li><code>-1</code> 存在于 `match` 的键中，映射为 `'negative'`。</li>    <li><code>0</code> <b>不</b>存在于 `match` 的键 `{1, -1}` 中，因此它将被映射为 `NaN`。</li>  </ul>  <p>最终结果是一个新的 Series，其中原始值为 `0` 的位置变成了 `NaN`。这与选项 A 的内容完全一致。</p><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 Series 和字典</span></span><br><span class="line">ser = pd.Series([<span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">0</span>])</span><br><span class="line"><span class="keyword">match</span> = &#123;<span class="number">1</span>: <span class="string">&#x27;positive&#x27;</span>, -<span class="number">1</span>: <span class="string">&#x27;negative&#x27;</span>&#125;</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行 map 操作</span></span><br><span class="line">result = ser.<span class="built_in">map</span>(<span class="keyword">match</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 打印结果</span></span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>25. 下面代码实现删除所有重复值的是( )</strong><br>A. <code>data.drop_duplicates(keep=False)</code><br>B. <code>data.drop_duplicates(keep=&#39;first&#39;)</code><br>C. <code>data.drop_duplicates(keep=&#39;False&#39;)</code><br>D. <code>data.drop_duplicates(keep=&#39;last&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `.drop_duplicates()` 方法的 `keep` 参数控制如何处理重复项。  <ul>    <li>`keep='first'` (默认)：保留第一次出现的。</li>    <li>`keep='last'`：保留最后一次出现的。</li>    <li><b>`keep=False`</b>：<b>删除所有</b>的重复行。即如果某行出现了多次，那么它的所有实例都会被删除，只保留那些从未重复过的唯一行。这符合“删除所有重复值”的描述。</li>    <li>`keep='False'` (字符串)：是无效参数，会报错。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;col&#x27;</span>: [<span class="string">&#x27;A&#x27;</span>, <span class="string">&#x27;B&#x27;</span>, <span class="string">&#x27;A&#x27;</span>, <span class="string">&#x27;C&#x27;</span>, <span class="string">&#x27;B&#x27;</span>]&#125;)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 删除所有重复项 (A和B的所有出现都被删除)</span></span><br><span class="line">result = df.drop_duplicates(keep=<span class="literal">False</span>)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>26. 下列哪个方法返回的不是boolean Series（ ）</strong><br>A. <code>data.duplicated()</code><br>B. <code>data.isnull()</code><br>C. <code>data &gt; data.median()</code><br>D. <code>data[data &gt; data.median()]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `data.duplicated()`：返回布尔 Series。</li>    <li>B. `data.isnull()`：返回布尔 Series。</li>    <li>C. `data > data.median()`：布尔比较，返回布尔 Series。</li>    <li><b>D. `data[data > data.median()]`</b>：这是一个<b>布尔索引</b>操作。它<b>使用</b>一个布尔 Series 来筛选原数据 `data`。返回的结果是 `data` 的一个子集，其数据类型与 `data` 相同（例如 `float64`），而不是布尔类型。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>27. 下列方法能将字符串中所有非重叠匹配模式以迭代器形式返回的是（ ）</strong><br>A. <code>findall</code><br>B. <code>finditer</code><br>C. <code>match</code><br>D. <code>search</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  这道题考察 Python `re` 模块（正则表达式）的方法。  <ul>    <li>A. `re.findall()`：返回所有匹配项的<b>列表</b>。</li>    <li><b>B. `re.finditer()`</b>：返回所有匹配项的<b>迭代器</b>，每个元素是一个匹配对象 (Match object)。</li>    <li>C. `re.match()`：只从字符串开头匹配，返回一个匹配对象或 `None`。</li>    <li>D. `re.search()`：在整个字符串中搜索第一个匹配项，返回一个匹配对象或 `None`。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> re</span><br><span class="line">text = <span class="string">&quot;apple banana apple&quot;</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># finditer 返回一个迭代器</span></span><br><span class="line">match_iterator = re.finditer(<span class="string">&quot;apple&quot;</span>, text)</span><br><span class="line"><span class="built_in">print</span>(<span class="built_in">type</span>(match_iterator))</span><br><span class="line"></span><br><span class="line"><span class="comment"># 遍历迭代器</span></span><br><span class="line"><span class="keyword">for</span> <span class="keyword">match</span> <span class="keyword">in</span> match_iterator:</span><br><span class="line">    <span class="built_in">print</span>(<span class="keyword">match</span>)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>28. 以下关于离散化和分箱说法不正确的是（ ）</strong><br>A. 使用pandas中的cut可以将数据列表分箱成左闭右开的一定数量区间<br>B. 使用pandas中的cut时，可以通过向labels选项传递列表或数组来传入箱名<br>C. 使用pandas中的qcut可以获得数量相等的箱子<br>D. 以上都正确</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: `pd.cut()` 默认创建的区间是<b>左开右闭</b>的，例如 `(a, b]`。而“左闭右开” (`[a, b)`) 需要通过设置 `right=False` 来实现。因此，将“左闭右开”作为 `cut` 的一般性描述是不准确的，尤其是针对其默认行为。</li>    <li>B: 正确。`labels` 参数用于为生成的箱子命名。</li>    <li>C: 正确。`qcut` 是基于分位数的分箱，会尝试使每个箱子包含相同数量的数据点。</li>  </ul>  因为 A 的描述与 `cut` 的默认行为不符，所以该说法不正确。<p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>29. 下列说法正确的是（ ）</strong><br>A. <code>df.fillna</code>的<code>method</code>为<code>bfill</code>时，以na值的下面一个值填充。为<code>ffill</code>时，以na值的上一个值填充<br>B. <code>df.fillna</code>的<code>limit</code>参数的作用是只填充na值个数小于等于limit的行<br>C. 要将<code>data[‘food’]</code>列中字符串转换为小写的方法是：<code>data[‘food’].lower()</code><br>D. <code>drop_duplicates</code>返回的是DataFrame，内容是<code>duplicated</code>返回数组中为<code>False</code>的部分，且默认为保留第一个观测到的值。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A</b>: 正确。`bfill` (backward fill) 是<b>后向</b>填充，使用后面（下面）的有效值。`ffill` (forward fill) 是<b>前向</b>填充，使用前面（上面）的有效值。</li>    <li>B: 错误。`limit` 参数限制的是<b>连续</b>缺失值的填充数量，而不是行内总数。</li>    <li>C: 错误。对 Series 应用字符串方法需要使用 `.str` 访问器，应为 `data['food'].str.lower()`。</li>    <li>D: 描述有瑕疵但逻辑上接近。`drop_duplicates()` 返回的是 `data[~data.duplicated()]` 的结果。虽然逻辑上是筛选 `duplicated()` 为 `False` 的部分，但用词“返回数组中”不准确。与 A 相比，A 的描述更精确无误。</li>  </ul><p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>30. 已知<code>val=&#39;a,c, emmm&#39;</code>; <code>val.find(&#39;,&#39;)</code>的结果是什么（ ）</strong><br>A. 1<br>B. -1<br>C. 2<br>D. 3</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `str.find(sub)` 方法返回子字符串 `sub` 在字符串中<b>第一次</b>出现的索引。索引从 0 开始计数。  在字符串 `'a,c, emmm'` 中，第一个逗号 `,` 的位置是在 `'a'` (索引0) 之后，即索引为 `1`。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">val = <span class="string">&#x27;a,c, emmm&#x27;</span></span><br><span class="line"><span class="built_in">print</span>(val.find(<span class="string">&#x27;,&#x27;</span>))</span><br></pre></td></tr></table></figure></p></details><h2 id="第八章：数据合并与重塑"><a href="#第八章：数据合并与重塑" class="headerlink" title="第八章：数据合并与重塑"></a>第八章：数据合并与重塑</h2><hr><p><strong>1. 下列哪个方法可以改变索引的层次？（ ）</strong><br>A. <code>reindex()</code><br>B. <code>swaplevel()</code><br>C. <code>change_level()</code><br>D. <code>reset_index()</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `reindex()`：根据新索引对数据进行重排，不直接改变层级结构。</li>    <li><b>B. `swaplevel()`</b>：专门用于<b>交换</b>多重索引中两个<b>层级</b>的位置。</li>    <li>C. `change_level()`：不是标准的 Pandas 方法。</li>    <li>D. `reset_index()`：将索引层级移动到数据列中，取消层次化索引。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建一个双层索引的 Series</span></span><br><span class="line">s = pd.Series(np.arange(<span class="number">4</span>), </span><br><span class="line">              index=[[<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;b&#x27;</span>], [<span class="number">1</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">2</span>]])</span><br><span class="line">s.index.names = [<span class="string">&#x27;level_1&#x27;</span>, <span class="string">&#x27;level_2&#x27;</span>]</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始索引:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(s)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 交换两个层级</span></span><br><span class="line">s_swapped = s.swaplevel(<span class="string">&#x27;level_1&#x27;</span>, <span class="string">&#x27;level_2&#x27;</span>)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n交换层级后:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(s_swapped)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>2. 用哪个Numpy库的函数可以将多个NumPy数组进行堆叠（ ）</strong><br>A. <code>concatenate</code><br>B. <code>concat</code><br>C. <code>merge</code><br>D. <code>join</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A. `concatenate`</b>：是 <b>NumPy</b> 库中用于沿指定轴连接（堆叠）多个数组的主要函数。</li>    <li>B. `concat`：是 <b>Pandas</b> 库的函数。</li>    <li>C. `merge`：是 <b>Pandas</b> 库的函数，用于数据库风格的连接。</li>    <li>D. `join`：是 <b>Pandas</b> 库的方法，用于基于索引的连接。</li>  </ul>  题目明确要求是 NumPy 库的函数。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">arr1 = np.array([[<span class="number">1</span>, <span class="number">2</span>], [<span class="number">3</span>, <span class="number">4</span>]])</span><br><span class="line">arr2 = np.array([[<span class="number">5</span>, <span class="number">6</span>]])</span><br><span class="line"></span><br><span class="line"><span class="comment"># 沿 axis=0 (行) 进行堆叠</span></span><br><span class="line">result = np.concatenate([arr1, arr2], axis=<span class="number">0</span>)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>3. 默认情况下，用merge方法连接两张表做的是（ ）</strong><br>A. 内连接<br>B. 外连接<br>C. 左连接<br>D. 右连接</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  Pandas 的 `pd.merge()` 函数中，`how` 参数决定了连接的类型。其默认值是 `'inner'`，即<b>内连接</b>。内连接会返回两个表中连接键的交集部分。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line">df1 = pd.DataFrame(&#123;<span class="string">&#x27;key&#x27;</span>: [<span class="string">&#x27;A&#x27;</span>, <span class="string">&#x27;B&#x27;</span>, <span class="string">&#x27;C&#x27;</span>], <span class="string">&#x27;value1&#x27;</span>: [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]&#125;)</span><br><span class="line">df2 = pd.DataFrame(&#123;<span class="string">&#x27;key&#x27;</span>: [<span class="string">&#x27;B&#x27;</span>, <span class="string">&#x27;C&#x27;</span>, <span class="string">&#x27;D&#x27;</span>], <span class="string">&#x27;value2&#x27;</span>: [<span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>]&#125;)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 默认进行内连接，只保留共有的键 &#x27;B&#x27; 和 &#x27;C&#x27;</span></span><br><span class="line">result = pd.merge(df1, df2)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>4. 假设有DataFrame 对象frame，下列操作会改变frame的是（ ）</strong><br>(1) <code>frame.index.names = [&#39;a&#39;]</code><br>(2) <code>frame.stack()</code><br>(3) <code>frame.swaplevel(0,1)</code></p><p>A. (1)<br>B. (2)<br>C. (3)<br>D. (1)(2)(3)</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>(1) <b>`frame.index.names = ['a']`</b>：直接对 DataFrame 的 `index` 对象的 `.names` 属性进行赋值，这是一个<b>原地 (in-place)</b> 操作，会直接改变 `frame`。</li>    <li>(2) `frame.stack()`：堆叠操作，会返回一个<b>新的</b> Series 或 DataFrame 对象，不改变原始的 `frame`。</li>    <li>(3) `frame.swaplevel(0,1)`：交换索引层级，会返回一个<b>新的</b> DataFrame 对象，不改变原始的 `frame`。</li>  </ul>  因此，只有操作 (1) 会原地改变 `frame`。<p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>5. 对于堆叠与拆堆操作，以下说法错误的是（ ）</strong><br>A. 如果层级中的所有值并未包含于每个子分组中时，拆分可能会引入缺失值<br>B. 默认情况下，堆叠会过滤出缺失值<br>C. 在DataFrame中拆堆时，被拆堆的层级会变为结果中最低的层级<br>D. 堆叠和拆堆操作是不可逆的</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确。`unstack()` 时，如果某个索引组合不存在，会用 `NaN` 填充。</li>    <li>B: 正确。`stack()` 的默认参数 `dropna=True` 会过滤掉全为 `NaN` 的行。</li>    <li>C: 正确。`unstack()` 会将指定的索引层级（默认为最内层）变为新的列层级的最内层。</li>    <li>D: <b>错误</b>。`stack()` 和 `unstack()` 是一对<b>可逆操作</b>。通常情况下，`df.stack().unstack()` 会得到与原始 `df` 相同的 DataFrame（需要注意 `NaN` 值的处理可能会影响完全可逆性）。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>6. 下列哪个方法可以对dataframe数据进行转置。（ ）</strong><br>A. <code>swaplevel()</code><br>B. <code>reset_index()</code><br>C. <code>dataframe.T</code><br>D. 以上都不是</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `swaplevel()`：交换多重索引的层级。</li>    <li>B. `reset_index()`：将索引转换为列。</li>    <li><b>C. `dataframe.T`</b>：`.T` 是 DataFrame 的一个<b>属性</b>，用于访问其<b>转置 (Transpose)</b> 后的形式，即将行和列互换。</li>  </ul><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;A&#x27;</span>: [<span class="number">1</span>, <span class="number">2</span>], <span class="string">&#x27;B&#x27;</span>: [<span class="number">3</span>, <span class="number">4</span>]&#125;)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n转置后:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(df.T)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>7. 假设有双层索引的DataFrame对象<code>data</code>，则下列代码的输出结果是：（ ）</strong><br><code>data1 = data.unstack().stack(); data is data1</code><br>A. True<br>B. False<br>C. 报错<br>D. 不能确定</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>`data.unstack()` 操作会返回一个<b>新的</b> DataFrame 对象。</li>    <li>接着对这个新对象调用 `.stack()` 方法，同样会返回<b>另一个新的</b>对象。</li>    <li>`data1` 引用的是经过两次操作后最终生成的新对象。</li>    <li>Python 的 `is` 运算符检查两个变量是否引用内存中的<b>同一个对象</b>。由于 `data` 和 `data1` 是两个独立的对象，即使它们的值可能完全相同，`data is data1` 的结果也为 `False`。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>8. 下列哪个方法可以取消dataframe层次化索引。( )</strong><br>A. <code>swaplevel()</code><br>B. <code>reset_index()</code><br>C. <code>dataframe.T</code><br>D. <code>set_index()</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `swaplevel()`：交换索引层级，但仍是层次化索引。</li>    <li><b>B. `reset_index()`</b>：此方法将一个或多个索引层级<b>移入到数据列</b>中，并用一个简单的整数索引替代，从而“取消”了层次化索引。</li>    <li>C. `dataframe.T`：转置 DataFrame。</li>    <li>D. `set_index()`：用于从数据列<b>创建</b>层次化索引。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>9. 对于两个Series对象a和b，运行<code>pd.Series(np.where(pd.isnull(a),b,a))</code>，下面哪个选项输出的结果与该行代码输出的结果相同（ ）</strong><br>A. <code>a.combine_first(b)</code><br>B. <code>pd.Series(np.where(pd.isnull(b),a,b))</code><br>C. <code>pd.Series(np.where(pd.isnull(a),a,b))</code><br>D. <code>pd.Series(np.where(pd.isnull(b),b,a))</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`np.where(pd.isnull(a), b, a)`</b> 的含义是：“如果 `a` 中的某个位置是 `null` (缺失值)，则取 `b` 中对应位置的值；否则，取 `a` 中原来的值”。</li>    <li><b>`a.combine_first(b)`</b> 的作用完全相同：用 `b` 中的值来“修补”或“填充” `a` 中的缺失值。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">a = pd.Series([np.nan, <span class="number">2.5</span>, <span class="number">0.0</span>, np.nan])</span><br><span class="line">b = pd.Series([<span class="number">0.</span>, <span class="number">1.5</span>, np.nan, <span class="number">5.</span>])</span><br><span class="line"></span><br><span class="line">result_where = pd.Series(np.where(pd.isnull(a), b, a))</span><br><span class="line">result_combine = a.combine_first(b)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;np.where 的结果:&quot;</span>, result_where.values)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;combine_first 的结果:&quot;</span>, result_combine.values)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>10. 对于<code>concat()</code>方法，下列的说法错误的是？（ ）</strong><br>A. <code>concat()</code>默认情况下是在<code>axis=0</code>轴向进行连接的。<br>B. <code>concat()</code>可以通过<code>join_axes</code>方法来指定用于连接的轴。<br>C. <code>concat()</code>在对Series对象在<code>axis=1</code>时进行连接得到的还是一个Series对象。<br>D. <code>concat()</code>之后得到的对象如果是存在多级索引时可以进行<code>unstack()</code>操作。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确。默认沿 `axis=0` (行方向) 拼接。</li>    <li>B: 正确（但在新版 Pandas 中已弃用）。`join_axes` 曾用于指定其他轴的索引。</li>    <li>C: <b>错误</b>。将多个 Series 沿 `axis=1` (列方向) 拼接时，每个 Series 会成为新对象的一列，最终得到的是一个 <b>DataFrame</b>，而不是 Series。</li>    <li>D: 正确。如果拼接后产生了多级索引，可以使用 `unstack()` 进行拆堆。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>11. 以下<code>merge</code>函数的参数<code>how</code>的取值范围，其中是将两个表共有的键进行连接操作的是（ ）</strong><br>A. <code>inner</code><br>B. <code>left</code><br>C. <code>outer</code><br>D. <code>right</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `pd.merge()` 函数中 `how` 参数的含义：  <ul>    <li><b>A. `inner`</b>：内连接，取两个表中连接键的<b>交集</b>。这正是“共有的键”。</li>    <li>B. `left`：左连接，以左表的键为准。</li>    <li>C. `outer`：外连接，取两个表中连接键的<b>并集</b>。</li>    <li>D. `right`：右连接，以右表的键为准。</li>  </ul><p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>12. 对于DataFrame <code>frame</code>，代码<code>frame.set_index([&#39;c&#39;,&#39;d&#39;]).unstack()</code>的输出为（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">frame = pd.DataFrame(&#123;<span class="string">&#x27;a&#x27;</span>: <span class="built_in">range</span>(<span class="number">3</span>), <span class="string">&#x27;b&#x27;</span>: <span class="built_in">range</span>(<span class="number">3</span>, <span class="number">0</span>, -<span class="number">1</span>),</span><br><span class="line">                      <span class="string">&#x27;c&#x27;</span>: [<span class="string">&#x27;one&#x27;</span>, <span class="string">&#x27;one&#x27;</span>, <span class="string">&#x27;two&#x27;</span>],</span><br><span class="line">                      <span class="string">&#x27;d&#x27;</span>: [<span class="number">0</span>, <span class="number">1</span>, <span class="number">1</span>]&#125;)</span><br></pre></td></tr></table></figure><p>A. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/15.png" alt="这里填写图片1的描述"><br>B. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/16.png" alt="这里填写图片1的描述"><br>C. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/17.png" alt="这里填写图片1的描述"><br>D. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/18.png" alt="这里填写图片1的描述"></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>初始 `frame`</b>：<pre>   a  b    c  d0  0  3  one  01  1  2  one  12  2  1  two  1</pre></li>    <li><b>`frame.set_index(['c','d'])`</b>：将 `'c'` 和 `'d'` 列设为多重索引 (MultiIndex)。`'c'` 是第0层，`'d'` 是第1层。<pre>       a  bc   d      one 0  0  3    1  1  2two 1  2  1</pre></li>    <li><b>`.unstack()`</b>：拆分（或“旋转”）索引。      <ul>        <li>默认情况下，`.unstack()` 会拆分<b>最内层</b>的索引，也就是 `'d'` (第1层)。</li>        <li>`'d'` 层级的标签 (`0`, `1`) 会成为新的<b>列层级</b>的最内层。</li>        <li>原始的数据列 (`'a'`, `'b'`) 成为新的列层级的最外层。</li>        <li>当某个索引组合（如 `('two', 0)`）在拆分前不存在时，拆分后对应位置会用 `NaN` 填充。</li>      </ul>    </li>    <li><b>最终结果</b>：<pre>      a         b     d     0    1    0    1c                    one 0.0  1.0  3.0  2.0two NaN  2.0  NaN  1.0</pre>这个结果与选项 B 的图片完全匹配。</li>  </ol><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 DataFrame</span></span><br><span class="line">frame = pd.DataFrame(&#123;<span class="string">&#x27;a&#x27;</span>: <span class="built_in">range</span>(<span class="number">3</span>), <span class="string">&#x27;b&#x27;</span>: <span class="built_in">range</span>(<span class="number">3</span>, <span class="number">0</span>, -<span class="number">1</span>),</span><br><span class="line">                      <span class="string">&#x27;c&#x27;</span>: [<span class="string">&#x27;one&#x27;</span>, <span class="string">&#x27;one&#x27;</span>, <span class="string">&#x27;two&#x27;</span>],</span><br><span class="line">                      <span class="string">&#x27;d&#x27;</span>: [<span class="number">0</span>, <span class="number">1</span>, <span class="number">1</span>]&#125;)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行 set_index 和 unstack</span></span><br><span class="line">result = frame.set_index([<span class="string">&#x27;c&#x27;</span>, <span class="string">&#x27;d&#x27;</span>]).unstack()</span><br><span class="line"></span><br><span class="line"><span class="comment"># 打印结果</span></span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>13. 设 <code>data=pd.Series(range(7), index=[[&#39;a&#39;,&#39;a&#39;,&#39;a&#39;,&#39;b&#39;,&#39;b&#39;,&#39;c&#39;,&#39;c&#39;], [1,2,3,1,2,1,2]])</code>，执行<code>data.loc[[&#39;a&#39;,&#39;c&#39;]]</code>得到的结果是（ ）</strong></p><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">a  1    0</span><br><span class="line">   2    1</span><br><span class="line">   3    2</span><br><span class="line">c  1    5</span><br><span class="line">   2    6</span><br><span class="line">dtype: int64</span><br></pre></td></tr></table></figure><p>B.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">a  1    0</span><br><span class="line">   2    1</span><br><span class="line">c  1    5</span><br><span class="line">   2    6</span><br><span class="line">dtype: int64</span><br></pre></td></tr></table></figure><p>C.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">a  1    0</span><br><span class="line">c  1    5</span><br><span class="line">dtype: int64</span><br></pre></td></tr></table></figure><p>D.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">a  3    2</span><br><span class="line">c  1    5</span><br><span class="line">dtype: int64</span><br></pre></td></tr></table></figure><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>创建 Series</b>：`data` 是一个具有双层索引 (MultiIndex) 的 Series。<pre>a  1    0   2    1   3    2b  1    3   2    4c  1    5   2    6dtype: int64</pre></li>    <li><b>执行 `data.loc[['a','c']]`</b>：      <ul>        <li><code>.loc[]</code> 是基于标签的索引方法。</li>        <li>当向 <code>.loc</code> 传入一个列表 `['a', 'c']` 时，它会选择<b>第一层索引</b>中所有标签为 `'a'` 或 `'c'` 的行。</li>        <li>这会选中所有以 `'a'` 开头的行和所有以 `'c'` 开头的行，并保持其原始的层级结构和对应的值。</li>      </ul>    </li>    <li><b>最终结果</b>：操作会返回一个新的 Series，包含原 Series 中第一层索引为 'a' 和 'c' 的所有数据，与选项 A 的内容完全一致。</li>  </ul><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 Series</span></span><br><span class="line">data = pd.Series(<span class="built_in">range</span>(<span class="number">7</span>), </span><br><span class="line">                  index=[[<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;c&#x27;</span>], </span><br><span class="line">                         [<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>,<span class="number">1</span>,<span class="number">2</span>,<span class="number">1</span>,<span class="number">2</span>]])</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 Series:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(data)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行 loc 操作</span></span><br><span class="line">result = data.loc[[<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;c&#x27;</span>]]</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n执行 data.loc[[&#x27;a&#x27;,&#x27;c&#x27;]] 之后的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>14. 列关于DataFrame中的<code>set_index</code>函数的叙述，错误的是：（ ）</strong><br>A. 使用<code>set_index</code>函数会生成一个新的DataFrame。<br>B. 使用<code>set_index</code>方法，默认情况下，被用作索引的列将会自动从DataFrame中移除。<br>C. 可以改变参数<code>drop</code>的值为<code>True</code>，将被用做索引的列留在DataFrame中。<br>D. <code>set_index</code>的反操作<code>reset_index</code>将分层索引的索引层级移动到列中</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确。默认 `inplace=False`，返回新对象。</li>    <li>B: 正确。默认 `drop=True`，用作索引的列会从数据列中移除。</li>    <li>C: <b>错误</b>。要将被用作索引的列<b>留在</b> DataFrame 中，需要设置 `drop=False`。`drop=True` 是默认行为，会<b>移除</b>该列。</li>    <li>D: 正确。`reset_index` 是 `set_index` 的逆操作。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>15. 下列对pandas中的<code>concat</code>方法的叙述，错误的是：（ ）</strong><br>A. <code>concat</code>方法中的参数<code>join_axes</code>可以用来指定用于连接其他轴向的轴。<br>B. 可以用<code>concat</code>方法中的参数<code>keys</code>通过在连接轴向上创建一个多层索引来区分结果中拼接在一起的各部分。<br>C. 默认情况下，<code>concat</code>方法是沿着<code>axis = 1</code>轴向生效的。<br>D. <code>concat</code>方法可以用于连接多个DataFrame。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确（但在新版 Pandas 中已弃用）。</li>    <li>B: 正确。`keys` 参数用于创建层次化索引。</li>    <li>C: <b>错误</b>。`pd.concat()` 的默认行为是沿着 <b>`axis=0`</b>（行方向）进行拼接。</li>    <li>D: 正确。`concat` 的主要用途就是连接多个 Pandas 对象。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>16. 对于<code>concat</code>函数的参数，以下说法错误的是（ ）</strong><br>A. <code>objs</code>参数用于指定需要连接的对象列表或字典<br>B. <code>keys</code>参数用于指定多层索引的层级<br>C. <code>axis</code>参数用于指定连接的轴向，默认为0轴<br>D. <code>join</code>参数用于指定连接的方式</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确。`objs` 是要拼接的对象序列。</li>    <li>B: <b>错误</b>。`keys` 参数用于提供新创建的<b>层级</b>的<b>标签 (labels)</b>，而不是指定层级本身。用于命名层级的是 `names` 参数。这个描述不精确，是所有选项中最不正确的。</li>    <li>C: 正确。默认 `axis=0`。</li>    <li>D: 正确。`join` 参数（'inner' 或 'outer'）决定了其他轴上的索引如何对齐。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>17. 以下使用merge函数连接左右DataFrame(两者都有两个列key1和key2)的操作正确的是( )</strong><br>A. <code>pd.merge(left,right,left_on=&#39;key1&#39;)</code><br>B. <code>pd.merge(left,right,right_on=&#39;key1&#39;)</code><br>C. <code>pd.merge(left,right,left_on=&#39;key1&#39;,right_index=True)</code><br>D. <code>pd.merge(left,right,left_on=&#39;key1&#39;,right_on=&#39;key2&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 错误。只指定 `left_on` 时，必须同时指定 `right_on` 或 `right_index=True`。</li>    <li>B: 错误。只指定 `right_on` 时，必须同时指定 `left_on` 或 `left_index=True`。</li>    <li>C: 正确。这是一个有效的连接操作，用左表的 `key1` 列和右表的索引进行连接。</li>    <li>D: 正确。这也是一个有效的连接操作，用左表的 `key1` 列和右表的 `key2` 列进行连接。</li>  </ul>  题目要求选择一个正确的操作，C 和 D 都是语法正确的。但在单选题中，D 展示了更典型的按不同列名连接的场景。<p>  <strong>正确答案：</strong> D (C 也是语法正确的)</p></details><hr><p><strong>18. 对于下列代码，下列选项中输出结果不同的是( )</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">data = pd.Series(np.random.randn(<span class="number">6</span>),</span><br><span class="line">                 index=[[<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>],[<span class="number">1</span>,<span class="number">2</span>,<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>,<span class="number">2</span>]])</span><br><span class="line">data[<span class="string">&#x27;a&#x27;</span>:<span class="string">&#x27;b&#x27;</span>]</span><br></pre></td></tr></table></figure><p>A. <code>data[[&#39;a&#39;,&#39;b&#39;]]</code><br>B. <code>data.loc[[&#39;a&#39;,&#39;b&#39;]]</code><br>C. <code>data.loc[[&#39;a&#39;,&#39;b&#39;],:3]</code><br>D. <code>data[:2]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>`data['a':'b']`：对第一层索引进行<b>标签切片</b>，会选择所有 `'a'` 和 `'b'` 的行，共5行。</li>    <li>A. `data[['a','b']]`：对第一层索引进行<b>花式索引</b>，选择所有 `'a'` 和 `'b'` 的行。结果与 `data['a':'b']` 相同。</li>    <li>B. `data.loc[['a','b']]`：与 A 相同，是更明确的写法。</li>    <li>C. `data.loc[['a','b'],:3]`：`.loc` 中，第二部分的整数切片 `:3` 是无效的，它期望的是标签。此代码会报错。</li>    <li>D. `data[:2]`：这是<b>位置切片</b>，只选择前2行（即所有 `'a'` 的行）。结果与 `data['a':'b']` 不同。</li>  </ul>  选项 D 的结果是明确且不同的。<p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>19. 已知<code>result</code>是Series，数据如下，下列语句结果不同于其他三项的是（ ）</strong></p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">state         number</span><br><span class="line">Ohio           one       0</span><br><span class="line">               two       1</span><br><span class="line">               three     2</span><br><span class="line">Colorado       one       3</span><br><span class="line">               two       4</span><br><span class="line">               three     5</span><br></pre></td></tr></table></figure><p>A. <code>result.unstack()</code><br>B. <code>result.unstack(0)</code><br>C. <code>result.unstack(&#39;number&#39;)</code><br>D. <code>result.unstack(1)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `unstack()` 方法用于将 Series 的多重索引中的一个层级“拆”到列上。  <ul>    <li>`result` 的索引层级是 `state` (level=0) 和 `number` (level=1)。</li>    <li><b>A. `result.unstack()`</b>：默认情况下，拆分<b>最内层</b>的索引，即 `number` (level=1)。</li>    <li><b>B. `result.unstack(0)`</b>：明确指定拆分第 0 层索引，即 `state`。<b>结果不同</b>。</li>    <li><b>C. `result.unstack('number')`</b>：明确指定拆分名为 `'number'` 的索引层级，即 level=1。结果与默认相同。</li>    <li><b>D. `result.unstack(1)`</b>：明确指定拆分第 1 层索引，即 `number`。结果与默认相同。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>20. 下列关于<code>merge</code>方法说法正确的是：（ ）</strong><br>A. 默认情况下，merge做的是外连接<br>B. 没有指定在哪一列上进行连接时， merge会自动将重叠的列名作为连接的键<br>C. merge方法的内连接，结果是两张表的并集，外连接是两张表的交集<br>D. 以上都不对</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 错误。`merge` 默认是<b>内连接 (`inner`)</b>。</li>    <li><b>B: 正确</b>。如果没有通过 `on`, `left_on`, `right_on` 等参数指定连接键，`merge` 会自动使用两个 DataFrame 中<b>共同的列名</b>作为连接键。</li>    <li>C: 错误。内连接是<b>交集</b>，外连接是<b>并集</b>。描述正好相反。</li>    <li>D: 错误，因为 B 是正确的。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>21. 对于给定的 <code>frame</code>，下列代码可以正确输出的是：（ ）</strong><br>A. <code>frame[&#39;state&#39;]</code><br>B. <code>frame[&#39;key1&#39;]</code><br>C. <code>frame[&#39;a&#39;]</code><br>D. <code>frame[&#39;Colorado&#39;]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `frame` 的列是一个多重索引，顶层 (`state`) 的标签是 `['Ohio', 'Colorado']`。  <ul>    <li>A: 错误。`'state'` 是列索引的一个<b>层级名</b>，不能直接用于索引。</li>    <li>B: 错误。`'key1'` 是<b>行</b>索引的层级名。</li>    <li>C: 错误。`'a'` 是<b>行</b>索引的一个标签。</li>    <li><b>D: 正确</b>。`'Colorado'` 是列索引<b>顶层</b>的一个有效标签，可以用 `frame['Colorado']` 来选择它下面的所有列。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>22. <code>frame.sort_index(level=0)</code> 的结果是（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">frame = pd.DataFrame(np.arange(<span class="number">12</span>).reshape((<span class="number">4</span>, <span class="number">3</span>)),</span><br><span class="line">                     index=[[<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;b&#x27;</span>], [<span class="number">1</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">2</span>]],</span><br><span class="line">                     columns=[[<span class="string">&#x27;Ohio&#x27;</span>, <span class="string">&#x27;Ohio&#x27;</span>, <span class="string">&#x27;Colorado&#x27;</span>],</span><br><span class="line">                              [<span class="string">&#x27;Green&#x27;</span>, <span class="string">&#x27;Red&#x27;</span>, <span class="string">&#x27;Green&#x27;</span>]])</span><br><span class="line">frame.index.names = [<span class="string">&#x27;key1&#x27;</span>, <span class="string">&#x27;key2&#x27;</span>]</span><br></pre></td></tr></table></figure><p>A. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/19.png" alt="这里填写图片1的描述"><br>B. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/20.png" alt="这里填写图片1的描述"><br>C. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/21.png" alt="这里填写图片1的描述"></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>初始 `frame` 的行索引</b>：是一个双层索引 (MultiIndex)，其值为 `[('a', 1), ('a', 2), ('b', 1), ('b', 2)]`。第一层 (`key1`) 是 `['a', 'a', 'b', 'b']`，第二层 (`key2`) 是 `[1, 2, 1, 2]`。</li>    <li><b>执行 `frame.sort_index(level=0)`</b>：      <ul>        <li>该方法用于按索引进行排序。</li>        <li>参数 <code>level=0</code> 明确指定了要排序的是<b>第一个索引层级</b>，即 `key1`。</li>      </ul>    </li>    <li><b>分析排序过程</b>：      <ul>        <li>我们观察 `key1` 层级的标签：`['a', 'a', 'b', 'b']`。</li>        <li>这个序列本身<b>已经</b>是按字母顺序排好序的（`a` 在 `b` 之前）。</li>        <li>因此，调用 `sort_index(level=0)` 不会改变 `frame` 的行顺序。</li>      </ul>    </li>    <li><b>最终结果</b>：输出的 DataFrame 将与原始的 `frame` 完全相同，这与选项 B 的图片内容一致。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 DataFrame</span></span><br><span class="line">frame = pd.DataFrame(np.arange(<span class="number">12</span>).reshape((<span class="number">4</span>, <span class="number">3</span>)),</span><br><span class="line">                     index=[[<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;b&#x27;</span>], [<span class="number">1</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">2</span>]],</span><br><span class="line">                     columns=[[<span class="string">&#x27;Ohio&#x27;</span>, <span class="string">&#x27;Ohio&#x27;</span>, <span class="string">&#x27;Colorado&#x27;</span>],</span><br><span class="line">                              [<span class="string">&#x27;Green&#x27;</span>, <span class="string">&#x27;Red&#x27;</span>, <span class="string">&#x27;Green&#x27;</span>]])</span><br><span class="line">frame.index.names = [<span class="string">&#x27;key1&#x27;</span>, <span class="string">&#x27;key2&#x27;</span>]</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(frame)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行 sort_index 操作</span></span><br><span class="line">result = frame.sort_index(level=<span class="number">0</span>)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n执行 frame.sort_index(level=0) 之后的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>23. 下列关于<code>concat</code>函数的参数说法正确的是：（ ）</strong><br>A. <code>axis</code>的轴向默认是0沿着行方向<br>B. <code>objs</code>不是必选参数<br>C. <code>join</code>默认是<code>inner</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A: 正确</b>。`axis=0` 是默认值，表示沿行索引方向进行拼接（即垂直堆叠）。</li>    <li>B: 错误。`objs` 是一个包含要拼接对象的序列，是 `concat` 的<b>必选</b>参数。</li>    <li>C: 错误。`join` 的默认值是 `'outer'`，即取所有轴上索引的并集。</li>  </ul><p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>24. 取消DataFrame的多层索引可以使用哪个方法（ ）</strong><br>A. <code>swaplevel()</code><br>B. <code>reset_index()</code><br>C. <code>concat()</code><br>D. <code>rename()</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  此题与第 8 题相同。`reset_index()` 方法将索引层级移入到数据列中，并用一个简单的整数索引替代，从而“取消”了层次化索引。<p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>25. 选出下面正确的一项（ ）</strong><br>A. DataFrame的<code>set_index</code>函数会在原来的DataFrame上进行修改<br>B. 一般情况下，<code>merge</code>是进行外连接<br>C. 用<code>sort_index()</code>只能在单一层级上对数据进行排序<br>D. 以上都不对</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 错误。`set_index` 默认 `inplace=False`，返回一个新对象。</li>    <li>B: 错误。`merge` 默认是<b>内连接 (`inner`)</b>。</li>    <li>C: 错误。`sort_index` 的 `level` 参数可以接受一个列表，从而按多个层级的顺序进行排序。</li>  </ul>  由于 A, B, C 都错误，所以 D 是正确选项。<p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>26. 执行下列代码的效果是：( )</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line">df = pd.DataFrame(np.arange(<span class="number">72</span>).reshape((<span class="number">8</span>,<span class="number">9</span>)))</span><br><span class="line">df.sub(df.mean(axis=<span class="number">1</span>), axis=<span class="number">0</span>)</span><br></pre></td></tr></table></figure><p>A. 输出各行的均值。<br>B. 输出每列原来的数值减去每行数据的平均值。<br>C. 输出每行原来的数值减去所有数据的平均值。<br>D. 输出每行原来的数值减去该行数据的平均值。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`df.mean(axis=1)`</b>：计算每一<b>行</b>的平均值。这会产生一个 Series，其索引与 `df` 的行索引对齐。</li>    <li><b>`df.sub(series, axis=0)`</b>：`sub` 是减法操作。`axis=0` (或 `axis='index'`) 指示 Pandas 在广播时，将 `series` 的索引与 `df` 的<b>行索引</b>对齐。</li>    <li>这意味着，对于 `df` 中的每一行，都会减去 `series` 中具有相同行索引的那个值（即该行的平均值）。</li>  </ol>  因此，整个操作的效果是：对于 `df` 的每一行，其所有元素都减去该行自身的平均值。<p>  <strong>正确答案：</strong> D</p></details><h2 id="第九章：数据可视化"><a href="#第九章：数据可视化" class="headerlink" title="第九章：数据可视化"></a>第九章：数据可视化</h2><p><strong>1. 在创建了子图之后，接连输入两条绘图命令<code>plt.plot()</code>，会出现什么情况？（ ）</strong><br>A. matplotlib会在最后一个图片和子图上展示两条命令的图像。<br>B. matplotlib会在最后一个子图上展示最后一条的图像，在倒数第二个子图上展示倒数第二条的图像。<br>C. 报错。<br>D. matplotlib只会在最后一个图片和子图上展示最后一条命令的图像。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  Matplotlib 的状态机接口 (pyplot) 会将所有绘图命令作用于当前“活动”的 Axes (子图) 对象。如果在创建子图后没有明确切换活动子图，那么所有后续的 `plt.plot()` 命令都会在同一个（通常是最后一个创建的）子图上叠加绘制。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> matplotlib.pyplot <span class="keyword">as</span> plt</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建一个包含两个子图的 Figure</span></span><br><span class="line">fig, axes = plt.subplots(<span class="number">1</span>, <span class="number">2</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 此时，axes[1] 是“活动”子图</span></span><br><span class="line"><span class="comment"># 接连输入两条绘图命令</span></span><br><span class="line">plt.plot([<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>])</span><br><span class="line">plt.plot([<span class="number">3</span>, <span class="number">2</span>, <span class="number">1</span>])</span><br><span class="line"></span><br><span class="line"><span class="comment"># 显示图像，会看到两条线都绘制在右边的子图上</span></span><br><span class="line">plt.show()</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>2. 在图表中添加图形时，需要用到的命令是？（ ）</strong><br>A. <code>add_subplot()</code><br>B. <code>add_patch()</code><br>C. <code>figure()</code><br>D. <code>set_title()</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `add_subplot()`：用于向 Figure 添加子图 (Axes)。</li>    <li><b>B. `add_patch()`</b>：`patch` 是 Matplotlib 中几何形状的基类，如矩形、圆形、多边形等。`ax.add_patch()` 方法用于将这些形状（图形）添加到子图中。</li>    <li>C. `figure()`：用于创建新的 Figure 对象。</li>    <li>D. `set_title()`：用于设置子图的标题。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> matplotlib.pyplot <span class="keyword">as</span> plt</span><br><span class="line"></span><br><span class="line">fig, ax = plt.subplots()</span><br><span class="line"><span class="comment"># 创建一个矩形 Patch</span></span><br><span class="line">rect = plt.Rectangle((<span class="number">0.2</span>, <span class="number">0.2</span>), <span class="number">0.5</span>, <span class="number">0.5</span>, color=<span class="string">&#x27;r&#x27;</span>)</span><br><span class="line"><span class="comment"># 将 Patch 添加到子图中</span></span><br><span class="line">ax.add_patch(rect)</span><br><span class="line">plt.show()</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>3. 下面这个图符合下列哪个语句的样式？（ ）</strong><br><img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/22.jpg" alt="这里填写图片1的描述"><br>A. <code>plt.plot(np.random.randn(30).cumsum(), &#39;ko--&#39;)</code><br>B. <code>plt.plot(np.random.randn(30).cumsum(), &#39;ko-&#39;)</code><br>C. <code>plt.plot(np.random.randn(30).cumsum(), &#39;k--&#39;)</code><br>D. <code>plt.plot(np.random.randn(30).cumsum(), &#39;k-&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `'ko--'` 是一个格式字符串，它组合了颜色、标记和线型：  <ul>    <li>`'k'`：表示颜色为黑色 (black)。</li>    <li>`'o'`：表示标记 (marker) 为圆点。</li>    <li>`'--'`：表示线型 (linestyle) 为虚线 (dashed)。</li>  </ul>  这与图片中“黑色、点、虚线连接”的样式完全匹配。<p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>4. 下面在matplotlib中不表示颜色的是（ ）</strong><br>A. b<br>B. k<br>C. o<br>D. r</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  在 Matplotlib 的格式字符串中：  <ul>    <li>A. `'b'`：表示蓝色 (blue)。</li>    <li>B. `'k'`：表示黑色 (black)。</li>    <li><b>C. `'o'`</b>：表示<b>标记 (marker)</b> 为圆点，不表示颜色。</li>    <li>D. `'r'`：表示红色 (red)。</li>  </ul>  *注：问题中出现了两个D选项，第二个D选项为答案所在，但我修改成了B、C、D以符合常规。根据内容，答案是表示标记的'o'*<p>  <strong>正确答案：</strong> C (原题中的第二个 D)</p></details><hr><p><strong>5. 以下哪个参数用于旋转Series绘图的刻度标签（ ）</strong><br>A. <code>rotation</code><br>B. <code>rot</code><br>C. <code>xticks</code><br>D. <code>yticks</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  在 Pandas 的 `.plot()` 方法中，`rot` 参数用于旋转 x 轴的刻度标签。  <ul>    <li>A. `rotation`：这是 Matplotlib 中 `plt.xticks()` 等函数使用的参数名。</li>    <li><b>B. `rot`</b>：这是 Pandas `.plot()` 方法中用于旋转刻度标签的便捷参数。</li>    <li>C, D. `xticks`, `yticks`：用于设置刻度的位置。</li>  </ul><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> matplotlib.pyplot <span class="keyword">as</span> plt</span><br><span class="line"></span><br><span class="line">s = pd.Series(<span class="built_in">range</span>(<span class="number">3</span>), index=[<span class="string">&#x27;long_label_a&#x27;</span>, <span class="string">&#x27;long_label_b&#x27;</span>, <span class="string">&#x27;long_label_c&#x27;</span>])</span><br><span class="line"><span class="comment"># 使用 rot 参数旋转刻度标签</span></span><br><span class="line">s.plot(kind=<span class="string">&#x27;bar&#x27;</span>, rot=<span class="number">45</span>)</span><br><span class="line">plt.show()</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>6. 下面在pandas中用于绘制密度图的是（ ）</strong><br>A. <code>line()</code><br>B. <code>barh()</code><br>C. <code>hist()</code><br>D. <code>density()</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  在 Pandas 的 `.plot` 访问器下：  <ul>    <li>A. `.plot.line()`：绘制线图。</li>    <li>B. `.plot.barh()`：绘制水平柱状图。</li>    <li>C. `.plot.hist()`：绘制直方图。</li>    <li><b>D. `.plot.density()`</b>：绘制核密度估计图 (Kernel Density Estimate, KDE)，即密度图。它也可以通过 `.plot(kind='kde')` 或 `.plot(kind='density')` 实现。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>7. 以下哪种方法用于绘制水平柱状图（ ）</strong><br>A. <code>line</code><br>B. <code>bar</code><br>C. <code>barh</code><br>D. <code>hist</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  在 Pandas 的 `.plot` 访问器下，或者通过 `.plot(kind=...)` 参数：  <ul>    <li>`line`：线图</li>    <li>`bar`：垂直柱状图</li>    <li><b>`barh`</b>：<b>水平 (horizontal)</b> 柱状图</li>    <li>`hist`：直方图</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>8. 以下哪种方法绘制的是直方图（ ）</strong><br>A. <code>scatter</code><br>B. <code>line</code><br>C. <code>density</code><br>D. <code>hist</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  在 Pandas 的 `.plot` 访问器下，或者通过 `.plot(kind=...)` 参数：  <ul>    <li>`scatter`：散点图</li>    <li>`line`：线图</li>    <li>`density`：密度图</li>    <li><b>`hist`</b>：<b>直方图 (histogram)</b></li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>9. <code>df=pd.DataFrame(np.random.rand(6,4),index=[&#39;one&#39;,&#39;two&#39;,...],columns=[&#39;A&#39;,&#39;B&#39;,&#39;C&#39;,&#39;D&#39;])</code>，代码<code>df.plot.bar(alpha=0.5, stacked=True)</code>的结果为（ ）</strong></p><p>A. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/23.png" alt="这里填写图片1的描述"><br>B. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/24.png" alt="这里填写图片1的描述"><br>C. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/25.png" alt="这里填写图片1的描述"><br>D. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/26.png" alt="这里填写图片1的描述"></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`df.plot.bar(...)`</b>：表示绘制垂直柱状图。      <ul>        <li>默认情况下，DataFrame 的<b>行索引</b> (`'one'`, `'two'`, ...) 会成为 x 轴上的刻度标签。</li>        <li>DataFrame 的每一<b>列</b> (`'A'`, `'B'`, `'C'`, `'D'`) 会成为一组数据，在图例中显示。</li>      </ul>    </li>    <li><b>`stacked=True`</b>：表示绘制<b>堆积</b>柱状图，即将每个索引（如 `'one'`）对应的多列数据（`A`, `B`, `C`, `D` 的值）堆叠在同一个柱子上，而不是并列放置。</li>    <li><b>`alpha=0.5`</b>：表示设置图形的透明度为 0.5。</li>  </ul>  <p>综合分析：结果应该是一个<b>堆积柱状图</b>，其 <b>x 轴</b>是 DataFrame 的行索引 (`'one'`, `'two'`, ...)，<b>图例</b>是 DataFrame 的列名 (`'A'`, `'B'`, ...)。</p>  <p>选项 C 的图片完全符合这个描述。</p><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"><span class="keyword">import</span> matplotlib.pyplot <span class="keyword">as</span> plt</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建一个与题目类似的 DataFrame</span></span><br><span class="line">df = pd.DataFrame(np.random.rand(<span class="number">6</span>, <span class="number">4</span>),</span><br><span class="line">                  index=[<span class="string">&#x27;one&#x27;</span>, <span class="string">&#x27;two&#x27;</span>, <span class="string">&#x27;three&#x27;</span>, <span class="string">&#x27;four&#x27;</span>, <span class="string">&#x27;five&#x27;</span>, <span class="string">&#x27;six&#x27;</span>],</span><br><span class="line">                  columns=[<span class="string">&#x27;A&#x27;</span>, <span class="string">&#x27;B&#x27;</span>, <span class="string">&#x27;C&#x27;</span>, <span class="string">&#x27;D&#x27;</span>])</span><br><span class="line"></span><br><span class="line"><span class="comment"># 绘制堆积柱状图</span></span><br><span class="line">df.plot.bar(stacked=<span class="literal">True</span>, alpha=<span class="number">0.5</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 显示图像</span></span><br><span class="line">plt.show()</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>10. seaborn中的哪个函数可以绘制散点图（ ）</strong><br>A. <code>distplot</code><br>B. <code>regplot</code><br>C. <code>barplot</code><br>D. <code>pairplot</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `distplot`：绘制直方图和密度图（在新版中已弃用，推荐 `histplot` 和 `displot`）。</li>    <li><b>B. `regplot`</b>：绘制<b>散点图</b>并拟合一条<b>回归线</b>。它核心是散点图。`scatterplot` 也是专门绘制散点图的函数。</li>    <li>C. `barplot`：绘制条形图（柱状图）。</li>    <li>D. `pairplot`：绘制变量间的成对关系图，其对角线是每个变量的分布图，非对角线是<b>散点图</b>。</li>  </ul>  B 和 D 都可以绘制散点图，但 B 是更直接的散点图（带回归）函数。<p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>11. 以下哪个函数用于为每条线生成一个区分的图例（ ）</strong><br>A. <code>plt.plot</code><br>B. <code>plt.legend</code><br>C. <code>plt.figure</code><br>D. <code>plt.subplots</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `plt.plot`：用于绘图，可以通过 `label` 参数为线条指定名称。</li>    <li><b>B. `plt.legend`</b>：专门用于<b>显示图例 (legend)</b>。它会收集所有带有 `label` 的绘图元素，并生成一个图例框。</li>    <li>C. `plt.figure`：创建新的图形窗口。</li>    <li>D. `plt.subplots`：创建包含子图的图形窗口。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>12. 对于seaborn，以下说法错误的是（ ）</strong><br>A. seaborn可以提高matplotlib图表的可读性和美观性<br>B. seaborn中的绘图函数使用一个data参数来传入数据<br>C. seaborn中的distplot用于绘制直方图和连续密度估计<br>D. seaborn不适用与在绘图前需要聚合或汇总的数据</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确。Seaborn 是基于 Matplotlib 的高级封装，提供了更美观的默认样式。</li>    <li>B: 正确。Seaborn 的一个核心特性是面向数据集，通常通过 `data` 参数传入 DataFrame，再通过字符串指定 x, y 轴对应的列。</li>    <li>C: 正确。`distplot`（在新版中推荐 `histplot`）可以同时展示直方图和 KDE 曲线。</li>    <li>D: <b>错误</b>。Seaborn 的许多函数，如 `barplot` 和 `countplot`，内部就包含了<b>聚合</b>操作。例如，`barplot` 默认会计算每个类别的均值。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>13. 关于Series和DataFrame的plot方法的参数，以下说法错误的是（ ）</strong><br>A. <code>alpha</code>用于传入绘图所用的子图对象<br>B. <code>sort_columns</code>用于将各列按字母顺序绘制<br>C. <code>legend</code>用于生成子图图例<br>D. <code>xlim</code>，<code>ylim</code>分别用于设置x轴范围和y轴范围</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A: 错误</b>。`alpha` 参数用于设置图形的<b>透明度</b>（取值 0 到 1）。用于传入子图对象的参数是 <b>`ax`</b>。</li>    <li>B: 正确。`sort_columns` 用于对列进行排序后再绘图。</li>    <li>C: 正确。`legend` 用于控制是否显示图例。</li>    <li>D: 正确。`xlim` 和 `ylim` 用于设置 x 轴和 y 轴的显示范围。</li>  </ul><p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>14. 以下代码的输出结果为（ ）</strong><br><code>fig, axes = plt.subplots(2,2); plt.plot([1,2,3,4,5])</code></p><p>A. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/27.jpg" alt="这里填写图片1的描述"><br>B. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/28.jpg" alt="这里填写图片1的描述"><br>C. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/29.jpg" alt="这里填写图片1的描述"><br>D. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/30.jpg" alt="这里填写图片1的描述"></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`fig, axes = plt.subplots(2,2)`</b>：创建了一个 2x2 的子图网格，共 4 个子图。`axes` 是一个包含这 4 个子图对象的 NumPy 数组。</li>    <li><b>`plt.plot(...)`</b>：当使用 `plt.` 接口（状态机接口）绘图时，它会自动在<b>当前活动</b>的子图上绘制。在 `subplots` 创建后，默认的活动子图是<b>最后一个</b>，即右下角的子图 `axes[1, 1]`。</li>  </ol>  因此，结果会是一个 2x2 的空网格，只有右下角的子图上绘制了一条线。选项 A 符合描述。<p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>15. 若要在散点图中比较直观地展示点的密集程度，最好改变下列哪一个值？（ ）</strong><br>A. <code>alpha</code><br>B. <code>style</code><br>C. <code>kind</code><br>D. <code>logy</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  当散点图中的点大量重叠时，很难看出点的密集区域。  <ul>    <li><b>A. `alpha`</b>：设置点的<b>透明度</b>。将透明度调低（如 `alpha=0.1`）后，点重叠的区域颜色会更深，从而能非常直观地展示出点的密集程度。</li>    <li>B. `style`：用于设置线型和标记样式，对散点图的点密集程度展示作用不大。</li>    <li>C. `kind`：用于指定绘图类型，不是散点图的参数。</li>    <li>D. `logy`：对 y 轴使用对数刻度，用于处理数值范围跨度大的数据，与点密集程度展示关系不大。</li>  </ul><p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>16. 下列代码的①②③处应该填入下列代码中的哪几个，才能得到下图（ ）</strong></p><p><img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/31.jpg" alt="这里填写图片1的描述"></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"><span class="keyword">import</span> matplotlib.pyplot <span class="keyword">as</span> plt</span><br><span class="line">a = np.arange(<span class="number">10</span>)</span><br><span class="line">plt.plot(a, a*<span class="number">1.5</span>, ①, </span><br><span class="line">         a, a*<span class="number">2.5</span>, ②, </span><br><span class="line">         a, a*<span class="number">3.5</span>, ③)</span><br><span class="line">plt.show()</span><br></pre></td></tr></table></figure><p>A. <code>&#39;r:x&#39;</code>, <code>&#39;r--x&#39;</code>, <code>&#39;r-.x&#39;</code><br>B. <code>&#39;r:x&#39;</code>, <code>&#39;r-.x&#39;</code>, <code>&#39;r--x&#39;</code><br>C. <code>&#39;r-.x&#39;</code>, <code>&#39;r--x&#39;</code>, <code>&#39;r:x&#39;</code><br>D. <code>&#39;r-.x&#39;</code>, <code>&#39;r:x&#39;</code>, <code>&#39;r--x&#39;</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <p>我们需要将图中的三条线与代码中的三组数据和格式字符串一一对应。所有线条都是红色(`r`)且带 `x` 标记，区别在于线型。</p>  <ol>    <li><b>第一条线 (最下面)</b>：对应数据 `a, a*1.5`。从图中看，这是一条<b>点线 (dotted)</b>。对应的格式字符串是 <b>`:`</b>。所以 ① 应该是 <b>`'r:x'`</b>。</li>    <li><b>第二条线 (中间)</b>：对应数据 `a, a*2.5`。从图中看，这是一条<b>点划线 (dash-dot)</b>。对应的格式字符串是 <b>`-.`</b>。所以 ② 应该是 <b>`'r-.x'`</b>。</li>    <li><b>第三条线 (最上面)</b>：对应数据 `a, a*3.5`。从图中看，这是一条<b>虚线 (dashed)</b>。对应的格式字符串是 <b>`--`</b>。所以 ③ 应该是 <b>`'r--x'`</b>。</li>  </ol>  <p>将这三个格式字符串按顺序组合，得到 `('r:x', 'r-.x', 'r--x')`，这与选项 B 完全匹配。</p><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"><span class="keyword">import</span> matplotlib.pyplot <span class="keyword">as</span> plt</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建数据</span></span><br><span class="line">a = np.arange(<span class="number">10</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 使用正确的格式字符串绘制三条线</span></span><br><span class="line">plt.plot(a, a*<span class="number">1.5</span>, <span class="string">&#x27;r:x&#x27;</span>,    <span class="comment"># 点线</span></span><br><span class="line">         a, a*<span class="number">2.5</span>, <span class="string">&#x27;r-.x&#x27;</span>,   <span class="comment"># 点划线</span></span><br><span class="line">         a, a*<span class="number">3.5</span>, <span class="string">&#x27;r--x&#x27;</span>)   <span class="comment"># 虚线</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 显示图像</span></span><br><span class="line">plt.show()</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>17. 下列format_string，不能表示绿色虚线的是（ ）</strong><br>A. <code>&#39;g:&#39;</code><br>B. <code>&#39;g-.&#39;</code><br>C. <code>&#39;g..&#39;</code><br>D. <code>&#39;g--&#39;</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `'g'` 表示绿色。虚线可以用 `:`(点线), `-.'`(点划线), `--`(虚线) 表示。  <ul>    <li>A. `'g:'`：绿色点线。</li>    <li>B. `'g-.'`：绿色点划线。</li>    <li>C. `'g..'`：`..` 不是 Matplotlib 标准的线型格式字符串。无效。</li>    <li>D. `'g--'`：绿色虚线。</li>  </ul>  因此，C 不能表示绿色虚线。<p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>18. 对于DataFrame对象<code>df</code>，<code>df.plot()</code>与下列哪条语句是等价的。（ ）</strong><br>A. <code>df.bar()</code><br>B. <code>df.plot().line()</code><br>C. <code>df.line()</code><br>D. <code>df.plot.line()</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  Pandas 的 `.plot()` 方法，当不指定 `kind` 参数时，默认绘制的是<b>线图 (line plot)</b>。  <ul>    <li>A: `df.bar()` 是错误的语法，应为 `df.plot.bar()`。</li>    <li>B: `df.plot()` 返回一个 Axes 对象，该对象没有 `.line()` 方法。</li>    <li>C: `df.line()` 不是标准的 Pandas 绘图方法。</li>    <li><b>D. `df.plot.line()`</b>：这是通过 `.plot` 访问器明确调用线图绘制的方法，其效果与默认的 `df.plot()` 完全相同。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>19. plot中可以使用哪个函数作柱状图（ ）</strong><br>A. <code>Bar()</code><br>B. <code>barh()</code><br>C. <code>hist()</code><br>D. <code>Barh</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  在 Pandas 的 `.plot` 访问器中：  <ul>    <li>A, D: `Bar()` 和 `Barh` 不是函数名，正确的应为小写。</li>    <li><b>B. `barh()`</b>：绘制水平柱状图。`bar()` 绘制垂直柱状图。两者都是绘制柱状图的函数。</li>    <li>C. `hist()`：绘制直方图，用于表示数值分布，与柱状图（表示类别数量或大小）不同。</li>  </ul>  选项 B 是一个有效的绘制柱状图的函数。<p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>20. 运行下列代码，得到的可视化结果为（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;A&#x27;</span>:[<span class="number">34</span>,<span class="number">12</span>,<span class="number">52</span>], <span class="string">&#x27;B&#x27;</span>:[<span class="number">87</span>,<span class="number">123</span>,<span class="number">23</span>], <span class="string">&#x27;C&#x27;</span>:[<span class="number">15</span>,<span class="number">19</span>,<span class="number">64</span>]&#125;,</span><br><span class="line">                  index=[<span class="string">&#x27;one&#x27;</span>,<span class="string">&#x27;two&#x27;</span>,<span class="string">&#x27;three&#x27;</span>])</span><br><span class="line">df.plot.bar()</span><br></pre></td></tr></table></figure><p>A. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/32.png" alt="这里填写图片1的描述"><br>B. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/33.png" alt="这里填写图片1的描述"><br>C. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/34.png" alt="这里填写图片1的描述"><br>D. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/35.png" alt="这里填写图片1的描述"></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`df.plot.bar()`</b>：该方法用于创建一个<b>垂直柱状图</b>。</li>    <li><b>数据映射</b>：      <ul>        <li>DataFrame 的<b>行索引</b> (`'one'`, `'two'`, `'three'`) 会成为 x 轴上的刻度标签。</li>        <li>DataFrame 的每一<b>列</b> (`'A'`, `'B'`, `'C'`) 会成为一组并列的柱子，并在图例中显示。</li>      </ul>    </li>    <li><b>结果分析</b>：对于 x 轴上的每个刻度（如 `'one'`），都会有三根并列的柱子，分别代表该行在 'A', 'B', 'C' 列的值。这种并列的形式被称为<b>分组柱状图</b>。</li>  </ul>  <p>选项 A 的图片展示了以 `'one'`, `'two'`, `'three'` 为 x 轴，'A', 'B', 'C' 为分组的垂直柱状图，完全符合代码的执行结果。</p><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> matplotlib.pyplot <span class="keyword">as</span> plt</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 DataFrame</span></span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;A&#x27;</span>:[<span class="number">34</span>,<span class="number">12</span>,<span class="number">52</span>], <span class="string">&#x27;B&#x27;</span>:[<span class="number">87</span>,<span class="number">123</span>,<span class="number">23</span>], <span class="string">&#x27;C&#x27;</span>:[<span class="number">15</span>,<span class="number">19</span>,<span class="number">64</span>]&#125;,</span><br><span class="line">                  index=[<span class="string">&#x27;one&#x27;</span>,<span class="string">&#x27;two&#x27;</span>,<span class="string">&#x27;three&#x27;</span>])</span><br><span class="line"></span><br><span class="line"><span class="comment"># 绘制分组垂直柱状图</span></span><br><span class="line">df.plot.bar()</span><br><span class="line"></span><br><span class="line"><span class="comment"># 显示图像</span></span><br><span class="line">plt.tight_layout() <span class="comment"># 调整布局以防标签重叠</span></span><br><span class="line">plt.show()</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>21. 运行下列代码，输出的结果为（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> matplotlib.pyplot <span class="keyword">as</span> plt</span><br><span class="line"></span><br><span class="line">fig, axes = plt.subplots(<span class="number">1</span>, <span class="number">2</span>)</span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;A&#x27;</span>:[<span class="number">34</span>, <span class="number">12</span>, <span class="number">52</span>], <span class="string">&#x27;B&#x27;</span>:[<span class="number">87</span>, <span class="number">123</span>, <span class="number">23</span>], <span class="string">&#x27;C&#x27;</span>:[<span class="number">15</span>, <span class="number">19</span>, <span class="number">64</span>]&#125;,</span><br><span class="line">                  index=[<span class="string">&#x27;one&#x27;</span>, <span class="string">&#x27;two&#x27;</span>, <span class="string">&#x27;three&#x27;</span>])</span><br><span class="line">df.plot()</span><br></pre></td></tr></table></figure><p>A. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/36.png" alt="这里填写图片1的描述"><br>B. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/37.png" alt="这里填写图片1的描述"><br>C. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/38.png" alt="这里填写图片1的描述"><br>D. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/39.png" alt="这里填写图片1的描述"></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b><code>fig, axes = plt.subplots(1, 2)</code></b>：这行代码创建了一个包含1行2列（共2个）子图的图形窗口。<code>axes</code> 是一个包含这两个子图对象的数组。</li>    <li><b>当前活动子图</b>：在 <code>plt.subplots</code> 执行后，Matplotlib 的“当前活动”子图（pyplot 接口会在此绘图）默认是<b>最后一个</b>被创建的子图，也就是右边的 <code>axes[1]</code>。</li>    <li><b><code>df.plot()</code></b>：这是 Pandas 的绘图方法。当不通过 <code>ax</code> 参数明确指定绘图位置时，它会自动在当前的活动子图上进行绘制。</li>    <li><b>结论</b>：因此，<code>df</code> 的线图会被绘制在右边的子图上，而左边的子图则保持为空白。这与选项 B 的图片完全一致。</li>  </ol><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> matplotlib.pyplot <span class="keyword">as</span> plt</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建一个 1x2 的子图网格</span></span><br><span class="line">fig, axes = plt.subplots(<span class="number">1</span>, <span class="number">2</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建 DataFrame</span></span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;A&#x27;</span>:[<span class="number">34</span>, <span class="number">12</span>, <span class="number">52</span>], <span class="string">&#x27;B&#x27;</span>:[<span class="number">87</span>, <span class="number">123</span>, <span class="number">23</span>], <span class="string">&#x27;C&#x27;</span>:[<span class="number">15</span>, <span class="number">19</span>, <span class="number">64</span>]&#125;,</span><br><span class="line">                  index=[<span class="string">&#x27;one&#x27;</span>, <span class="string">&#x27;two&#x27;</span>, <span class="string">&#x27;three&#x27;</span>])</span><br><span class="line"></span><br><span class="line"><span class="comment"># 在当前活动的子图（默认是右边的 axes[1]）上绘图</span></span><br><span class="line">df.plot()</span><br><span class="line"></span><br><span class="line"><span class="comment"># 显示图像</span></span><br><span class="line">plt.show()</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>22. 通过<code>fig,axes=plt.subplots(2,2)</code>生成的子图，不可以通过以下方式调用：</strong><br>A. <code>axes[1]</code><br>B. <code>axes[0,0]</code><br>C. <code>fig[0,0]</code><br>D. <code>fig.axes[0]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>`fig, axes = plt.subplots(2,2)` 中，`axes` 是一个 2x2 的 NumPy 数组，包含了 4 个子图 (Axes) 对象。</li>    <li>A: `axes[1]` 可以访问第二行（可以得到 `[axes[1,0], axes[1,1]]`）。有效。</li>    <li>B: `axes[0,0]` 可以访问第一行第一列的子图。有效。</li>    <li><b>C: `fig[0,0]`</b>：<b>错误</b>。`fig` 是 Figure 对象，它不支持像 NumPy 数组那样的二维索引来访问子图。</li>    <li>D: `fig.axes` 是一个包含了 Figure 中所有子图对象的列表。`fig.axes[0]` 可以访问第一个子图。有效。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>23. 下列关于可视化的说法，错误的是（ ）</strong><br>A. <code>plt.legend</code>用于为每一条线生成一个区分的图例<br>B. <code>plt.savefig</code>方法可以将图片写入到所有的文件型对象中<br>C. 默认情况下，Series和DataFrame的<code>plot()</code>方法绘制的是条形图<br>D. <code>seaborn</code>中的绘图函数使用<code>data</code>参数来传入数据</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确。</li>    <li>B: 正确。`savefig` 可以接收文件路径，也可以接收一个文件类对象（如 `io.BytesIO`）。</li>    <li>C: <b>错误</b>。`plot()` 方法默认绘制的是<b>线图 (line plot)</b>，不是条形图。</li>    <li>D: 正确。这是 Seaborn 的一个核心特性。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>24. 下列说法错误的是（ ）</strong><br>A. 使用jupyter notebook画复杂图表必须将绘图命令放在单个单元格里<br>B. matplotlib会自动检查标签是否重叠<br>C. Series.plot.grid方法展示轴网络默认是打开的<br>D. Series和DataFrame的索引可以用来绘制轴刻度</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确。为了保证所有命令作用于同一个 Figure/Axes 对象，通常需要将它们放在一个单元格中执行。</li>    <li>B: 错误。Matplotlib 默认<b>不会</b>自动检查和调整重叠的标签，有时需要手动调整（如旋转或使用 `tight_layout`）。</li>    <li>C: 错误。`.plot.grid()` 方法默认 `visible=None`，其行为取决于配置，但通常需要明确设置为 `True` 才能显示网格。</li>    <li>D: 正确。Pandas 绘图时，默认使用索引作为 x 轴（对于 Series）或刻度（对于 DataFrame）。</li>  </ul>  选项 B 和 C 都错误，但 B 描述的是一个更普遍和基础的 Matplotlib 行为。<p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>25. 下面说法正确的是：（ ）</strong><br>A. <code>ax1=fig.add_subplot(2,2,0)</code>是可以运行的<br>B. 绘制图形时，其中使用到的alpha参数用于调节图像透明的<br>C. <code>plot.bar()</code>和<code>plot.barh()</code>函数分别用于绘制水平的和垂直的柱状图</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 错误。`add_subplot(nrows, ncols, index)` 中的 `index` 是从 <b>1</b> 开始计数的，所以 `add_subplot(2,2,0)` 会报错。</li>    <li><b>B: 正确</b>。`alpha` 参数用于设置图形的透明度，取值范围为 0 (完全透明)到 1 (完全不透明)。</li>    <li>C: 错误。`plot.bar()` 绘制<b>垂直</b>柱状图，`plot.barh()` 绘制<b>水平</b>柱状图。描述正好相反。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>26. 下面哪一条语句可以为DataFrame生成堆积柱状图？( )</strong><br>A. <code>df.plot.bar(stacked=True, alpha=0.5)</code><br>B. <code>df.plot.bar(stack=True, alpha=0.5)</code><br>C. <code>df.plot.bar(stacked=False, alpha=0.5)</code><br>D. <code>df.plot.bar(stack=False, alpha=0.5)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  在 Pandas 的 `.plot.bar()` 方法中，用于生成堆积柱状图的参数是 `stacked`，并且需要将其值设置为 `True`。  <ul>    <li><b>A: `stacked=True` 是正确的参数和值。</b></li>    <li>B: `stack=True` 是错误的参数名。</li>    <li>C, D: `stacked/stack=False` 表示不使用堆积，绘制并列柱状图。</li>  </ul><p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>27. 下哪个说法是正确的？（ ）</strong><br>A. <code>add()</code>方法可以往图表中添加图形<br>B. 如果想取消图例中的元素，可以选择不要传入<code>label</code>参数或传入<code>label = &#39;_nolegend&#39;</code><br>C. 注释只可以用于添加文本<br>D. 只能将绘制的图片保存为格式为.svg的文件</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 错误。没有通用的 `add()` 方法，添加图形是 `add_patch()`，添加子图是 `add_subplot()` 等。</li>    <li><b>B: 正确</b>。`plt.legend()` 只会为设置了 `label` 参数的绘图元素生成图例项。将 `label` 设置为以下划线开头的字符串（如 `_nolegend`）是 Matplotlib 中一个约定俗成的、用于在图例中隐藏该元素的方法。</li>    <li>C: 错误。注释 (`annotate`) 不仅可以添加文本，还可以添加箭头等指向性图形。</li>    <li>D: 错误。`savefig` 支持多种格式，如 `.png`, `.jpg`, `.pdf`, `.svg` 等。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>28. 以下哪条执行语句输出结果和<code>plt.plot(np.random.randn(30).cumsum(), &#39;ko--&#39;)</code>不同。( )</strong><br>A. <code>plt.plot(np.random.randn(30).cumsum(), color=&#39;k&#39;, linestyle=&#39;dashed&#39;, marker=&#39;o&#39;)</code><br>B. <code>plt.plot(np.random.randn(30).cumsum(), color=&#39;k&#39;, &#39;--o&#39;)</code><br>C. <code>plt.plot(np.random.randn(30).cumsum(), &#39;ok--&#39;)</code><br>D. <code>plt.plot(np.random.randn(30).cumsum(), &#39;o--k&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>`'ko--'` 表示：颜色黑 (`k`)，标记圆点 (`o`)，线型虚线 (`--`)。</li>    <li>A: `color='k'`, `linestyle='dashed'` (`--`), `marker='o'`。与 `'ko--'` <b>等价</b>。</li>    <li>B: `color='k'`, `'--o'`。`'--o'` 是一个格式字符串，表示虚线+圆点标记。与 `'ko--'` <b>等价</b>。</li>    <li>C: `'ok--'`。格式字符串中，颜色、标记、线型的顺序可以任意调换。与 `'ko--'` <b>等价</b>。</li>    <li>D: `'o--k'`。与 `'ko--'` <b>等价</b>。</li>  </ul>  *此题所有选项都与`'ko--'`等价，可能存在设计错误。但根据您提供的答案是B，我将假设`color`关键字参数与格式字符串不能混合使用，这在某些旧版本或特定情况下可能导致解析问题。但在现代Matplotlib中，这种混合是允许的。*<p>  <strong>正确答案：</strong> B (基于题目可能存在的特定解析规则)</p></details><h2 id="第十章：高级数据分析技术"><a href="#第十章：高级数据分析技术" class="headerlink" title="第十章：高级数据分析技术"></a>第十章：高级数据分析技术</h2><p><strong>1. 以下不可以作为<code>Groupby</code>的参数的（ ）</strong><br>A. 函数<br>B. 字典<br>C. Series<br>D. 具体的值</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `groupby()` 方法的 `by` 参数非常灵活，可以接受多种类型的输入来定义分组键：  <ul>    <li>A. <b>函数</b>：可以传入一个函数，它会对每个索引标签调用，返回值将用作分组键。</li>    <li>B. <b>字典</b>或 C. <b>Series</b>：可以传入一个字典或 Series，其键或索引对应于被分组对象的索引，值用作分组键。</li>    <li><b>D. 具体的值</b>：不能直接传入一个具体的值（如整数 `5` 或字符串 `'a'`）作为分组依据，因为这无法为每一行/列提供一个明确的分组键。必须是与被分组轴长度相同的序列（如列表、数组）、列名、函数或字典/Series。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>2. <code>groupby</code>没有以下哪个方法？（ ）</strong><br>A. <code>count()</code><br>B. <code>peak_to_peak</code><br>C. <code>prod()</code><br>D. <code>std()</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  GroupBy 对象有一系列内置的聚合方法。  <ul>    <li>A. `count()`：计算每个分组的非 `NaN` 值的数量。存在。</li>    <li><b>B. `peak_to_peak`</b>：`ptp` (peak-to-peak) 是 NumPy 数组的方法，用于计算最大值和最小值之差。GroupBy 对象本身没有直接的 `.peak_to_peak` 方法，但可以通过 `.agg(np.ptp)` 来应用。</li>    <li>C. `prod()`：计算每个分组的乘积。存在。</li>    <li>D. `std()`：计算每个分组的标准差。存在。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>3. 下列可以用于DataFrame中分组的是（ ）</strong><br>① DataFrame中的一个或者一组列<br>② 字典或者Series<br>③ 函数<br>④ 索引级别</p><p>A. ①<br>B. ①②<br>C. ①②③<br>D. ①②③④</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `DataFrame.groupby()` 的 `by` 参数支持所有这些方式：  <ul>    <li>① <b>列名</b>：最常见的方式，如 `df.groupby('col_A')` 或 `df.groupby(['col_A', 'col_B'])`。</li>    <li>② <b>字典或Series</b>：可以提供一个映射关系，将索引映射到分组键。</li>    <li>③ <b>函数</b>：可以传入一个函数，它会作用于索引，返回值作为分组键。</li>    <li>④ <b>索引级别</b>：对于多重索引 (MultiIndex)，可以通过层级名称或编号进行分组，如 `df.groupby(level='level_name')`。</li>  </ul>  因此，所有四种方式都可以用于分组。<p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>4. <code>pivot_table</code>的默认聚合类型是（ ）</strong><br>A. 分组平均值<br>B. 各个分组的中位数<br>C. 各个分组的方差<br>D. 各个分组的值的和</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `pd.pivot_table()` 函数用于创建数据透视表。其 `aggfunc` 参数决定了聚合的类型。当不指定 `aggfunc` 时，其默认值是 `'mean'`，即计算<b>分组平均值</b>。<p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&quot;A&quot;</span>: [<span class="string">&quot;foo&quot;</span>, <span class="string">&quot;foo&quot;</span>, <span class="string">&quot;bar&quot;</span>],</span><br><span class="line">                   <span class="string">&quot;B&quot;</span>: [<span class="string">&quot;one&quot;</span>, <span class="string">&quot;one&quot;</span>, <span class="string">&quot;two&quot;</span>],</span><br><span class="line">                   <span class="string">&quot;C&quot;</span>: [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]&#125;)</span><br><span class="line"><span class="comment"># 默认计算 C 列的平均值</span></span><br><span class="line">pivot = pd.pivot_table(df, values=<span class="string">&#x27;C&#x27;</span>, index=<span class="string">&#x27;A&#x27;</span>, columns=<span class="string">&#x27;B&#x27;</span>)</span><br><span class="line"><span class="built_in">print</span>(pivot)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>5. 下面方法可以计算分组中的非NA值的乘积的是（ ）</strong><br>A. <code>std</code><br>B. <code>count</code><br>C. <code>prod</code><br>D. <code>median</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  GroupBy 对象的内置聚合方法：  <ul>    <li>A. `std`：标准差。</li>    <li>B. `count`：计数。</li>    <li><b>C. `prod`</b>：<b>乘积 (product)</b>。</li>    <li>D. `median`：中位数。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>6. <code>groupby</code>没有以下哪个方法？（ ）</strong><br>A. <code>count()</code><br>B. <code>std()</code><br>C. <code>prod()</code><br>D. <code>get_max()</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  GroupBy 对象有一系列内置的聚合方法。  <ul>    <li>A. `count()`：存在。</li>    <li>B. `std()`：存在。</li>    <li>C. `prod()`：存在。</li>    <li><b>D. `get_max()`</b>：不存在。获取最大值的方法是 <b>`max()`</b>。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>7. 下列对于分组与聚合的叙述，正确的是（ ）</strong><br>A. 只能用一个键对数据进行分组。<br>B. 分组键可以是正确长度的任何数组。<br>C. 默认情况下，一个DataFrame中所有的列都可以聚合。<br>D. <code>mean</code>方法可以计算GroupBy对象中各个分组中所有数值的均值。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 错误。可以用一个或多个键（列表）进行分组。</li>    <li><b>B: 正确</b>。只要数组的长度与被分组的轴的长度相同，它就可以作为分组键。</li>    <li>C: 错误。只有<b>数值型</b>的列才能进行聚合计算（如 `mean`, `sum` 等）。非数值列会被自动排除。</li>    <li>D: 错误。`mean()` 方法计算的是每个分组内<b>每一列</b>的均值，而不是所有数值的整体均值。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>8. 假设<code>df = ...</code>，以下哪条语句可以根据<code>key1</code>标签计算<code>data1</code>列的均值。（ ）</strong><br>A. <code>df[&#39;data1&#39;].mean()</code><br>B. <code>df[&#39;data1&#39;].groupby(df[&#39;key1&#39;]).mean()</code><br>C. <code>df[&#39;data1&#39;].groupby(&#39;key1&#39;).mean()</code><br>D. <code>df[&#39;data1&#39;].median()</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  目标是先按 `'key1'` 分组，然后只对 `'data1'` 列计算均值。  <ul>    <li>A: 计算了整列 `'data1'` 的均值，没有分组。</li>    <li><b>B: `df['data1'].groupby(df['key1']).mean()`</b>：这是一个标准且正确的<b>“Series GroupBy”</b>操作。先选择了 `'data1'` 这一列 (一个 Series)，然后用 `'key1'` 列 (另一个 Series) 作为分组键对其进行分组，最后计算均值。</li>    <li>C: 错误。当对一个 Series (`df['data1']`) 使用 `.groupby()` 时，不能再用一个字符串列名作为分组键，必须提供一个与该 Series 等长的数组、列表或另一个 Series。</li>    <li>D: 计算了整列的中位数，没有分组。</li>  </ul>  另一种等价的写法是 `df.groupby('key1')['data1'].mean()`。<p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>9. 关于<code>agg</code>方法，以下说法错误的是（ ）</strong><br>A. <code>agg</code>方法不能实现将不同的函数应用到不同的列<br>B. <code>agg</code>方法可以传入包含多个函数的列表<br>C. 通过向<code>agg</code>方法传入(name,function)元组的列表来实现对结果列名的修改<br>D. <code>agg</code>方法可以传入自定义函数</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A: 错误</b>。`agg` 方法的一个强大功能就是可以通过传入一个<b>字典</b>，实现将不同的函数应用到不同的列上。例如 `grouped.agg({'col_A': 'mean', 'col_B': 'sum'})`。</li>    <li>B: 正确。传入函数列表会把所有函数应用到所有适用的列上。</li>    <li>C: 正确。传入 `[('new_name', func)]` 这样的元组列表，可以自定义结果的列名。</li>    <li>D: 正确。`agg` 可以接受任何能处理 Series 的自定义函数。</li>  </ul><p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>10. 关于<code>pivot_table</code>的选项，以下说法错误的是（ ）</strong><br>A. <code>pivot_table</code>默认的聚合类型为平均值<br>B. <code>dropna</code>选项用于在结果表中替换缺失值的值<br>C. <code>pivot_table</code>默认情况下聚合所有数值型的列<br>D. <code>margins</code>用于添加行&#x2F;列小计和总计</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确。`aggfunc` 参数默认为 `'mean'`。</li>    <li><b>B: 错误</b>。用于替换缺失值的参数是 <b>`fill_value`</b>。`dropna` 参数是 DataFrame 的一个方法，用于删除缺失值，而不是 `pivot_table` 的一个选项。</li>    <li>C: 正确。如果不指定 `values` 参数，`pivot_table` 会对所有可聚合的数值列进行聚合。</li>    <li>D: 正确。`margins=True` 会添加总计行和列。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>11. 假设有DataFrame对象<code>df</code>，<code>key1</code>是<code>df</code>中的列，下列代码不可以运行的是（ ）</strong><br>A. <code>means = df[&#39;data1&#39;].groupby(df).mean()</code><br>B. <code>grouped = df.groupby(df.dtypes, axis=1)</code><br>C. <code>df.groupby([&#39;key1&#39;]).mean()</code><br>D. <code>pieces = dict(list(df.groupby(&#39;key1&#39;)))</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>A: 错误</b>。`.groupby(df)` 尝试用整个 DataFrame `df` 作为分组键。DataFrame 对象是不可哈希的 (unhashable)，不能作为分组键使用，这会引发 `TypeError`。</li>    <li>B: 有效。`df.dtypes` 返回一个 Series，其索引是列名，值是数据类型。`axis=1` 表示按列分组，可以用 `df.dtypes` 这个 Series 将列按其数据类型进行分组。</li>    <li>C: 有效。按 `'key1'` 列的值进行分组，并计算均值。</li>    <li>D: 有效。GroupBy 对象是可迭代的，可以将其转换为一个元组列表（每个元组是 `(group_name, sub_dataframe)`)，然后再转换为字典。</li>  </ul><p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>12. 已知DataFrame <code>people</code> 和字典 <code>mapping</code>，则代码<code>people.groupby(mapping, axis=1).sum()</code>的输出可能为（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">people = pd.DataFrame(np.random.randn(<span class="number">5</span>, <span class="number">5</span>),</span><br><span class="line">                      columns=[<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;d&#x27;</span>,<span class="string">&#x27;e&#x27;</span>],</span><br><span class="line">                      index=[<span class="string">&#x27;Joe&#x27;</span>,<span class="string">&#x27;Steve&#x27;</span>,<span class="string">&#x27;Wes&#x27;</span>,<span class="string">&#x27;Jim&#x27;</span>,<span class="string">&#x27;Travis&#x27;</span>])</span><br><span class="line">mapping = &#123;<span class="string">&#x27;a&#x27;</span>:<span class="string">&#x27;red&#x27;</span>, <span class="string">&#x27;b&#x27;</span>:<span class="string">&#x27;red&#x27;</span>, <span class="string">&#x27;c&#x27;</span>:<span class="string">&#x27;blue&#x27;</span>,</span><br><span class="line">           <span class="string">&#x27;d&#x27;</span>:<span class="string">&#x27;blue&#x27;</span>, <span class="string">&#x27;e&#x27;</span>:<span class="string">&#x27;red&#x27;</span>, <span class="string">&#x27;f&#x27;</span>:<span class="string">&#x27;orange&#x27;</span>&#125;</span><br></pre></td></tr></table></figure><p>A. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/40.png" alt="这里填写图片1的描述"><br>B. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/41.png" alt="这里填写图片1的描述"><br>C. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/42.png" alt="这里填写图片1的描述"><br>D. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/43.png" alt="这里填写图片1的描述"></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>`people.groupby(mapping, axis=1)`</b>：      <ul>        <li><code>axis=1</code> 表示按<b>列</b>进行分组。</li>        <li><code>mapping</code> 字典提供了列名到分组键的映射关系。</li>        <li>根据 `mapping`：          <ul>            <li>`'a'`, `'b'`, `'e'` 列被映射到分组 <b>`'red'`</b>。</li>            <li>`'c'`, `'d'` 列被映射到分组 <b>`'blue'`</b>。</li>            <li>`'f'` 在 `people` 的列中不存在，所以 `'orange'` 分组不会被创建。</li>          </ul>        </li>      </ul>    </li>    <li><b>`.sum()`</b>：对每个分组内的列进行<b>求和</b>。      <ul>        <li>新的 <b>`'red'`</b> 列的值 = 原 `'a'` 列 + 原 `'b'` 列 + 原 `'e'` 列。</li>        <li>新的 <b>`'blue'`</b> 列的值 = 原 `'c'` 列 + 原 `'d'` 列。</li>      </ul>    </li>    <li><b>最终结果</b>：      <ul>        <li>行索引保持不变 (`'Joe'`, `'Steve'`, ...)。</li>        <li>列索引变为分组键 `'blue'` 和 `'red'`。</li>        <li>由于原始数据是 `np.random.randn()` 生成的浮点数，求和后的结果仍然是浮点数。</li>      </ul>    </li>  </ul>  <p>选项 A 的图片展示了 `blue` 和 `red` 两列，并且其值为浮点数，完全符合代码的执行结果。</p><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 DataFrame 和 mapping</span></span><br><span class="line">people = pd.DataFrame(np.random.randn(<span class="number">5</span>, <span class="number">5</span>),</span><br><span class="line">                      columns=[<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;d&#x27;</span>,<span class="string">&#x27;e&#x27;</span>],</span><br><span class="line">                      index=[<span class="string">&#x27;Joe&#x27;</span>,<span class="string">&#x27;Steve&#x27;</span>,<span class="string">&#x27;Wes&#x27;</span>,<span class="string">&#x27;Jim&#x27;</span>,<span class="string">&#x27;Travis&#x27;</span>])</span><br><span class="line">mapping = &#123;<span class="string">&#x27;a&#x27;</span>:<span class="string">&#x27;red&#x27;</span>, <span class="string">&#x27;b&#x27;</span>:<span class="string">&#x27;red&#x27;</span>, <span class="string">&#x27;c&#x27;</span>:<span class="string">&#x27;blue&#x27;</span>,</span><br><span class="line">           <span class="string">&#x27;d&#x27;</span>:<span class="string">&#x27;blue&#x27;</span>, <span class="string">&#x27;e&#x27;</span>:<span class="string">&#x27;red&#x27;</span>, <span class="string">&#x27;f&#x27;</span>:<span class="string">&#x27;orange&#x27;</span>&#125;</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 DataFrame:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(people)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行 groupby 和 sum 操作</span></span><br><span class="line">result = people.groupby(mapping, axis=<span class="number">1</span>).<span class="built_in">sum</span>()</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n执行分组求和之后的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>13. <code>pandas.crosstab</code>函数计算的是分组中的（ ）</strong><br>A. 累积和<br>B. 算术平均值<br>C. 频率<br>D. 算术中位数</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `pd.crosstab()` (交叉表) 是一个专门用于计算<b>交叉频率表</b>的函数。它会计算两个（或更多）因子（列）的组合出现的<b>频率</b>（计数）。<p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>14. 有数据集<code>tips</code>，列出了其前6行的数据</strong><br><img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/44.png" alt="这里填写图片1的描述"><br><strong>执行<code>grouped=tips.groupby([&#39;day&#39;,&#39;smoker&#39;]); grouped[&#39;tip_pct&#39;,&#39;total_bill&#39;].agg([&#39;count&#39;,&#39;mean&#39;])</code>后得到的输出是（ ）</strong></p><p>A. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/45.png" alt="这里填写图片1的描述"><br>B. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/46.png" alt="这里填写图片1的描述"><br>C. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/47.png" alt="这里填写图片1的描述"><br>D. <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/48.png" alt="这里填写图片1的描述"></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`grouped=tips.groupby(['day','smoker'])`</b>：首先，按 `'day'` 和 `'smoker'` 这两列对 `tips` DataFrame 进行分组，创建了一个 GroupBy 对象 `grouped`。</li>    <li><b>`grouped['tip_pct','total_bill']`</b>：接着，从这个 GroupBy 对象中选择了 `'tip_pct'` 和 `'total_bill'` 这两列，表示后续的聚合操作将只针对这两列进行。</li>    <li><b>`.agg(['count','mean'])`</b>：最后，对选中的两列应用了两个聚合函数：`count` (计算非空值的数量) 和 `mean` (计算均值)。</li>  </ol>  <p><b>结果的结构分析</b>：</p>  <ul>    <li><b>行索引 (Index)</b>：将会是一个双层索引 (MultiIndex)，由分组键 `('day', 'smoker')` 构成。</li>    <li><b>列索引 (Columns)</b>：也将会是一个双层索引。      <ul>        <li><b>外层</b>是应用聚合的原始列名：`'tip_pct'` 和 `'total_bill'`。</li>        <li><b>内层</b>是应用的聚合函数名：`'count'` 和 `'mean'`。</li>      </ul>    </li>  </ul>  <p>将这些组合起来，结果 DataFrame 的列会是 `(tip_pct, count)`, `(tip_pct, mean)`, `(total_bill, count)`, `(total_bill, mean)`。选项 A 的图片结构与此完全匹配。</p>  <p>（注：选项B的图片似乎是 `.agg({'tip_pct': 'count', 'total_bill': 'mean'})` 的结果，选项D的图片是 `.agg(['count', 'mean'])` 但只作用于一列的结果，选项C的图片结构不完整。）</p><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建一个与题目类似的 tips DataFrame</span></span><br><span class="line"><span class="comment"># 实际的 tips 数据集有更多行</span></span><br><span class="line">data = &#123;<span class="string">&#x27;total_bill&#x27;</span>: [<span class="number">16.99</span>, <span class="number">10.34</span>, <span class="number">21.01</span>, <span class="number">23.68</span>, <span class="number">24.59</span>, <span class="number">25.29</span>],</span><br><span class="line">        <span class="string">&#x27;tip&#x27;</span>: [<span class="number">1.01</span>, <span class="number">1.66</span>, <span class="number">3.50</span>, <span class="number">3.31</span>, <span class="number">3.61</span>, <span class="number">4.71</span>],</span><br><span class="line">        <span class="string">&#x27;smoker&#x27;</span>: [<span class="string">&#x27;No&#x27;</span>, <span class="string">&#x27;No&#x27;</span>, <span class="string">&#x27;No&#x27;</span>, <span class="string">&#x27;No&#x27;</span>, <span class="string">&#x27;No&#x27;</span>, <span class="string">&#x27;No&#x27;</span>],</span><br><span class="line">        <span class="string">&#x27;day&#x27;</span>: [<span class="string">&#x27;Sun&#x27;</span>, <span class="string">&#x27;Sun&#x27;</span>, <span class="string">&#x27;Sun&#x27;</span>, <span class="string">&#x27;Sun&#x27;</span>, <span class="string">&#x27;Sun&#x27;</span>, <span class="string">&#x27;Sun&#x27;</span>],</span><br><span class="line">        <span class="string">&#x27;time&#x27;</span>: [<span class="string">&#x27;Dinner&#x27;</span>, <span class="string">&#x27;Dinner&#x27;</span>, <span class="string">&#x27;Dinner&#x27;</span>, <span class="string">&#x27;Dinner&#x27;</span>, <span class="string">&#x27;Dinner&#x27;</span>, <span class="string">&#x27;Dinner&#x27;</span>],</span><br><span class="line">        <span class="string">&#x27;size&#x27;</span>: [<span class="number">2</span>, <span class="number">3</span>, <span class="number">3</span>, <span class="number">2</span>, <span class="number">4</span>, <span class="number">4</span>]&#125;</span><br><span class="line">tips = pd.DataFrame(data)</span><br><span class="line">tips[<span class="string">&#x27;tip_pct&#x27;</span>] = tips[<span class="string">&#x27;tip&#x27;</span>] / tips[<span class="string">&#x27;total_bill&#x27;</span>] <span class="comment"># 创建 tip_pct 列</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行题目中的分组和聚合操作</span></span><br><span class="line">grouped = tips.groupby([<span class="string">&#x27;day&#x27;</span>,<span class="string">&#x27;smoker&#x27;</span>])</span><br><span class="line">result = grouped[<span class="string">&#x27;tip_pct&#x27;</span>,<span class="string">&#x27;total_bill&#x27;</span>].agg([<span class="string">&#x27;count&#x27;</span>,<span class="string">&#x27;mean&#x27;</span>])</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>15. 下面代码的输出结果为：</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">def</span> <span class="title function_">fun</span>(<span class="params">data</span>):</span><br><span class="line">    <span class="keyword">return</span> data.<span class="built_in">max</span>() // <span class="number">2</span></span><br><span class="line">data = pd.DataFrame(...)</span><br><span class="line">data.groupby(<span class="string">&#x27;key&#x27;</span>).agg(fun).<span class="built_in">max</span>().mean()</span><br></pre></td></tr></table></figure><p>A. 0.5<br>B. 1<br>C. 1.5<br>D. 2</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`data.groupby('key').agg(fun)`</b>：      <ul>        <li>分组 'a': `data1` 的 max 是 2，`fun` 返回 `2 // 2 = 1`。`data2` 的 max 是 1，`fun` 返回 `1 // 2 = 0`。</li>        <li>分组 'b': `data1` 的 max 是 4，`fun` 返回 `4 // 2 = 2`。`data2` 的 max 是 3，`fun` 返回 `3 // 2 = 1`。</li>        <li>结果 DataFrame 为：`{'data1': [1, 2], 'data2': [0, 1]}`</li>      </ul>    </li>    <li><b>`.max()`</b>：对上一步结果的每一<b>列</b>求最大值。      <ul>        <li>`data1` 列的最大值是 `2`。</li>        <li>`data2` 列的最大值是 `1`。</li>        <li>结果 Series 为：`data1: 2, data2: 1`</li>      </ul>    </li>    <li><b>`.mean()`</b>：对上一步结果求均值。      <ul>        <li>`(2 + 1) / 2 = 1.5`。</li>      </ul>    </li>  </ol><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>16. 下列选项中错误的是（ ）</strong><br>A. <code>groupby</code>可以在任意轴向上分组<br>B. 默认情况下，<code>groupby</code>在<code>axis=1</code>的轴向上分组。<br>C. 分组信息不一定以数组形式存在<br>D. <code>cut</code>返回的Categorical对象可以直接传递给<code>groupby</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确。可以通过 `axis` 参数指定 `0` (行) 或 `1` (列)。</li>    <li><b>B: 错误</b>。`groupby` 的 `axis` 参数<b>默认值为 0</b>，即默认按行进行分组。</li>    <li>C: 正确。分组信息可以是函数、字典、Series 等。</li>    <li>D: 正确。`cut` 的结果非常适合用作 `groupby` 的分组键。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>17. 对于一个GroupBy对象，如果你要将<code>min</code>函数应用到<code>size</code>列上，将<code>std</code>函数应用到<code>tip</code>列上，应该执行下列哪个语句？</strong><br>A. <code>grouped.agg([(&#39;size&#39;,np.min),(&#39;tip&#39;,&#39;std&#39;)])</code><br>B. <code>grouped.agg(&#123;&#39;size&#39;: np.min, &#39;tip&#39;:  std&#125;)</code><br>C. <code>grouped.agg(&#123;&#39;size&#39;: np.min, &#39;tip&#39;: &#39;std&#39;&#125;)</code><br>D. <code>grouped.agg([(&#39;size&#39;,np.min),(&#39;tip&#39;,std)])</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  要将不同的聚合函数应用到不同的列，最直接的方法是向 `.agg()` 传入一个<b>字典</b>，其中<b>键是列名</b>，<b>值是聚合函数</b>。  <ul>    <li>A, D: 元组列表的格式通常用于对所有列应用聚合，并重命名结果。</li>    <li>B: 错误。`std` 是一个未定义的变量，正确的函数是 `np.std` 或字符串 `'std'`。</li>    <li><b>C: 正确</b>。`{'size': np.min, 'tip': 'std'}` 使用字典将 `np.min` 函数应用到 `size` 列，将 `'std'` (字符串形式) 函数应用到 `tip` 列。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><h2 id="第十一章：时间序列数据的处理和分析"><a href="#第十一章：时间序列数据的处理和分析" class="headerlink" title="第十一章：时间序列数据的处理和分析"></a>第十一章：时间序列数据的处理和分析</h2><p><strong>1. 下面哪个时间序列频率字符串表示“每月第二个星期天”（ ）</strong><br>A. <code>Q-SUN</code><br>B. <code>W-SUN</code><br>C. <code>WOM-2SUN</code><br>D. <code>BQ-SUN</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  Pandas 频率字符串中，`WOM` (Week Of Month) 用于生成特定周的日期。  <ul>    <li>A. `Q-SUN`：每个季度的最后一个星期天。</li>    <li>B. `W-SUN`：每周的星期天。</li>    <li><b>C. `WOM-2SUN`</b>：<b>每月 (Week Of Month) 的第二个 (2) 星期天 (SUN)</b>。</li>    <li>D. `BQ-SUN`：每个业务季度的最后一个星期天。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>2. 若<code>start = datetime(2011, 1, 7)</code>，则<code>start + timedelta(12, 12, 12)</code>的结果是（ ）</strong><br>A. <code>datetime.datetime(2011, 1, 19, 0, 0, 12, 12)</code><br>B. <code>datetime.datetime(2011, 1, 19, 0, 12, 12)</code><br>C. <code>datetime.datetime(2011, 1, 19, 12, 12)</code><br>D. <code>datetime.datetime(2011, 1, 19, 12, 0, 12)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `timedelta(days=0, seconds=0, microseconds=0)`。  题目中的 `timedelta(12, 12, 12)` 对应 `timedelta(days=12, seconds=12, microseconds=12)`。  <ul>    <li>`start` 是 `2011-01-07 00:00:00`。</li>    <li>加上 12 天：`2011-01-07 + 12 days = 2011-01-19`。</li>    <li>加上 12 秒：时间变为 `00:00:12`。</li>    <li>加上 12 微秒。</li>  </ul>  结果是 `datetime.datetime(2011, 1, 19, 0, 0, 12, 12)`。<p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>3. 下列基础的时间序列频率表示每分钟的是（ ）</strong><br>A. D<br>B. T<br>C. M<br>D. BM</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `D`：每日 (Daily)。</li>    <li><b>B. `T`</b> 或 `min`：<b>每分钟 (per minute)</b>。</li>    <li>C. `M`：每月最后一个日历日 (Month end)。</li>    <li>D. `BM`：每月最后一个工作日 (Business month end)。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>4. 下列对于<code>date_range</code>方法的叙述，正确的是（ ）</strong><br>A. 使用<code>date_range</code>方法的时候，必须要传入一个起始日期和一个结尾日期。<br>B. 默认情况下，<code>date_range</code>生成的是每日的时间戳。<br>C. 若执行语句<code>index = pd.date_range(...)</code>，则<code>index</code>中包含结尾日期而不包含起始日期。<br>D. 使用<code>date_range</code>方法将生成一个<code>datetime</code>对象。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 错误。`date_range` 至少需要 `start`, `end`, `periods` 中的两个。可以只提供 `start` 和 `periods`。</li>    <li><b>B: 正确</b>。如果不指定 `freq` 参数，其默认值是 `'D'`，即每日。</li>    <li>C: 错误。`date_range` 生成的日期范围是包含起始日期的。是否包含结尾日期取决于步长和周期。</li>    <li>D: 错误。`date_range` 生成的是 Pandas 的 <b>`DatetimeIndex`</b> 对象，而不是单个的 `datetime` 对象。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>5. <code>stamp = datetime(2011, 1, 3); stamp.strftime(?)</code>，问号处应该填入下列哪条语句，才可以使输出结果为<code>&#39;2011-01-03&#39;</code>（ ）</strong><br>A. <code>&#39;%Y-%M-%d&#39;</code><br>B. <code>&#39;%y-%m-%d&#39;</code><br>C. <code>&#39;%D&#39;</code><br>D. <code>&#39;%F&#39;</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `strftime` 格式化指令：  <ul>    <li>`%Y`：四位数的年份 (2011)。</li>    <li>`%y`：两位数的年份 (11)。</li>    <li>`%m`：补零的月份 (01)。</li>    <li>`%M`：分钟。</li>    <li>`%d`：补零的日期 (03)。</li>    <li>`%D`：是 `'%m/%d/%y'` 的简写。</li>    <li><b>`%F`</b>：是 `'%Y-%m-%d'` 的简写。</li>  </ul>  因此，要得到 `'2011-01-03'`，可以使用 `'%Y-%m-%d'` 或其简写 `'%F'`。<p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>6. 对于下列代码…其运行结果为（ ）</strong><br><code>start = datetime(2019,1,1,0,0); end = start + timedelta(12,60); end.strftime(&#39;%Y-%m-%d/%H:%M:%S&#39;)</code><br>A. <code>&#39;2019-01-13/00:01:00&#39;</code><br>B. <code>&#39;2031-01-1/00:01:00&#39;</code><br>C. <code>&#39;2019-01-13/01:00:00&#39;</code><br>D. <code>&#39;2031-01-1/01:00:00&#39;</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li>`timedelta(12, 60)` 表示 12 天 (days) 和 60 秒 (seconds)。</li>    <li>`start` 是 `2019-01-01 00:00:00`。</li>    <li>加上 12 天 -> `2019-01-13`。</li>    <li>加上 60 秒 -> `00:01:00`。</li>    <li>所以 `end` 是 `2019-01-13 00:01:00`。</li>    <li>使用 `strftime` 格式化后得到 `'2019-01-13/00:01:00'`。</li>  </ol><p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>7. pandas中的哪个函数或方法可以将字符串列表转换为日期索引类型（ ）</strong><br>A. <code>strftime</code><br>B. <code>strptime</code><br>C. <code>to_datetime</code><br>D. <code>timedelta</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `strftime`：将日期时间对象<b>格式化为字符串</b>。</li>    <li>B. `strptime`：将<b>字符串解析为</b>日期时间对象（Python `datetime` 模块的方法）。</li>    <li><b>C. `to_datetime`</b>：是 Pandas 中用于将各种形式（包括字符串列表）<b>转换为 `DatetimeIndex`</b> 或 `Timestamp` 的主要函数。</li>    <li>D. `timedelta`：表示时间差。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>8. 已知<code>now = datetime(2000,1,1)</code>，运行<code>MonthEnd().rollforward(now+MonthEnd())</code>得到的结果为（ ）</strong><br>A. <code>Timestamp(&#39;2000-02-31 00:00:00&#39;)</code><br>B. <code>Timestamp(&#39;2000-01-31 00:00:00&#39;)</code><br>C. <code>Timestamp(&#39;2000-01-01 00:00:00&#39;)</code><br>D. <code>Timestamp(&#39;2000-02-01 00:00:00&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li>`now` 是 `2000-01-01`。</li>    <li>`MonthEnd()` 是一个日期偏移量对象。</li>    <li>`now + MonthEnd()`：将 `now` 滚动到其所在月份的最后一天，得到 `2000-01-31`。</li>    <li>`.rollforward(...)`：如果日期已经在一个偏移量的锚点上，它将保持不变；否则，它会将日期向前滚动到下一个锚点。</li>    <li>`MonthEnd().rollforward(Timestamp('2000-01-31'))`：因为 `2000-01-31` 本身就是一个月末，所以 `rollforward` 不会改变它。</li>  </ol>  结果是 `Timestamp('2000-01-31 00:00:00')`。<p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>9. <code>parse(&#39;6/12/2011&#39;, ?)</code>，问号处应填入以下哪条语句，才使得输出<code>datetime.datetime(2011, 12, 6, 0, 0)</code>。（ ）</strong><br>A. <code>dayfirst=True</code><br>B. <code>dayfirst=False</code><br>C. <code>daylast=True</code><br>D. <code>daylast=False</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>输入的字符串是 `'6/12/2011'`。</li>    <li>期望的输出是 `2011-12-06`，这意味着 `6` 必须被解析为<b>日 (day)</b>，`12` 被解析为<b>月 (month)</b>。</li>    <li>`dateutil.parser.parse` 函数默认会按美式格式 (月/日/年) 解析。要强制它按欧式格式 (日/月/年) 解析，需要设置参数 <b>`dayfirst=True`</b>。</li>  </ul><p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>10. 已知区间<code>p=pd.Period(&#39;2007&#39;,freq=&#39;A-JUN&#39;)</code>则代码<code>p.asfreq(&#39;M&#39;,&#39;end&#39;)</code>输出为（ ）</strong><br>A. <code>Period(&#39;2006-07&#39;, &#39;M&#39;)</code><br>B. <code>Period(&#39;2007-06&#39;, &#39;M&#39;)</code><br>C. <code>Period(&#39;2007-07&#39;, &#39;M&#39;)</code><br>D. <code>Period(&#39;2008-06&#39;, &#39;M&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>`p=pd.Period('2007', freq='A-JUN')` 表示一个从 2006年7月 到 2007年6月 的年度区间。</li>    <li>`.asfreq('M', 'end')` 将这个年度区间转换为月度区间。`'end'` 表示取该区间的<b>最后一个月份</b>。</li>    <li>这个年度区间的最后一个月是 2007年6月。</li>  </ul>  因此，结果是 `Period('2007-06', 'M')`。<p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>11. 下列哪个语句可以输出<code>datetime.datetime(2011, 1, 3, 0, 0)</code>（ ）</strong><br>A. <code>datetime.datetime(2011, 1, 3, 0, 0)</code><br>B. <code>import dateutil.parser; parse(&#39;2011-01-03&#39;)</code><br>C. <code>pd.to_datetime(&#39;2011-01-03&#39;)</code><br>D. <code>pd.to_datetime(&#39;2011-01-03&#39;).to_pydatetime()</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A, B: 都直接创建或返回一个 Python 内置的 `datetime.datetime` 对象。</li>    <li>C: `pd.to_datetime()` 返回的是 Pandas 的 `Timestamp` 对象。</li>    <li><b>D: `pd.to_datetime(...).to_pydatetime()`</b>：先将字符串转换为 Pandas 的 `Timestamp`，然后使用 `.to_pydatetime()` 方法将其转换回 Python 内置的 `datetime.datetime` 对象。</li>  </ul>  所有选项都能得到等价的日期时间表示，但只有 D 是通过 Pandas 实现并最终转换为 `datetime.datetime` 对象的。但 A 和 B 也能直接得到。此题可能存在歧义，但根据答案 D，考察的是 Pandas 转换。<p>  <strong>正确答案：</strong> D (A和B也是正确的)</p></details><hr><p><strong>12. 已知<code>now = datetime(2011,11,17)</code>，则代码<code>offset=MonthEnd();offset.rollforward(now)</code>的输出为（ ）</strong><br>A. <code>Timestamp(&#39;2011-10-31 00:00:00&#39;)</code><br>B. <code>Timestamp(&#39;2011-12-17 00:00:00&#39;)</code><br>C. <code>Timestamp(&#39;2011-11-30 00:00:00&#39;)</code><br>D. <code>Timestamp(&#39;2011-10-17 00:00:00&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>`offset=MonthEnd()`：创建了一个“月末”日期偏移量。</li>    <li>`.rollforward(now)`：将日期 `now` 向前滚动到<b>下一个</b>偏移量的锚点。如果 `now` 本身就在锚点上，则保持不变。</li>    <li>`now` 是 `2011-11-17`，不是月末。</li>    <li>下一个月末是 `2011-11-30`。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>13. 存在一个时间序列对象<code>p = pd.Period(2017, freq=&#39;A-DEC&#39;)</code>，<code>p + 2</code>的结果为（ ）</strong><br>A. <code>Period(2018, freq=’A-FEB’)</code><br>B. <code>Period(2019, freq=’A-DEC’)</code><br>C. <code>Period(2019, freq=’A-NOV’)</code><br>D. <code>Period(2018, freq=’A-FEB’)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>`p = pd.Period(2017, freq='A-DEC')` 表示一个以12月为结尾的年度区间，即2017年。</li>    <li>对 Period 对象进行整数加法，会根据其频率向前移动相应数量的单位。</li>    <li>`p + 2` 表示将 2017 年度区间向前移动 2 个年度单位。</li>    <li>`2017 + 2 = 2019`。频率保持不变。</li>  </ul><p>  <strong>正确答案：</strong> B</p></details><hr><p><strong>14. 假设<code>ts</code>是一个以<code>datetime</code>对象为索引的Series，则以下语句输出结果相同的是（ ）</strong><br>① <code>ts[&#39;1/10/2011&#39;]</code> ② <code>ts[&#39;20110110&#39;]</code> ③ <code>ts[datetime(2011, 1, 10)]</code> ④ <code>ts[datetime(2011, 1, 10)]</code><br>A. ①④<br>B. ①③<br>C. ②④<br>D. ③④</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  Pandas 在处理时间序列索引时，非常灵活，能够解析多种日期字符串格式，并将其与 `datetime` 对象匹配。  <ul>    <li>① `'1/10/2011'` (美式月/日/年) -> 会被解析为 2011年1月10日。</li>    <li>② `'20110110'` (YYYYMMDD) -> 会被解析为 2011年1月10日。</li>    <li>③, ④ `datetime(2011, 1, 10)` -> 直接就是 2011年1月10日。</li>  </ul>  所有这些方式最终都会指向索引中同一个 `datetime(2011, 1, 10)` 的位置。但选项中只有③和④是完全相同的代码。<p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>15. 以下哪个时间频率表示工作日的月初日期（ ）</strong><br>A. <code>M</code><br>B. <code>BM</code><br>C. <code>MS</code><br>D. <code>BMS</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>`M`：月末 (Month End)</li>    <li>`BM`：业务月末 (Business Month End)</li>    <li>`MS`：月初 (Month Start)</li>    <li><b>`BMS`</b>：<b>业务月初 (Business Month Start)</b>，即每个月的第一个工作日。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>16. 在<code>datetime</code>对象中，“2019年5月20日15时20分”应该是下列哪一个格式？( )</strong><br>A. <code>%Y-%M-%D-%H-%m</code><br>B. <code>%Y-%m-%D-%H-%M</code><br>C. <code>%Y-%M-%D-%H-%M</code><br>D. <code>%Y-%m-%d-%H-%M</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `strftime` 格式化指令：  <ul>    <li>`%Y`：年</li>    <li>`%m`：月</li>    <li>`%d`：日</li>    <li>`%H`：小时 (24小时制)</li>    <li>`%M`：分钟</li>  </ul>  选项 D 的 `%Y-%m-%d-%H-%M` 正确地使用了这些指令。<p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>17. 在时间序列中，输出从2010年1月1号0点开始的，每隔4个小时一次，一共十条记录的语句是？（ ）</strong><br>A. <code>pd.date_range(&#39;2010-01-01&#39;, periods = 10, freq = &#39;4h&#39;)</code><br>B. <code>pd.date_range(&#39;2010-01-01&#39;, periods = 10, freq = &#39;D-4h&#39;)</code><br>C. <code>pd.date_range(&#39;2010-01-01&#39;, &#39;2010-01-02&#39;, freq = &#39;4h&#39;)</code><br>D. <code>pd.date_range(&#39;2010-01-01&#39;,  freq = &#39;4h&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `pd.date_range` 需要知道生成的范围。  <ul>    <li>`start='2010-01-01'`：指定了起始日期。</li>    <li>`periods=10`：指定了生成的记录数量为10条。</li>    <li>`freq='4h'`：指定了频率为每4小时。</li>  </ul>  选项 A 完美地组合了这三个参数来实现目标。<p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>18. 下面是<code>datetime(2019, 1, 1).strftime(&#39;%Y-%m-%d&#39;)</code>的结果的是 （ ）</strong><br>A. <code>2019-01-03</code><br>B. <code>19-01-03</code><br>C. <code>2019-1-3</code><br>D. <code>19-1-3</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `strftime('%Y-%m-%d')` 的含义：  <ul>    <li>`%Y`：四位年份 (2019)</li>    <li>`%m`：补零的月份 (01)</li>    <li>`%d`：补零的日期 (01)</li>  </ul>  因此，`datetime(2019, 1, 1)` 会被格式化为 `'2019-01-01'`。此题选项似乎有误，但根据格式，A选项`2019-01-03` 的格式正确，只是日期不对。*假设日期为3号，则A正确*。<p>  <strong>正确答案：</strong> A (假设日期为3号)</p></details><hr><p><strong>19. 设有<code>dates=pd.DatetimeIndex(...)</code>，<code>ts=pd.Series(np.arange(5),index=dates)</code>，执行<code>ts[&#39;1/2/2000&#39;]</code>后得到的输出是（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">dates = pd.DatetimeIndex([<span class="string">&#x27;1/1/2000&#x27;</span>, <span class="string">&#x27;1/2/2000&#x27;</span>, <span class="string">&#x27;1/2/2000&#x27;</span>, </span><br><span class="line">                          <span class="string">&#x27;1/2/2000&#x27;</span>, <span class="string">&#x27;1/3/2000&#x27;</span>])</span><br><span class="line">ts = pd.Series(np.arange(<span class="number">5</span>), index=dates)</span><br></pre></td></tr></table></figure><p>A. <code>6</code><br>B. <code>[1, 2, 3]</code><br>C.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">2000-01-02    1</span><br><span class="line">2000-01-02    2</span><br><span class="line">2000-01-02    3</span><br><span class="line">dtype: int32</span><br></pre></td></tr></table></figure><p>D. <code>2000-01-02    1</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li><b>创建 Series</b>：`ts` 是一个以 `DatetimeIndex` 为索引的 Series。其内容如下：<pre>2000-01-01    02000-01-02    12000-01-02    22000-01-02    32000-01-03    4dtype: int32</pre></li>    <li><b>重复索引查询</b>：索引中包含了<b>重复的标签</b> `2000-01-02`。</li>    <li><b>执行 `ts['1/2/2000']`</b>：      <ul>        <li>Pandas 能够自动将字符串 `'1/2/2000'` 解析为对应的日期时间对象。</li>        <li>当使用一个重复的标签进行索引时，Pandas 会返回一个<b>新的 Series</b>，其中包含所有匹配该标签的行。</li>        <li>索引为 `2000-01-02` 的行有三条，对应的值是 `1, 2, 3`。</li>      </ul>    </li>    <li><b>最终结果</b>：操作会返回一个新的 Series，其索引都是 `2000-01-02`，值分别是 `1, 2, 3`。这与选项 C 的内容完全一致。</li>  </ul>  <p>选项 B `[1, 2, 3]` 是一个 Python 列表，而 Pandas 操作返回的是 Series 对象。选项 A 和 D 都不完整。</p><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 Series</span></span><br><span class="line">dates = pd.DatetimeIndex([<span class="string">&#x27;1/1/2000&#x27;</span>, <span class="string">&#x27;1/2/2000&#x27;</span>, <span class="string">&#x27;1/2/2000&#x27;</span>,</span><br><span class="line">                          <span class="string">&#x27;1/2/2000&#x27;</span>, <span class="string">&#x27;1/3/2000&#x27;</span>])</span><br><span class="line">ts = pd.Series(np.arange(<span class="number">5</span>), index=dates)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 Series:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(ts)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行索引操作</span></span><br><span class="line">result = ts[<span class="string">&#x27;1/2/2000&#x27;</span>]</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n执行 ts[&#x27;1/2/2000&#x27;] 之后的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>20. <code>ts=pd.Series(np.arange(4),index=pd.date_range(&#39;1/1/2019&#39;,periods=4,freq=&#39;M&#39;))</code>，执行<code>ts.shift(1,freq=&#39;D&#39;)</code>后得到的结果是（ ）</strong></p><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">2019-01-31    0</span><br><span class="line">2019-02-28    1</span><br><span class="line">2019-03-31    2</span><br><span class="line">2019-04-30    3</span><br></pre></td></tr></table></figure><p>B.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">2019-01-31    NaN</span><br><span class="line">2019-02-28    0.0</span><br><span class="line">2019-03-31    1.0</span><br><span class="line">2019-04-30    2.0</span><br></pre></td></tr></table></figure><p>C.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">2019-01-30    0</span><br><span class="line">2019-02-27    1</span><br><span class="line">2019-03-30    2</span><br><span class="line">2019-04-29    3</span><br></pre></td></tr></table></figure><p>D.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">2019-02-01    0</span><br><span class="line">2019-03-01    1</span><br><span class="line">2019-04-01    2</span><br><span class="line">2019-05-01    3</span><br></pre></td></tr></table></figure><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>创建 Series `ts`</b>：      <ul>        <li>`pd.date_range('1/1/2019', periods=4, freq='M')` 生成一个以每月最后一个日历日为频率的 DatetimeIndex。</li>        <li>所以 `ts` 的索引是 `['2019-01-31', '2019-02-28', '2019-03-31', '2019-04-30']`。</li>        <li>`ts` 的内容如下：<pre>2019-01-31    02019-02-28    12019-03-31    22019-04-30    3</pre></li>      </ul>    </li>    <li><b>执行 `ts.shift(1, freq='D')`</b>：      <ul>        <li><code>.shift()</code> 方法用于移动数据或索引。</li>        <li>当提供了 <code>freq</code> 参数时，它会移动<b>索引</b>，而不是移动数据值。</li>        <li><code>freq='D'</code> 表示移动的单位是“天”。</li>        <li><code>1</code> 表示将索引<b>向前移动 1 个单位</b>（即加1天）。</li>      </ul>    </li>    <li><b>分析索引变化</b>：      <ul>        <li>`2019-01-31` + 1天 -> `2019-02-01`</li>        <li>`2019-02-28` + 1天 -> `2019-03-01`</li>        <li>`2019-03-31` + 1天 -> `2019-04-01`</li>        <li>`2019-04-30` + 1天 -> `2019-05-01`</li>      </ul>    </li>    <li><b>最终结果</b>：数据值 `[0, 1, 2, 3]` 保持不变，但与移动后的新日期索引对齐。这与选项 D 的内容完全一致。</li>  </ol>  <p>（注：如果不提供 <code>freq</code> 参数，如 <code>ts.shift(1)</code>，则会移动数据值，结果与选项 B 类似。）</p><p>  <strong>正确答案：</strong> D</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 Series</span></span><br><span class="line">ts = pd.Series(np.arange(<span class="number">4</span>), </span><br><span class="line">                index=pd.date_range(<span class="string">&#x27;1/1/2019&#x27;</span>, periods=<span class="number">4</span>, freq=<span class="string">&#x27;M&#x27;</span>))</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 Series:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(ts)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行带 freq 参数的 shift 操作</span></span><br><span class="line">result = ts.shift(<span class="number">1</span>, freq=<span class="string">&#x27;D&#x27;</span>)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n执行 ts.shift(1, freq=&#x27;D&#x27;) 之后的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>21. 则<code>ts+ts[::2]</code>的输出结果是：（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">from</span> datetime <span class="keyword">import</span> datetime</span><br><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line">dates = [datetime(<span class="number">2019</span>,<span class="number">7</span>,<span class="number">10</span>), datetime(<span class="number">2019</span>,<span class="number">7</span>,<span class="number">14</span>), </span><br><span class="line">         datetime(<span class="number">2019</span>,<span class="number">7</span>,<span class="number">16</span>), datetime(<span class="number">2019</span>,<span class="number">7</span>,<span class="number">18</span>), </span><br><span class="line">         datetime(<span class="number">2019</span>,<span class="number">7</span>,<span class="number">20</span>)]</span><br><span class="line">ts = pd.Series(<span class="built_in">range</span>(<span class="number">1</span>,<span class="number">6</span>), index=dates) <span class="comment"># 假设变量名为 ts 而非 s</span></span><br></pre></td></tr></table></figure><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">2019-07-10     2.0</span><br><span class="line">2019-07-14     3.0</span><br><span class="line">2019-07-16     6.0</span><br><span class="line">2019-07-18     5.0</span><br><span class="line">2019-07-20    10.0</span><br></pre></td></tr></table></figure><p>B.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">2019-07-10     2.0</span><br><span class="line">2019-07-14     NaN</span><br><span class="line">2019-07-16     6.0</span><br><span class="line">2019-07-18     NaN</span><br><span class="line">2019-07-20    10.0</span><br></pre></td></tr></table></figure><p>C.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">2019-07-10     1.0</span><br><span class="line">2019-07-14     NaN</span><br><span class="line">2019-07-16     3.0</span><br><span class="line">2019-07-18     NaN</span><br><span class="line">2019-07-20     5.0</span><br></pre></td></tr></table></figure><p>D.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">2019-07-10     2.0</span><br><span class="line">2019-07-16     6.0</span><br><span class="line">2019-07-20    10.0</span><br></pre></td></tr></table></figure><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>创建 Series `ts`</b>：`ts` 的内容如下：<pre>2019-07-10    12019-07-14    22019-07-16    32019-07-18    42019-07-20    5</pre></li>    <li><b>创建切片 `ts[::2]`</b>：      <ul>        <li><code>[::2]</code> 是步长为2的切片操作，会选择索引为 0, 2, 4 的元素。</li>        <li>所以 `ts[::2]` 的内容如下：<pre>2019-07-10    12019-07-16    32019-07-20    5</pre></li>      </ul>    </li>    <li><b>执行 `ts + ts[::2]`</b>：      <ul>        <li>两个 Series 相加时，会按<b>索引对齐</b>。</li>        <li>只有在两个 Series 中<b>都存在</b>的索引，其值才会相加。</li>        <li>对于只存在于一个 Series 中的索引，结果为 <b>`NaN`</b> (缺失值)。</li>      </ul>    </li>    <li><b>逐个索引分析</b>：      <ul>        <li><b>`2019-07-10`</b>: 在 `ts` 中为 `1`，在 `ts[::2]` 中也为 `1`。相加得 `2.0`。</li>        <li><b>`2019-07-14`</b>: 在 `ts` 中为 `2`，在 `ts[::2]` 中<b>不存在</b>。相加得 `NaN`。</li>        <li><b>`2019-07-16`</b>: 在 `ts` 中为 `3`，在 `ts[::2]` 中也为 `3`。相加得 `6.0`。</li>        <li><b>`2019-07-18`</b>: 在 `ts` 中为 `4`，在 `ts[::2]` 中<b>不存在</b>。相加得 `NaN`。</li>        <li><b>`2019-07-20`</b>: 在 `ts` 中为 `5`，在 `ts[::2]` 中也为 `5`。相加得 `10.0`。</li>      </ul>    </li>    <li><b>最终结果</b>：操作后的 Series 与选项 B 的内容完全一致。</li>  </ol><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">from</span> datetime <span class="keyword">import</span> datetime</span><br><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 Series</span></span><br><span class="line">dates = [datetime(<span class="number">2019</span>,<span class="number">7</span>,<span class="number">10</span>), datetime(<span class="number">2019</span>,<span class="number">7</span>,<span class="number">14</span>), </span><br><span class="line">         datetime(<span class="number">2019</span>,<span class="number">7</span>,<span class="number">16</span>), datetime(<span class="number">2019</span>,<span class="number">7</span>,<span class="number">18</span>), </span><br><span class="line">         datetime(<span class="number">2019</span>,<span class="number">7</span>,<span class="number">20</span>)]</span><br><span class="line">ts = pd.Series(<span class="built_in">range</span>(<span class="number">1</span>,<span class="number">6</span>), index=dates)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行相加操作</span></span><br><span class="line">result = ts + ts[::<span class="number">2</span>]</span><br><span class="line"></span><br><span class="line"><span class="comment"># 打印结果</span></span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>22. 则<code>ts[&#39;7/10/2019&#39;]</code>的输出结果是：（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">dates = pd.DatetimeIndex([<span class="string">&#x27;7/10/2019&#x27;</span>,<span class="string">&#x27;7/10/2019&#x27;</span>,<span class="string">&#x27;7/11/2019&#x27;</span>,</span><br><span class="line">                          <span class="string">&#x27;7/12/2019&#x27;</span>,<span class="string">&#x27;7/12/2019&#x27;</span>])</span><br><span class="line">ts = pd.Series(np.arange(<span class="number">5</span>), index=dates)</span><br></pre></td></tr></table></figure><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">2019-07-10    0</span><br><span class="line">2019-07-10    1</span><br></pre></td></tr></table></figure><p>B. <code>2019-07-10    0</code><br>C. <code>2019-07-10    1</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>创建 Series `ts`</b>：`ts` 的内容如下，其中索引 `2019-07-10` 出现了两次。<pre>2019-07-10    02019-07-10    12019-07-11    22019-07-12    32019-07-12    4dtype: int32</pre></li>    <li><b>执行 `ts['7/10/2019']`</b>：      <ul>        <li>这是基于标签的索引操作。Pandas 会自动将字符串 `'7/10/2019'` 解析为 `Timestamp('2019-07-10')`。</li>        <li>当使用一个<b>重复的标签</b>进行索引时，Pandas 会返回一个<b>新的 Series</b>，其中包含所有匹配该标签的行。</li>      </ul>    </li>    <li><b>最终结果</b>：操作会返回一个新的 Series，包含所有索引为 `2019-07-10` 的行，其值分别为 `0` 和 `1`。这与选项 A 的内容完全一致。</li>  </ol><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 Series</span></span><br><span class="line">dates = pd.DatetimeIndex([<span class="string">&#x27;7/10/2019&#x27;</span>,<span class="string">&#x27;7/10/2019&#x27;</span>,<span class="string">&#x27;7/11/2019&#x27;</span>,</span><br><span class="line">                          <span class="string">&#x27;7/12/2019&#x27;</span>,<span class="string">&#x27;7/12/2019&#x27;</span>])</span><br><span class="line">ts = pd.Series(np.arange(<span class="number">5</span>), index=dates)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 Series:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(ts)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行索引操作</span></span><br><span class="line">result = ts[<span class="string">&#x27;7/10/2019&#x27;</span>]</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n执行 ts[&#x27;7/10/2019&#x27;] 之后的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>23. 下列对于<code>datetime</code>模块中的数据类型的叙述，错误的是（ ）</strong><br>A. <code>time</code>将时间存储为小时，分钟，秒，微秒。<br>B. <code>timedelta</code>表示两个<code>datetime</code>值之间的差。<br>C. <code>datetime</code>表示存储日期和时间。<br>D. <code>date</code>表示使用农历日历存储的日历日期（年，月，日）。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A, B, C 都是正确的描述。</li>    <li><b>D: 错误</b>。`date` 对象表示的是<b>公历 (Gregorian calendar)</b> 日期，而不是农历。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>24. 已知<code>p = pd.Period(2007, freq=&#39;A-DEC&#39;)</code>，则下列语句可以运行的是（ ）</strong><br>A. <code>p + 1</code><br>B. <code>p * 2</code><br>C. <code>p++</code><br>D. <code>1/p</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `Period` 对象支持与整数的加减法，表示按其频率移动。  <ul>    <li><b>A. `p + 1`</b>：有效，将年度区间向前移动1年。</li>    <li>B. `p * 2`：无效，不支持乘法。</li>    <li>C. `p++`：无效，Python 中没有 `++` 自增运算符。</li>    <li>D. `1/p`：无效，不支持除法。</li>  </ul><p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>25. 下列语句输出的<code>DatetimeIndex</code>是（ ）</strong><br><code>print(pd.date_range(&#39;2019/7/12&#39;,&#39;2021/6/30&#39;,freq = &#39;WOM-1sun&#39;))</code><br>A. …每个月的第一天的日期。<br>B. …每个月的第一个周一的日期。<br>C. …每个月的第一个周日的日期。<br>D. …每个月的最后一个周日的日期。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `'WOM-1sun'` 频率字符串的含义是：  <ul>    <li>`WOM`：Week Of Month</li>    <li>`1`：第一周</li>    <li>`sun`：星期日</li>  </ul>  合起来就是“每个月的第一个星期日”。<p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>26. 下列方法中，不能将<code>date = datetime(2000,1,1)</code>转换为<code>&#39;2000-01-01&#39;</code>的是（ ）</strong><br>A. <code>date.strftime(&#39;%Y-%m-%d&#39;)</code><br>B. <code>str(date).split(&#39; &#39;)[0]</code><br>C. <code>str(date)[0:str(date).index(&#39; &#39;)]</code><br>D. <code>str(date).strftime(&#39;%Y-%m-%d&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: `strftime` 是 `datetime` 对象的方法，可以正确格式化。</li>    <li>B: `str(date)` 得到 `'2000-01-01 00:00:00'`，按空格分割后取第一部分，得到 `'2000-01-01'`。正确。</li>    <li>C: 与 B 类似，通过字符串切片获取第一部分。正确。</li>    <li><b>D: 错误</b>。`str(date)` 返回的是一个<b>字符串</b>，字符串对象没有 `strftime` 方法，这会引发 `AttributeError`。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>27. <code>stamp = datetime(2019, 1, 1); stamp.strftime(?)</code>，如何才可以使输出<code>&#39;01/01/2019&#39;</code>（ ）</strong><br>A. <code>&#39;%c&#39;</code><br>B. <code>&#39;%p&#39;</code><br>C. <code>&#39;%X&#39;</code><br>D. <code>&#39;%x&#39;</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `strftime` 的简写格式：  <ul>    <li>`%c`：本地化的日期和时间。</li>    <li>`%p`：AM 或 PM。</li>    <li>`%X`：本地化的时间。</li>    <li><b>`%x`</b>：<b>本地化的日期</b>，在美式 locale 下通常是 `'%m/%d/%Y'` 格式，即 `'01/01/2019'`。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>28. <code>a = datetime(2011, 1, 3, 4)</code>，想得到<code>&#39;11-01-03-04’</code>的输出，需要输入以下哪个语句？（ ）</strong><br>A. <code>a.strftime(&#39;%Y-%m-%d-%h&#39;)</code><br>B. <code>a.strftime(&#39;%y-%m-%d-%h&#39;)</code><br>C. <code>a.strftime(&#39;%Y-%m-%d-%H&#39;)</code><br>D. <code>a.strftime(&#39;%y-%m-%d-%H&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  需要 `'11-01-03-04'` 格式：  <ul>    <li>`'11'` -> `%y` (两位年份)</li>    <li>`'01'` -> `%m` (补零月份)</li>    <li>`'03'` -> `%d` (补零日期)</li>    <li>`'04'` -> `%H` (补零小时, 24小时制)</li>  </ul>  选项 D 正确组合了这些指令。<p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>29. 已知 <code>ts</code> 如下，下列哪个选项不能得到 Out[17]: 0.3523043050814792这个值？（ ）</strong></p><pre>ts2011-01-02    1.1200452011-01-05   -0.1819502011-01-07    0.352304  2011-01-08    0.9362662011-01-10    1.7904152011-01-12    0.276105dtype: float64</pre><p>A. <code>ts[&#39;07/01/2011&#39;]</code><br>B. <code>ts[&#39;20110107&#39;]</code><br>C. <code>ts[ts.index[2]]</code><br>D. <code>ts[2]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  目标值 `0.352304...` 对应的索引是 `2011-01-07`，其位置是第 3 个，即整数位置索引为 `2`。  <p>我们来分析每个选项：</p>  <ul>    <li><b>A. `ts['07/01/2011']`</b>：Pandas 的时间序列索引器非常智能，但它对日期字符串的解析有默认规则。`'07/01/2011'` 这种格式在美式 (US) 语境下通常被解析为 <b>7月1日</b>，而不是1月7日。由于索引中没有 `2011-07-01`，此操作会引发 `KeyError`。因此，它<b>不能</b>得到目标值。</li>    <li><b>B. `ts['20110107']`</b>：`'YYYYMMDD'` 是一种无歧义的格式，Pandas 可以正确解析为 `2011-01-07`。<b>可以</b>得到目标值。</li>    <li><b>C. `ts[ts.index[2]]`</b>：`ts.index[2]` 获取索引中位置为 2 的 `Timestamp` 对象（即 `Timestamp('2011-01-07')`），然后用这个对象去精确索引 `ts`。<b>可以</b>得到目标值。</li>    <li><b>D. `ts[2]`</b>：当 Series 的索引是 `DatetimeIndex` 时，整数索引会作为<b>位置索引</b>使用。`ts[2]` 会获取位置为 2 的元素（即第三个元素）。<b>可以</b>得到目标值。</li>  </ul>  <p>因此，只有选项 A 因为日期格式解析的歧义问题而无法得到正确结果。</p><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">from</span> datetime <span class="keyword">import</span> datetime</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 Series</span></span><br><span class="line">index = [datetime(<span class="number">2011</span>, <span class="number">1</span>, <span class="number">2</span>), datetime(<span class="number">2011</span>, <span class="number">1</span>, <span class="number">5</span>), datetime(<span class="number">2011</span>, <span class="number">1</span>, <span class="number">7</span>),</span><br><span class="line">         datetime(<span class="number">2011</span>, <span class="number">1</span>, <span class="number">8</span>), datetime(<span class="number">2011</span>, <span class="number">1</span>, <span class="number">10</span>), datetime(<span class="number">2011</span>, <span class="number">1</span>, <span class="number">12</span>)]</span><br><span class="line">ts = pd.Series([<span class="number">1.12</span>, -<span class="number">0.18</span>, <span class="number">0.35</span>, <span class="number">0.93</span>, <span class="number">1.79</span>, <span class="number">0.27</span>], index=index)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 Series:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(ts)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n--- 逐个分析选项 ---&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># A (会报错)</span></span><br><span class="line"><span class="keyword">try</span>:</span><br><span class="line">    <span class="built_in">print</span>(<span class="string">&quot;A. ts[&#x27;07/01/2011&#x27;]:&quot;</span>, ts[<span class="string">&#x27;07/01/2011&#x27;</span>])</span><br><span class="line"><span class="keyword">except</span> KeyError <span class="keyword">as</span> e:</span><br><span class="line">    <span class="built_in">print</span>(<span class="string">f&quot;A. ts[&#x27;07/01/2011&#x27;]: 引发 KeyError，因为 &#x27;07/01/2011&#x27; 被解析为7月1日。&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># B (可以)</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;B. ts[&#x27;20110107&#x27;]:&quot;</span>, ts[<span class="string">&#x27;20110107&#x27;</span>])</span><br><span class="line"></span><br><span class="line"><span class="comment"># C (可以)</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;C. ts[ts.index[2]]:&quot;</span>, ts[ts.index[<span class="number">2</span>]])</span><br><span class="line"></span><br><span class="line"><span class="comment"># D (可以)</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;D. ts[2]:&quot;</span>, ts[<span class="number">2</span>])</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>30. <code>longer_ts = pd.Series(...)</code>，下列语句中，会报错的是（ ）</strong><br>A. <code>longer_ts[&#39;2001-05-25&#39;]</code><br>B. <code>longer_ts[&#39;20010525&#39;]</code><br>C. <code>longer_ts[&#39;200105&#39;]</code><br>D. <code>longer_ts[&#39;2001/05&#39;]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A, B, D: 都是有效的日期/月份字符串，Pandas 可以解析并用作切片或索引。`'2001-05-25'` 和 `'20010525'` 选择单日，`'2001/05'` 选择整个月份。</li>    <li><b>C: 错误</b>。`'200105'` 这种六位数的格式对于 Pandas 的日期解析器来说是<b>有歧义的</b>，它无法确定这是 `'2001-05'` 还是其他格式，通常会引发解析错误或返回空结果。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>31. 下列说法中错误的是（ ）</strong><br>A. <code>datetime.strptime</code>可以将字符串转化成<code>datetime</code>格式<br>B. 当日期出现在月份之前时，可以用<code>dayfirst=True</code>来说明<br>C. 时间序列的切片原则是左闭右开<br>D. <code>PeriodIndex</code>类存储的是区间的序列</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 正确。`strptime` (string parse time) 用于解析字符串。</li>    <li>B: 正确。`dayfirst=True` 用于解析 `DD/MM/YYYY` 格式。</li>    <li><b>C: 错误</b>。与 Python 列表不同，Pandas 时间序列的<b>标签切片</b>是<b>“左闭右闭”</b>的，即包含结束日期。</li>    <li>D: 正确。`PeriodIndex` 由 `Period` 对象构成，每个对象代表一个时间区间。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>32. <code>%F</code>代表哪种格式的缩写( )</strong><br>A. <code>%m/%d/%y</code><br>B. <code>%y-%m-%d</code><br>C. <code>%Y-%m-%d</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `%F` 是 `strftime` 和 `strptime` 中 `'%Y-%m-%d'` 的 ISO 8601 格式简写。<p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>33. <code>timedelta</code>中不包含以下哪个参数（ ）</strong><br>A. <code>months</code><br>B. <code>weeks</code><br>C. <code>days</code><br>D. <code>hours</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `datetime.timedelta` 对象的构造函数只接受 `days`, `seconds`, `microseconds`, `milliseconds`, `minutes`, `hours`, `weeks` 这些参数。它<b>不接受</b> `months` 或 `years`，因为月和年的天数是不固定的。<p>  <strong>正确答案：</strong> A</p></details><hr><p><strong>34. 下列对于<code>datetime</code>模块中的数据类型叙述，错误的是（ ).</strong><br>A. <code>time</code>将时间存储为小时，分钟，秒，微秒。<br>B. <code>timedelta</code>表示两个<code>datetime</code>值之间的差。<br>C. <code>datetime</code>表示存储日期与时间。<br>D. <code>date</code>表示使用农历日期日历存储的日历日期（年，月，日）。</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  此题与第 23 题相同。`date` 对象表示的是公历日期。<p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>35. 以下不是<code>pandas.date_range()</code>的参数的是（ ）</strong><br>A. <code>after</code><br>B. <code>periods</code><br>C. <code>end</code><br>D. <code>freq</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `pd.date_range()` 的主要参数是 `start`, `end`, `periods`, `freq`。  <ul>    <li><b>A: `after`</b> 不是 `date_range` 的参数。</li>    <li>B, C, D 都是其有效参数。</li>  </ul><p>  <strong>正确答案：</strong> A</p></details><h2 id="第十二章：一些Pandas中的高级用法"><a href="#第十二章：一些Pandas中的高级用法" class="headerlink" title="第十二章：一些Pandas中的高级用法"></a>第十二章：一些Pandas中的高级用法</h2><p><strong>1. 已知<code>categories</code>和<code>codes</code>，可通过下列哪个方法或函数快速构建Categorical对象（ ）</strong><br>A. <code>astype</code><br>B. <code>pd.Categorical</code><br>C. <code>from_codes</code><br>D. <code>take</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A. `astype('category')`：用于将现有的 Series 或列转换为分类类型，它会自动推断 `categories` 和 `codes`。</li>    <li>B. `pd.Categorical(...)`：是主要的构造函数，可以从原始值创建 Categorical 对象。</li>    <li><b>C. `pd.Categorical.from_codes(...)`</b>：是 `pd.Categorical` 的一个<b>类方法</b>，专门用于从已知的 `codes` (编码) 和 `categories` (类别) 来<b>直接构造</b>一个 Categorical 对象。</li>    <li>D. `take`：用于根据索引位置选取元素，不是构造方法。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>2. 假设<code>df = ...</code>，<code>g = df.groupby(&#39;key&#39;).value</code>，则以下对<code>g</code>的操作，不能运行的是（ ）</strong><br>A. 以下都不是<br>B. <code>g.transform(&#39;mean&#39;)</code><br>C. <code>g.transform(lambda x: x.rank(ascending=False))</code><br>D. <code>g.transform(std)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  `transform` 方法期望传入的函数能对每个子分组 (Series) 进行计算，并返回一个与该子分组形状相同的 Series 或数组。  <ul>    <li>B. `'mean'`：`transform('mean')` 会计算每个分组的均值，并将该均值广播到该分组的所有成员上。有效。</li>    <li>C. `lambda x: x.rank(...)`：对每个分组 `x` (一个 Series) 计算排名，返回的排名 Series 与 `x` 形状相同。有效。</li>    <li><b>D. `g.transform(std)`</b>：这里的 `std` 是一个未定义的变量。正确的写法应该是字符串 `'std'` 或者 NumPy 的函数 `np.std`。直接使用 `std` 会引发 `NameError`。因此，此操作不能运行。</li>  </ul><p>  <strong>正确答案：</strong> D</p></details><hr><p><strong>3. 已知 <code>categories=[&#39;a&#39;,&#39;b&#39;,&#39;c&#39;]</code>， <code>codes=[0,1,2,0,0,1]</code>，执行代码<code>pd.Series(categories).take(pd.Series(codes))</code>，其输出的结果为（ ）</strong></p><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">0    a</span><br><span class="line">1    b</span><br><span class="line">2    c</span><br><span class="line">0    a</span><br><span class="line">0    a</span><br><span class="line">1    b</span><br><span class="line">dtype: object</span><br></pre></td></tr></table></figure><p>B.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">[a, b, c, a, a, b]</span><br><span class="line">Categories (3, object): [a, b, c]</span><br></pre></td></tr></table></figure><p>C.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line">0    a</span><br><span class="line">1    b</span><br><span class="line">2    c</span><br><span class="line">3    a</span><br><span class="line">4    a</span><br><span class="line">5    c</span><br><span class="line">dtype: category</span><br><span class="line">Categories (3, object): [a, b, c]</span><br></pre></td></tr></table></figure><p>D.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">[a, b, c, a, a, b]</span><br><span class="line">Categories (3, object): [a &lt; b &lt; c]</span><br></pre></td></tr></table></figure><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`pd.Series(categories)`</b>：首先，我们创建一个 Series 对象 `s`。      <pre>s:0    a1    b2    cdtype: object</pre>    </li>    <li><b>`.take(pd.Series(codes))`</b>：      <ul>        <li><code>.take()</code> 方法根据传入的<b>位置索引</b>列表或 Series 来从 `s` 中选取元素。</li>        <li>`pd.Series(codes)` 的值是 `[0, 1, 2, 0, 0, 1]`。</li>        <li><code>.take()</code> 会按照这个顺序从 `s` 中取值：          <ul>            <li>取位置 `0` -> `'a'`</li>            <li>取位置 `1` -> `'b'`</li>            <li>取位置 `2` -> `'c'`</li>            <li>取位置 `0` -> `'a'`</li>            <li>取位置 `0` -> `'a'`</li>            <li>取位置 `1` -> `'b'`</li>          </ul>        </li>      </ul>    </li>    <li><b>最终结果</b>：      <ul>        <li>最终生成一个新的 Series，其值为 `['a', 'b', 'c', 'a', 'a', 'b']`。</li>        <li>这个新 Series 的索引会是 `pd.Series(codes)` 的索引，即 `[0, 1, 2, 3, 4, 5]`。</li>        <li>但选项 A 展示的索引是 `[0, 1, 2, 0, 0, 1]`，这是<b>不正确的</b>，因为 `take` 会使用 `codes` 的值作为位置，但会保留 `codes` Series 自身的索引作为新 Series 的索引。</li>      </ul>    </li>  </ol>  <p><b>结论</b>：选项 A 的值是正确的，但其显示的索引是错误的。在选择题中，如果值的顺序正确，通常会选择该选项。`take` 方法本身返回的是一个 Series，而不是 Categorical 对象（如 B, C, D 所示），所以 A 是最接近的答案，尽管其索引表示有误。</p><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的数据</span></span><br><span class="line">categories = [<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>]</span><br><span class="line">codes = [<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">0</span>, <span class="number">0</span>, <span class="number">1</span>]</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行操作</span></span><br><span class="line">s = pd.Series(categories)</span><br><span class="line">result = s.take(pd.Series(codes))</span><br><span class="line"></span><br><span class="line"><span class="comment"># 打印结果</span></span><br><span class="line"><span class="built_in">print</span>(result)</span><br><span class="line"><span class="comment"># 注意：实际输出的索引是 0, 1, 2, 3, 4, 5，但选项 A 的值是正确的</span></span><br></pre></td></tr></table></figure></p></details><hr><p><strong>4. 已知 <code>categories = [&#39;a&#39;,&#39;b&#39;,&#39;c&#39;,&#39;d&#39;]</code>，<code>pd.Categorical.from_codes(codes, categories)</code> 中传入以下哪个 <code>codes</code> 可以构造对象 <img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/49.png" alt="这里填写图片1的描述">？（ ）</strong></p><p>A. <code>codes = [1, 2, 1, 3, 2, 0, 0]</code><br>B. <code>codes = [0, 0, 2, 3, 1, 2, 1]</code><br>C. <code>codes = [1, 1, 3, 4, 2, 3, 2]</code><br>D. <code>codes = [2, 3, 2, 4, 3, 1, 1]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <p>`pd.Categorical.from_codes(codes, categories)` 函数通过 `codes`（编码）和 `categories`（类别）来构造一个 Categorical 对象。`codes` 中的每个数字都是 `categories` 列表的索引。</p>  <p>我们的 `categories` 是 `['a', 'b', 'c', 'd']`，其对应的索引关系如下：</p>  <ul>    <li>'a' -> 0</li>    <li>'b' -> 1</li>    <li>'c' -> 2</li>    <li>'d' -> 3</li>  </ul>  <p>目标是构造出序列 `[a, a, c, d, b, c, b]`。我们只需要将这个序列中的每个值替换成它对应的索引编码即可：</p>  <ul>    <li>'a' -> 0</li>    <li>'a' -> 0</li>    <li>'c' -> 2</li>    <li>'d' -> 3</li>    <li>'b' -> 1</li>    <li>'c' -> 2</li>    <li>'b' -> 1</li>  </ul>  <p>因此，正确的 `codes` 列表应该是 `[0, 0, 2, 3, 1, 2, 1]`。这与选项 B 完全匹配。</p>  <p>同时，我们需要检查其他选项的有效性。`from_codes` 要求 `codes` 列表中的所有值都必须是 `categories` 的有效索引（即 `0, 1, 2, 3`）。选项 C 和 D 中都包含了值 `4`，这不是一个有效索引，所以它们会引发错误。</p><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 定义类别和正确的编码</span></span><br><span class="line">categories = [<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>, <span class="string">&#x27;d&#x27;</span>]</span><br><span class="line">codes = [<span class="number">0</span>, <span class="number">0</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">1</span>]</span><br><span class="line"></span><br><span class="line"><span class="comment"># 使用 from_codes 构造 Categorical 对象</span></span><br><span class="line">my_categorical = pd.Categorical.from_codes(codes, categories)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 打印结果</span></span><br><span class="line"><span class="built_in">print</span>(my_categorical)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>5. 以下哪一个不是分类方法（ ）</strong><br>A. <code>add_categories</code><br>B. <code>as_unordered</code><br>C. <code>remove_used_categories</code><br>D. <code>rename_categories</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  这些都是 Categorical 数据的 `.cat` 访问器下的方法。  <ul>    <li>A. `add_categories`：添加新类别。存在。</li>    <li>B. `as_unordered`：将有序分类转换为无序。存在。</li>    <li><b>C. `remove_used_categories`</b>：没有这个方法。有一个 `.remove_unused_categories()` 方法，用于移除未在数据中出现的类别。</li>    <li>D. `rename_categories`：重命名类别。存在。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>6. 如果一个Categorical对象的<code>categories</code>属性是<code>[&#39;red&#39;, &#39;blue&#39;, &#39;green&#39;, &#39;white&#39;]</code>，<code>codes</code>属性是<code>[0, 1, 2, 3, 2, 1, 3, 0, 2]</code>，那么这个对象创建时传入的序列是（ ）</strong></p><p>A. <code>[&#39;red&#39;, &#39;blue&#39;, &#39;green&#39;, &#39;white&#39;, &#39;red&#39;, &#39;red&#39;, &#39;blue&#39;, &#39;green&#39;, &#39;white&#39;]</code><br>B. <code>[&#39;red&#39;, &#39;blue&#39;, &#39;green&#39;, &#39;white&#39;, &#39;red&#39;, &#39;blue&#39;, &#39;green&#39;, &#39;white&#39;, &#39;white&#39;]</code><br>C. <code>[&#39;red&#39;, &#39;blue&#39;, &#39;green&#39;, &#39;white&#39;, &#39;green&#39;, &#39;blue&#39;, &#39;white&#39;, &#39;red&#39;, &#39;green&#39;]</code><br>D. <code>[&#39;red&#39;, &#39;blue&#39;, &#39;green&#39;, &#39;white&#39;, &#39;green&#39;, &#39;white&#39;, &#39;white&#39;, &#39;red&#39;, &#39;green&#39;]</code><br><em>(注：原题中有两个A选项，这里将其修改为D以便区分)</em></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <p>我们可以通过 `codes`（编码）和 `categories`（类别）反向推导出原始的序列。`codes` 中的每个数字代表了它在 `categories` 列表中的位置索引。</p>  <p>给定的 `categories` 是 `['red', 'blue', 'green', 'white']`，其索引关系如下：</p>  <ul>    <li>0: 'red'</li>    <li>1: 'blue'</li>    <li>2: 'green'</li>    <li>3: 'white'</li>  </ul>  <p>给定的 `codes` 是 `[0, 1, 2, 3, 2, 1, 3, 0, 2]`。我们逐个将编码替换为对应的类别值：</p>  <ul>    <li>`codes[0]` = 0  -> 'red'</li>    <li>`codes[1]` = 1  -> 'blue'</li>    <li>`codes[2]` = 2  -> 'green'</li>    <li>`codes[3]` = 3  -> 'white'</li>    <li>`codes[4]` = 2  -> 'green'</li>    <li>`codes[5]` = 1  -> 'blue'</li>    <li>`codes[6]` = 3  -> 'white'</li>    <li>`codes[7]` = 0  -> 'red'</li>    <li>`codes[8]` = 2  -> 'green'</li>  </ul>  <p>将这些值组合起来，得到的原始序列是 `['red', 'blue', 'green', 'white', 'green', 'blue', 'white', 'red', 'green']`。这与选项 C 完全匹配。</p><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 题目中描述的原始序列</span></span><br><span class="line">original_sequence = [<span class="string">&#x27;red&#x27;</span>, <span class="string">&#x27;blue&#x27;</span>, <span class="string">&#x27;green&#x27;</span>, <span class="string">&#x27;white&#x27;</span>, <span class="string">&#x27;green&#x27;</span>, <span class="string">&#x27;blue&#x27;</span>, <span class="string">&#x27;white&#x27;</span>, <span class="string">&#x27;red&#x27;</span>, <span class="string">&#x27;green&#x27;</span>]</span><br><span class="line"></span><br><span class="line"><span class="comment"># 从该序列创建 Categorical 对象</span></span><br><span class="line">cat = pd.Categorical(original_sequence)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;创建时的原始序列:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(original_sequence)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n生成的 categories 属性:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(cat.categories) <span class="comment"># 结果是按字母顺序排序的 [&#x27;blue&#x27;, &#x27;green&#x27;, &#x27;red&#x27;, &#x27;white&#x27;]</span></span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n生成的 codes 属性:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(cat.codes)</span><br><span class="line"></span><br><span class="line"><span class="comment"># --- 为了验证题目逻辑，我们用 from_codes 反向构造 ---</span></span><br><span class="line">categories_given = [<span class="string">&#x27;red&#x27;</span>, <span class="string">&#x27;blue&#x27;</span>, <span class="string">&#x27;green&#x27;</span>, <span class="string">&#x27;white&#x27;</span>]</span><br><span class="line">codes_given = [<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">3</span>, <span class="number">0</span>, <span class="number">2</span>]</span><br><span class="line"></span><br><span class="line">cat_from_codes = pd.Categorical.from_codes(codes_given, categories=categories_given)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n根据题目给出的 categories 和 codes 构造的对象:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(cat_from_codes)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>7. 若一个Categorical对象是由序列<code>[&#39;Apple&#39;, &#39;Orange&#39;, &#39;Pear&#39;, &#39;Orange&#39;, &#39;Apple&#39;]</code>所创建，…这个对象的<code>categories</code>属性是？（ ）</strong></p><p>A. <code>Index([&#39;Apple&#39;, &#39;Orange&#39;, &#39;Pear&#39;], dtype=&#39;object&#39;)</code><br>B. <code>Index([&#39;Orange&#39;, &#39;Apple&#39;, &#39;Pear&#39;], dtype=&#39;object&#39;)</code><br>C. <code>Index([&#39;Apple&#39;, &#39;Pear&#39;, &#39;Orange&#39;], dtype=&#39;object&#39;)</code><br>D. <code>Index([&#39;Orange&#39;, &#39;Pear&#39;, &#39;Apple&#39;], dtype=&#39;object&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <p>当从一个序列（如列表）创建 `pd.Categorical` 对象时，如果没有明确指定类别的顺序，Pandas 会遵循以下规则：</p>  <ol>    <li>找出序列中所有<b>唯一</b>的值。        <ul>            <li>对于 <code>['Apple', 'Orange', 'Pear', 'Orange', 'Apple']</code>，唯一的值是 <code>'Apple'</code>, <code>'Orange'</code>, <code>'Pear'</code>。</li>        </ul>    </li>    <li>将这些唯一值<b>按字母顺序（或数值大小）排序</b>，作为 `categories` 属性。        <ul>            <li>将 <code>'Apple'</code>, <code>'Orange'</code>, <code>'Pear'</code> 按字母顺序排序，得到 <code>['Apple', 'Orange', 'Pear']</code>。</li>        </ul>    </li>  </ol>  <p>因此，`categories` 属性将是一个包含 `['Apple', 'Orange', 'Pear']` 的 Pandas Index 对象。这与选项 A 完全匹配。</p>  <p>（相应的 `codes` 属性会根据这个排好序的 `categories` 来生成，例如 'Apple' 对应 0，'Orange' 对应 1，'Pear' 对应 2。）</p><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 题目中描述的原始序列</span></span><br><span class="line">original_sequence = [<span class="string">&#x27;Apple&#x27;</span>, <span class="string">&#x27;Orange&#x27;</span>, <span class="string">&#x27;Pear&#x27;</span>, <span class="string">&#x27;Orange&#x27;</span>, <span class="string">&#x27;Apple&#x27;</span>]</span><br><span class="line"></span><br><span class="line"><span class="comment"># 从该序列创建 Categorical 对象</span></span><br><span class="line">cat = pd.Categorical(original_sequence)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 打印 categories 属性</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;生成的 categories 属性:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(cat.categories)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 打印 codes 属性以验证</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n相应的 codes 属性:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(cat.codes) <span class="comment"># 结果应为 [0 1 2 1 0]</span></span><br></pre></td></tr></table></figure></p></details><hr><p><strong>8. 执行以下代码，输出的结果为（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">s = pd.Series([<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;d&#x27;</span>]*<span class="number">2</span>)</span><br><span class="line">cat_s = s.astype(<span class="string">&#x27;category&#x27;</span>)</span><br><span class="line">cat_s2 = cat_s.cat.set_categories([<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;d&#x27;</span>,<span class="string">&#x27;e&#x27;</span>])</span><br><span class="line">cat_s3 = cat_s2[cat_s2.isin([<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;e&#x27;</span>])]</span><br><span class="line">cat_s3.cat.remove_unused_categories()</span><br></pre></td></tr></table></figure><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">0    a</span><br><span class="line">4    a</span><br><span class="line">dtype: category</span><br><span class="line">Categories (1, object): [&#x27;a&#x27;]</span><br></pre></td></tr></table></figure><p>B.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">0    a</span><br><span class="line">4    a</span><br><span class="line">dtype: category</span><br><span class="line">Categories (5, object): [&#x27;a&#x27;, &#x27;b&#x27;, &#x27;c&#x27;, &#x27;d&#x27;, &#x27;e&#x27;]</span><br></pre></td></tr></table></figure><p>C.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">0    a</span><br><span class="line">4    e</span><br><span class="line">5    a</span><br><span class="line">9    e</span><br><span class="line">dtype: category</span><br><span class="line">Categories (5, object): [&#x27;a&#x27;, &#x27;b&#x27;, &#x27;c&#x27;, &#x27;d&#x27;, &#x27;e&#x27;]</span><br></pre></td></tr></table></figure><p>D.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">0    a</span><br><span class="line">4    e</span><br><span class="line">5    a</span><br><span class="line">9    e</span><br><span class="line">dtype: category</span><br><span class="line">Categories (2, object): [&#x27;a&#x27;, &#x27;e&#x27;]</span><br></pre></td></tr></table></figure><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <p>我们逐步分析代码的执行过程：</p>  <ol>    <li><b><code>s = pd.Series(['a','b','c','d']*2)</code></b>：`s` 的内容是 `['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd']`。</li>    <li><b><code>cat_s = s.astype('category')</code></b>：将 `s` 转换为分类类型，`cat_s` 的类别是 `['a', 'b', 'c', 'd']`。</li>    <li><b><code>cat_s2 = cat_s.cat.set_categories(['a','b','c','d','e'])</code></b>：重新设置类别，为 `cat_s2` 添加了新的类别 `'e'`，但数据值本身不变。此时 `cat_s2` 的类别是 `['a', 'b', 'c', 'd', 'e']`。</li>    <li><b><code>cat_s3 = cat_s2[cat_s2.isin(['a','e'])]</code></b>：      <ul>        <li><code>.isin(['a','e'])</code> 会检查 `cat_s2` 中的每个值是否是 `'a'` 或 `'e'`。</li>        <li>由于 `cat_s2` 中只有 `'a'`，没有 `'e'`，所以这个操作会筛选出所有值为 `'a'` 的行。</li>        <li>`cat_s3` 的内容是：<pre>0    a4    adtype: category</pre></li>        <li><b>重要</b>：此时 `cat_s3` 仍然<b>继承</b>了 `cat_s2` 的完整类别列表 `['a', 'b', 'c', 'd', 'e']`，尽管很多类别在 `cat_s3` 的数据中并未使用。</li>      </ul>    </li>    <li><b><code>cat_s3.cat.remove_unused_categories()</code></b>：      <ul>        <li>这个方法会检查 `cat_s3` 的数据，并移除那些在 `categories` 列表中存在但在数据中<b>未被使用</b>的类别。</li>        <li>在 `cat_s3` 中，只有类别 `'a'` 被使用了。因此，未使用的类别 `'b'`, `'c'`, `'d'`, `'e'` 都会被移除。</li>      </ul>    </li>    <li><b>最终结果</b>：数据值仍然是 `[a, a]`，但 `categories` 属性被清理后只剩下 `['a']`。这与选项 A 的内容完全一致。</li>  </ol><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 逐步执行代码以观察变化</span></span><br><span class="line">s = pd.Series([<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;d&#x27;</span>]*<span class="number">2</span>)</span><br><span class="line">cat_s = s.astype(<span class="string">&#x27;category&#x27;</span>)</span><br><span class="line">cat_s2 = cat_s.cat.set_categories([<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;d&#x27;</span>,<span class="string">&#x27;e&#x27;</span>])</span><br><span class="line">cat_s3 = cat_s2[cat_s2.isin([<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;e&#x27;</span>])]</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;筛选后的 cat_s3 (类别未清理):&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(cat_s3)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行最后的清理操作</span></span><br><span class="line">final_result = cat_s3.cat.remove_unused_categories()</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n执行 remove_unused_categories() 后的最终结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(final_result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>9. 使用<code>from_codes</code>构造函数：如下</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">categories = [<span class="string">&#x27;Lucy&#x27;</span>, <span class="string">&#x27;Daisy&#x27;</span>, <span class="string">&#x27;Lucky&#x27;</span>]</span><br><span class="line">codes = [<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">0</span>, <span class="number">0</span>, <span class="number">0</span>]</span><br><span class="line">my_c = pd.Categorical.from_codes(codes, categories)</span><br></pre></td></tr></table></figure><p><strong>则<code>my_c</code>的输出结果是：（ ）</strong></p><p>A. <code>[Lucy, Daisy, Lucky, Lucy, Lucy, Lucy]</code><br>B. <code>[Lucy, Daisy, Lucky, Daisy, Daisy, Daisy]</code><br>C. <code>[Lucy, Daisy, Lucky, Lucky, Lucky, Lucky]</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <p>`pd.Categorical.from_codes(codes, categories)` 函数通过已知的 `codes`（编码）和 `categories`（类别）来直接构造一个 Categorical 对象。`codes` 列表中的每个数字都是 `categories` 列表的索引。</p>  <p>给定的 `categories` 是 `['Lucy', 'Daisy', 'Lucky']`，其索引关系如下：</p>  <ul>    <li>0: 'Lucy'</li>    <li>1: 'Daisy'</li>    <li>2: 'Lucky'</li>  </ul>  <p>给定的 `codes` 是 `[0, 1, 2, 0, 0, 0]`。我们逐个将编码替换为对应的类别值：</p>  <ul>    <li>`codes[0]` = 0  -> 'Lucy'</li>    <li>`codes[1]` = 1  -> 'Daisy'</li>    <li>`codes[2]` = 2  -> 'Lucky'</li>    <li>`codes[3]` = 0  -> 'Lucy'</li>    <li>`codes[4]` = 0  -> 'Lucy'</li>    <li>`codes[5]` = 0  -> 'Lucy'</li>  </ul>  <p>将这些值组合起来，得到的原始序列是 `['Lucy', 'Daisy', 'Lucky', 'Lucy', 'Lucy', 'Lucy']`。当打印一个 Categorical 对象时，它会显示这个序列以及类别信息。选项 A 的列表内容与此完全匹配。</p><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 题目中的代码</span></span><br><span class="line">categories = [<span class="string">&#x27;Lucy&#x27;</span>, <span class="string">&#x27;Daisy&#x27;</span>, <span class="string">&#x27;Lucky&#x27;</span>]</span><br><span class="line">codes = [<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">0</span>, <span class="number">0</span>, <span class="number">0</span>]</span><br><span class="line">my_c = pd.Categorical.from_codes(codes, categories)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 打印 Categorical 对象</span></span><br><span class="line"><span class="built_in">print</span>(my_c)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>10. 若一个Categorical对象是由序列<code>[&#39;Apple&#39;, &#39;Orange&#39;, &#39;Pear&#39;, &#39;Orange&#39;, &#39;Apple&#39;]</code>所创建，这个对象的codes属性是[0 1 2 1 0]，这个对象的<code>categories</code>属性是？（ ）</strong></p><p>A. <code>Index([&#39;Apple&#39;, &#39;Orange&#39;, &#39;Pear&#39;], dtype=&#39;object&#39;)</code><br>B. <code>Index([&#39;Orange&#39;, &#39;Apple&#39;, &#39;Pear&#39;], dtype=&#39;object&#39;)</code><br>C. <code>Index([&#39;Apple&#39;, &#39;Pear&#39;, &#39;Orange&#39;], dtype=&#39;object&#39;)</code><br>D. <code>Index([&#39;Orange&#39;, &#39;Pear&#39;, &#39;Apple&#39;], dtype=&#39;object&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <p>此题与第 7 题完全相同。</p>  <p>当从一个序列（如列表）创建 `pd.Categorical` 对象时，如果没有明确指定类别的顺序，Pandas 会遵循以下规则：</p>  <ol>    <li>找出序列中所有<b>唯一</b>的值。        <ul>            <li>对于 <code>['Apple', 'Orange', 'Pear', 'Orange', 'Apple']</code>，唯一的值是 <code>'Apple'</code>, <code>'Orange'</code>, <code>'Pear'</code>。</li>        </ul>    </li>    <li>将这些唯一值<b>按字母顺序（或数值大小）排序</b>，作为 `categories` 属性。        <ul>            <li>将 <code>'Apple'</code>, <code>'Orange'</code>, <code>'Pear'</code> 按字母顺序排序，得到 <code>['Apple', 'Orange', 'Pear']</code>。</li>        </ul>    </li>  </ol>  <p>因此，`categories` 属性将是一个包含 `['Apple', 'Orange', 'Pear']` 的 Pandas Index 对象。这与选项 A 完全匹配。</p><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 题目中描述的原始序列</span></span><br><span class="line">original_sequence = [<span class="string">&#x27;Apple&#x27;</span>, <span class="string">&#x27;Orange&#x27;</span>, <span class="string">&#x27;Pear&#x27;</span>, <span class="string">&#x27;Orange&#x27;</span>, <span class="string">&#x27;Apple&#x27;</span>]</span><br><span class="line"></span><br><span class="line"><span class="comment"># 从该序列创建 Categorical 对象</span></span><br><span class="line">cat = pd.Categorical(original_sequence)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 打印 categories 属性</span></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;生成的 categories 属性:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(cat.categories)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>11. 已知<code>cat_s = pd.Series([&#39;a&#39;, &#39;b&#39;] * 2).astype(&#39;category&#39;)</code>，<code>cat_s2 = cat_s.cat.set_categories([&#39;a&#39;, &#39;b&#39;, &#39;c&#39;])</code>，<code>cat_s2</code>返回的是（ ）</strong></p><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">0    a</span><br><span class="line">1    b</span><br><span class="line">2    a</span><br><span class="line">3    b</span><br><span class="line">dtype: category</span><br><span class="line">Categories (2, object): [&#x27;a&#x27;, &#x27;b&#x27;]</span><br></pre></td></tr></table></figure><p>B.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">0    a</span><br><span class="line">1    b</span><br><span class="line">2    a</span><br><span class="line">3    b</span><br><span class="line">dtype: category</span><br><span class="line">Categories (3, object): [&#x27;a&#x27;, &#x27;b&#x27;, &#x27;c&#x27;]</span><br></pre></td></tr></table></figure><p>C.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">0    a</span><br><span class="line">1    b</span><br><span class="line">2    c</span><br><span class="line">dtype: category</span><br><span class="line">Categories (3, object): [&#x27;a&#x27;, &#x27;b&#x27;, &#x27;c&#x27;]</span><br></pre></td></tr></table></figure><p>D.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">0    a</span><br><span class="line">1    b</span><br><span class="line">...</span><br><span class="line">dtype: category</span><br><span class="line">Categories (5, object): [&#x27;a&#x27;, &#x27;b&#x27;, &#x27;c&#x27;]</span><br></pre></td></tr></table></figure><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`cat_s = pd.Series(['a', 'b'] * 2).astype('category')`</b>：      <ul>        <li><code>['a', 'b'] * 2</code> 创建了列表 <code>['a', 'b', 'a', 'b']</code>。</li>        <li><code>pd.Series(...)</code> 创建了包含这些值的 Series。</li>        <li><code>.astype('category')</code> 将其转换为分类类型。此时，`cat_s` 的<b>数据值</b>是 `['a', 'b', 'a', 'b']`，其<b>类别 (categories)</b> 是 `['a', 'b']`。</li>      </ul>    </li>    <li><b>`cat_s2 = cat_s.cat.set_categories(['a', 'b', 'c'])`</b>：      <ul>        <li><code>.cat.set_categories(...)</code> 方法用于<b>重新设置</b> Categorical 对象的类别列表。</li>        <li>这个操作<b>不会改变 Series 的数据值</b>，`['a', 'b', 'a', 'b']` 保持不变。</li>        <li>它只会将 `categories` 属性更新为新的列表 `['a', 'b', 'c']`。</li>      </ul>    </li>    <li><b>最终结果</b>：      <ul>        <li>数据值：`[a, b, a, b]`</li>        <li>类别：`['a', 'b', 'c']`</li>      </ul>    </li>  </ol>  <p>选项 B 的输出完全符合这个结果：数据值和索引都正确，并且 `Categories` 属性被更新为 `(3, object): ['a', 'b', 'c']`。</p><p>  <strong>正确答案：</strong> B</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 Series</span></span><br><span class="line">cat_s = pd.Series([<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>] * <span class="number">2</span>).astype(<span class="string">&#x27;category&#x27;</span>)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始 cat_s:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(cat_s)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 重新设置类别</span></span><br><span class="line">cat_s2 = cat_s.cat.set_categories([<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>])</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\ncat_s2 的结果:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(cat_s2)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>12. 已知分类转换…则代码<code>cat_s2.value_counts()</code>的输出为（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line">s = pd.Series([<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;d&#x27;</span>]*<span class="number">2</span>)</span><br><span class="line">cat_s = s.astype(<span class="string">&#x27;category&#x27;</span>)</span><br><span class="line">actual_categories = [<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;d&#x27;</span>,<span class="string">&#x27;e&#x27;</span>]</span><br><span class="line">cat_s2 = cat_s.cat.set_categories(actual_categories)</span><br></pre></td></tr></table></figure><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">a    2</span><br><span class="line">b    2</span><br><span class="line">c    2</span><br><span class="line">d    2</span><br><span class="line">e    0</span><br><span class="line">dtype: int64</span><br></pre></td></tr></table></figure><p>B. </p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">d    2</span><br><span class="line">c    2</span><br><span class="line">b    2</span><br><span class="line">a    2</span><br><span class="line">e    0</span><br><span class="line">dtype: int64</span><br></pre></td></tr></table></figure><p>C. </p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">a    2</span><br><span class="line">b    2</span><br><span class="line">c    2</span><br><span class="line">d    2</span><br><span class="line">dtype: int64</span><br></pre></td></tr></table></figure><p>D. </p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">d    2</span><br><span class="line">c    2</span><br><span class="line">b    2</span><br><span class="line">a    2</span><br><span class="line">dtype: int64</span><br></pre></td></tr></table></figure><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b><code>s = pd.Series(['a','b','c','d']*2)</code></b>：`s` 的内容是 `['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd']`。</li>    <li><b><code>cat_s = s.astype('category')</code></b>：`cat_s` 的类别是 `['a', 'b', 'c', 'd']`。</li>    <li><b><code>cat_s2 = cat_s.cat.set_categories(['a','b','c','d','e'])</code></b>：      <ul>        <li>为 `cat_s2` 重新设置了类别，加入了 `'e'`。</li>        <li>此时 `cat_s2` 的<b>数据值</b>仍然是 `['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd']`。</li>        <li>`cat_s2` 的<b>类别</b>是 `['a', 'b', 'c', 'd', 'e']`。</li>      </ul>    </li>    <li><b><code>cat_s2.value_counts()</code></b>：      <ul>        <li>该方法用于统计<b>每个类别</b>在数据中出现的次数。</li>        <li>它会统计<b>所有已定义的类别</b>，即使某个类别在数据中没有出现。</li>        <li>'a' 出现了 2 次。</li>        <li>'b' 出现了 2 次。</li>        <li>'c' 出现了 2 次。</li>        <li>'d' 出现了 2 次。</li>        <li>类别 'e' 虽然已定义，但在数据中<b>没有出现</b>，所以计数为 <b>0</b>。</li>      </ul>    </li>    <li><b>最终结果</b>：`value_counts()` 的结果是一个 Series，其索引是 `cat_s2` 的类别，值是对应的计数。默认情况下，结果会按<b>计数值降序</b>排列。</li>  </ol>  <p>选项 A 和 B 都包含了正确的计数值，包括 `e: 0`。它们的区别在于索引的顺序。`value_counts()` 默认按值（计数）降序排序，对于计数值相同的项，其顺序可能不固定。但 A 和 B 都是可能且正确的结果。</p><p>  <strong>正确答案：</strong> A (或 B，取决于排序)</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 题目中的代码</span></span><br><span class="line">s = pd.Series([<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;d&#x27;</span>]*<span class="number">2</span>)</span><br><span class="line">cat_s = s.astype(<span class="string">&#x27;category&#x27;</span>)</span><br><span class="line">actual_categories = [<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;d&#x27;</span>,<span class="string">&#x27;e&#x27;</span>]</span><br><span class="line">cat_s2 = cat_s.cat.set_categories(actual_categories)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行 value_counts()</span></span><br><span class="line">result = cat_s2.value_counts()</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>13. 设有数据集<code>df=pd.DataFrame(&#123;&#39;key&#39;:[&#39;a&#39;,&#39;b&#39;,&#39;c&#39;]*2, &#39;value&#39;:np.arange(6)&#125;)</code>，执行<code>df[&#39;value&#39;].groupby(df[&#39;key&#39;]).transform(&#39;mean&#39;)</code>后得到的结果是（ ）</strong></p><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">key</span><br><span class="line">a    1.5</span><br><span class="line">b    2.5</span><br><span class="line">c    3.5</span><br></pre></td></tr></table></figure><p>B.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line">  key  value</span><br><span class="line">0   a    1.5</span><br><span class="line">1   b    2.5</span><br><span class="line">2   c    3.5</span><br><span class="line">3   a    1.5</span><br><span class="line">4   b    2.5</span><br><span class="line">5   c    3.5</span><br><span class="line"></span><br></pre></td></tr></table></figure><p>C.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">0    1.5</span><br><span class="line">1    2.5</span><br><span class="line">2    3.5</span><br><span class="line">3    1.5</span><br><span class="line">4    2.5</span><br><span class="line">5    3.5</span><br></pre></td></tr></table></figure><p>D.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">key</span><br><span class="line">a    3.0</span><br><span class="line">b    3.0</span><br><span class="line">c    3.0</span><br></pre></td></tr></table></figure><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>创建 DataFrame `df`</b>：<pre>  key  value0   a      01   b      12   c      23   a      34   b      45   c      5</pre></li>    <li><b>`df['value'].groupby(df['key'])`</b>：这是一个“Series GroupBy”操作。      <ul>        <li>我们选择了 `df['value']` 这一列（一个 Series）。</li>        <li>然后使用 `df['key']` 这一列作为分组键对其进行分组。</li>        <li>分组情况如下：          <ul>            <li>组 'a': 包含 `value` 列的 `0` 和 `3`。</li>            <li>组 'b': 包含 `value` 列的 `1` 和 `4`。</li>            <li>组 'c': 包含 `value` 列的 `2` 和 `5`。</li>          </ul>        </li>      </ul>    </li>    <li><b>`.transform('mean')`</b>：      <ul>        <li><code>transform</code> 方法会对每个分组进行计算（这里是计算均值），然后返回一个与<b>原始对象形状相同</b>的 Series/DataFrame。</li>        <li>计算每个组的均值：          <ul>            <li>组 'a' 的均值: `(0 + 3) / 2 = 1.5`。</li>            <li>组 'b' 的均值: `(1 + 4) / 2 = 2.5`。</li>            <li>组 'c' 的均值: `(2 + 5) / 2 = 3.5`。</li>          </ul>        </li>        <li><code>transform</code> 会将计算出的分组均值“广播”回原始的索引位置。</li>      </ul>    </li>    <li><b>最终结果</b>：操作会返回一个与 `df['value']` 等长的 Series，其索引是原始的 `0..5`，值为每个元素所在分组的均值。这与选项 C 的内容完全一致。<pre>0    1.5  (属于组 'a')1    2.5  (属于组 'b')2    3.5  (属于组 'c')3    1.5  (属于组 'a')4    2.5  (属于组 'b')5    3.5  (属于组 'c')</pre></li>  </ol>  <p>（注：如果是使用 <code>.agg('mean')</code> 或 <code>.apply('mean')</code>，结果会是选项 A 的形式，即聚合后的结果。）</p><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 DataFrame</span></span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;key&#x27;</span>:[<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>]*<span class="number">2</span>, <span class="string">&#x27;value&#x27;</span>:np.arange(<span class="number">6</span>)&#125;)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行 transform 操作</span></span><br><span class="line">result = df[<span class="string">&#x27;value&#x27;</span>].groupby(df[<span class="string">&#x27;key&#x27;</span>]).transform(<span class="string">&#x27;mean&#x27;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 打印结果</span></span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>14. <code>df.set_index(&#39;time&#39;).resample(&#39;5min&#39;).count()</code>的输出结果是：（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">times = pd.date_range(<span class="string">&#x27;2019-07-10 00:00&#x27;</span>, freq=<span class="string">&#x27;1min&#x27;</span>, periods=<span class="number">15</span>)</span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;time&#x27;</span>: times, <span class="string">&#x27;value&#x27;</span>: np.arange(<span class="number">15</span>)&#125;)</span><br></pre></td></tr></table></figure><p>A.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">           value</span><br><span class="line">time              </span><br><span class="line">2019-07-10      15</span><br></pre></td></tr></table></figure><p>B.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">                     value</span><br><span class="line">time                      </span><br><span class="line">2019-07-10 00:00:00      3</span><br><span class="line">2019-07-10 00:03:00      3</span><br><span class="line">2019-07-10 00:06:00      3</span><br><span class="line">2019-07-10 00:09:00      3</span><br><span class="line">2019-07-10 00:12:00      3</span><br></pre></td></tr></table></figure><p>C.</p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">                     value</span><br><span class="line">time                      </span><br><span class="line">2019-07-10 00:00:00      5</span><br><span class="line">2019-07-10 00:05:00      5</span><br><span class="line">2019-07-10 00:10:00      5</span><br></pre></td></tr></table></figure><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b><code>df.set_index('time')</code></b>：首先，将 `'time'` 列设置为 DataFrame 的索引，使其成为一个时间序列。</li>    <li><b><code>.resample('5min')</code></b>：接着，对这个时间序列进行<b>重采样 (resample)</b>。      <ul>        <li><code>'5min'</code> 表示按 5 分钟的频率进行。</li>        <li>这个操作会根据时间索引将数据划分到不同的时间“箱子”里。默认情况下，时间箱是左闭右开的。          <ul>            <li><b>第一个箱</b>：`[2019-07-10 00:00:00, 2019-07-10 00:05:00)`，包含 `00:00` 到 `00:04` 的数据。</li>            <li><b>第二个箱</b>：`[2019-07-10 00:05:00, 2019-07-10 00:10:00)`，包含 `00:05` 到 `00:09` 的数据。</li>            <li><b>第三个箱</b>：`[2019-07-10 00:10:00, 2019-07-10 00:15:00)`，包含 `00:10` 到 `00:14` 的数据。</li>          </ul>        </li>      </ul>    </li>    <li><b><code>.count()</code></b>：最后，对每个时间箱内的数据进行<b>计数</b>。      <ul>        <li>第一个箱 (`00:00` 到 `00:04`) 包含 5 条记录 (因为原始数据是每分钟一条)。</li>        <li>第二个箱 (`00:05` 到 `00:09`) 包含 5 条记录。</li>        <li>第三个箱 (`00:10` 到 `00:14`) 包含 5 条记录。</li>      </ul>    </li>    <li><b>最终结果</b>：结果 DataFrame 的索引是每个时间箱的起始时间，值为每个箱的记录数。这与选项 C 的内容完全一致。</li>  </ol><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 DataFrame</span></span><br><span class="line">times = pd.date_range(<span class="string">&#x27;2019-07-10 00:00&#x27;</span>, freq=<span class="string">&#x27;1min&#x27;</span>, periods=<span class="number">15</span>)</span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;time&#x27;</span>: times, <span class="string">&#x27;value&#x27;</span>: np.arange(<span class="number">15</span>)&#125;)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行重采样和计数操作</span></span><br><span class="line">result = df.set_index(<span class="string">&#x27;time&#x27;</span>).resample(<span class="string">&#x27;5min&#x27;</span>).count()</span><br><span class="line"></span><br><span class="line"><span class="comment"># 打印结果</span></span><br><span class="line"><span class="built_in">print</span>(result)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>15. 对于 <code>df</code>，<code>c = df[&#39;count&#39;].astype(&#39;category&#39;).values</code>，<code>c.codes</code> 的执行结果是什么（ ）</strong></p><pre>  basket_id   fruit  count    weight0          0   apple     11  2.3579031          1  orange      7  0.1408992          2   apple      5  1.8430443          3   apple     13  3.5150994          4   apple     13  2.2569935          5  orange      7  3.7489836          6   apple      9  2.4590817          7   apple     12  0.977361</pre><p>A. <code>array([3, 1, 0, 5, 5, 1, 2, 4], dtype=int8)</code><br>B. <code>array([1, 3, 0, 5, 5, 1, 2, 4], dtype=int8)</code><br>C. <code>array([3, 1, 5, 5, 5, 1, 2, 4], dtype=int8)</code><br>D. <code>array([3, 1, 0, 4, 5, 1, 2, 4], dtype=int8)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ol>    <li><b>`df['count']`</b>：首先，我们选择 `'count'` 这一列，其值为 `[11, 7, 5, 13, 13, 7, 9, 12]`。</li>    <li><b>`.astype('category')`</b>：接着，将这一列转换为分类类型。Pandas 会自动执行以下步骤：      <ul>        <li>找出所有<b>唯一</b>的值：`5, 7, 9, 11, 12, 13`。</li>        <li>将这些唯一值<b>按数值大小排序</b>，作为 `categories`：`[5, 7, 9, 11, 12, 13]`。</li>      </ul>    </li>    <li><b>`.values`</b>：获取这个分类 Series 底层的 `pd.Categorical` 对象，变量 `c` 引用了它。</li>    <li><b>`c.codes`</b>：获取这个 `Categorical` 对象的编码 (`codes`) 属性。编码是原始数据中每个值对应于排好序的 `categories` 的索引。      <ul>        <li>`categories` 的索引关系是：`5`->0, `7`->1, `9`->2, `11`->3, `12`->4, `13`->5。</li>      </ul>    </li>    <li><b>逐个编码</b>：      <ul>        <li>`11` -> 索引 <b>3</b></li>        <li>`7` -> 索引 <b>1</b></li>        <li>`5` -> 索引 <b>0</b></li>        <li>`13` -> 索引 <b>5</b></li>        <li>`13` -> 索引 <b>5</b></li>        <li>`7` -> 索引 <b>1</b></li>        <li>`9` -> 索引 <b>2</b></li>        <li>`12` -> 索引 <b>4</b></li>      </ul>    </li>    <li><b>最终结果</b>：`c.codes` 返回的 NumPy 数组是 `[3, 1, 0, 5, 5, 1, 2, 4]`。这与选项 A 完全匹配。</li>  </ol><p>  <strong>正确答案：</strong> A</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 DataFrame</span></span><br><span class="line">data = &#123;<span class="string">&#x27;basket_id&#x27;</span>: <span class="built_in">range</span>(<span class="number">8</span>),</span><br><span class="line">        <span class="string">&#x27;fruit&#x27;</span>: [<span class="string">&#x27;apple&#x27;</span>, <span class="string">&#x27;orange&#x27;</span>, <span class="string">&#x27;apple&#x27;</span>, <span class="string">&#x27;apple&#x27;</span>, <span class="string">&#x27;apple&#x27;</span>, <span class="string">&#x27;orange&#x27;</span>, <span class="string">&#x27;apple&#x27;</span>, <span class="string">&#x27;apple&#x27;</span>],</span><br><span class="line">        <span class="string">&#x27;count&#x27;</span>: [<span class="number">11</span>, <span class="number">7</span>, <span class="number">5</span>, <span class="number">13</span>, <span class="number">13</span>, <span class="number">7</span>, <span class="number">9</span>, <span class="number">12</span>],</span><br><span class="line">        <span class="string">&#x27;weight&#x27;</span>: np.random.rand(<span class="number">8</span>) * <span class="number">4</span>&#125;</span><br><span class="line">df = pd.DataFrame(data)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 执行题目中的代码</span></span><br><span class="line">c = df[<span class="string">&#x27;count&#x27;</span>].astype(<span class="string">&#x27;category&#x27;</span>).values</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;排好序的类别 (categories):&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(c.categories)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n对应的编码 (codes):&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(c.codes)</span><br></pre></td></tr></table></figure></p></details><hr><p><strong>16. 下列说法正确的是 ( )</strong><br>A. 使用<code>TimeGrouper</code>的一个限制是时间必须是<code>Series</code>或<code>DataFrame</code><br>B. <code>agg</code>不可以使用lambda表达式<br>C. <code>transform</code>可以使用‘mean’<br>D. <code>apply</code>可以传入‘mean’</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <ul>    <li>A: 错误。`TimeGrouper` (现在是 `pd.Grouper(freq=...)`) 的限制是分组的轴必须是 `DatetimeIndex`。</li>    <li>B: 错误。`agg` 可以使用 lambda 表达式。</li>    <li><b>C: 正确</b>。`transform` 可以接受如 `'mean'`, `'sum'` 等字符串作为参数，进行快速计算。</li>    <li>D: 错误。`apply` 期望传入一个函数对象，而不是字符串 `'mean'`。应为 `apply(np.mean)`。</li>  </ul><p>  <strong>正确答案：</strong> C</p></details><hr><p><strong>17. 对于 <code>s = pd.Series([&#39;a&#39;, &#39;b&#39;, &#39;c&#39;]*2); cat_s = s.astype(&#39;category&#39;)</code>，可以新增’d’类别的语句是（ ）</strong></p><p>A. <code>cat_s.add_categories(&#39;d&#39;)</code><br>B. <code>s.add_categories(&#39;d&#39;)</code><br>C. <code>cat_s.cat.add_categories(&#39;d&#39;)</code><br>D. <code>s.cat.add_categories(&#39;d&#39;)</code></p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <p>在 Pandas 中，对于一个分类类型（categorical dtype）的 Series，所有与分类相关的操作都需要通过 <code>.cat</code> 访问器来调用。</p>  <ul>    <li><b><code>cat_s</code></b>：是一个分类类型的 Series。</li>    <li><b><code>s</code></b>：是一个普通的 `object` 类型的 Series。</li>  </ul>  <p>我们来分析每个选项：</p>  <ul>    <li><b>A. `cat_s.add_categories('d')`</b>：错误。Series 对象本身没有 <code>.add_categories()</code> 方法，必须通过 <code>.cat</code> 访问器。</li>    <li><b>B. `s.add_categories('d')`</b>：错误。<code>s</code> 是一个普通 Series，没有分类方法。</li>    <li><b>C. `cat_s.cat.add_categories('d')`</b>：<b>正确</b>。这是标准的语法：首先选择分类 Series `cat_s`，然后使用 <code>.cat</code> 访问器，最后调用 <code>.add_categories()</code> 方法来添加新的类别。</li>    <li><b>D. `s.cat.add_categories('d')`</b>：错误。<code>s</code> 不是分类类型，因此它没有 <code>.cat</code> 访问器。</li>  </ul><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的 Series</span></span><br><span class="line">s = pd.Series([<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>]*<span class="number">2</span>)</span><br><span class="line">cat_s = s.astype(<span class="string">&#x27;category&#x27;</span>)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;原始类别:&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(cat_s.cat.categories)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 使用正确的方法新增类别 &#x27;d&#x27;</span></span><br><span class="line">cat_s_new = cat_s.cat.add_categories(<span class="string">&#x27;d&#x27;</span>)</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;\n新增类别后的新 Series:&quot;</span>)</span><br><span class="line"><span class="comment"># 注意：add_categories 返回一个新的 Categorical 对象，需要重新赋值</span></span><br><span class="line"><span class="built_in">print</span>(cat_s_new.cat.categories) </span><br></pre></td></tr></table></figure></p></details><hr><p><strong>18. <code>g.transform(lambda x: x.mean())</code> 与下列代码的哪个输出结果相同？（ ）</strong></p><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;key&#x27;</span>: [<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>] * <span class="number">4</span>,</span><br><span class="line">                   <span class="string">&#x27;value&#x27;</span>: np.arange(<span class="number">12.</span>)&#125;)</span><br><span class="line">g = df.groupby(<span class="string">&#x27;key&#x27;</span>)[<span class="string">&#x27;value&#x27;</span>] <span class="comment"># 修正了题目中的 g 的定义，使其更明确</span></span><br></pre></td></tr></table></figure><p>A. <code>g.agg(lambda x: x.mean())</code><br>B. <code>g.apply(lambda x: x.mean())</code><br>C. 上面两种都不与之匹配</p><details>  <summary style="font-weight: bold; cursor: pointer; color: #007bff;">点击查看解析与代码</summary>  <br>  解析：  <p>这道题的核心是理解 GroupBy 对象上 <code>transform</code>, <code>agg</code>, 和 <code>apply</code> 三个方法的区别，特别是它们返回结果的<b>形状</b>。</p>  <ul>    <li><b><code>transform</code></b>：      <ul>        <li>对每个分组进行计算，然后返回一个与<b>原始对象形状和索引相同</b>的 Series 或 DataFrame。</li>        <li>它将每个分组的计算结果（如均值）“广播”回该分组的所有原始位置。</li>        <li>例如，`g.transform('mean')` 会返回一个长度为 12 的 Series，其索引与 `df` 相同。</li>      </ul>    </li>    <li><b><code>agg</code> (或 `aggregate`)</b>：      <ul>        <li>对每个分组进行计算，然后返回一个<b>聚合后</b>的、尺寸更小的对象。</li>        <li>其<b>索引</b>将是分组的键（即 `'a'`, `'b'`, `'c'`）。</li>        <li>例如，`g.agg('mean')` 会返回一个长度为 3 的 Series，其索引是 `['a', 'b', 'c']`。</li>      </ul>    </li>    <li><b><code>apply</code></b>：      <ul>        <li>`apply` 更通用，但当它用于返回单个标量（如均值）的聚合函数时，其行为与 `agg` 类似，返回一个<b>聚合后</b>的结果。</li>        <li>其索引也将是分组的键。</li>      </ul>    </li>  </ul>  <p><b>结论</b>：因为 <code>transform</code> 返回的结果形状与原始数据相同，而 <code>agg</code> 和 `apply` 返回的是聚合后的、形状更小的结果，所以 <code>transform</code> 的输出与后两者都<b>不相同</b>。</p><p>  <strong>正确答案：</strong> C</p><p>  <strong>代码示例：</strong><br>  <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> pandas <span class="keyword">as</span> pd</span><br><span class="line"><span class="keyword">import</span> numpy <span class="keyword">as</span> np</span><br><span class="line"></span><br><span class="line"><span class="comment"># 创建题目中的数据</span></span><br><span class="line">df = pd.DataFrame(&#123;<span class="string">&#x27;key&#x27;</span>: [<span class="string">&#x27;a&#x27;</span>, <span class="string">&#x27;b&#x27;</span>, <span class="string">&#x27;c&#x27;</span>] * <span class="number">4</span>,</span><br><span class="line">                   <span class="string">&#x27;value&#x27;</span>: np.arange(<span class="number">12.</span>)&#125;)</span><br><span class="line">g = df.groupby(<span class="string">&#x27;key&#x27;</span>)[<span class="string">&#x27;value&#x27;</span>]</span><br><span class="line"></span><br><span class="line"><span class="comment"># 计算 transform 的结果</span></span><br><span class="line">transform_result = g.transform(<span class="keyword">lambda</span> x: x.mean())</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;--- g.transform() 的结果 (与原始df索引相同) ---&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(transform_result)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Shape: <span class="subst">&#123;transform_result.shape&#125;</span>\n&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 计算 agg 的结果</span></span><br><span class="line">agg_result = g.agg(<span class="keyword">lambda</span> x: x.mean())</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;--- g.agg() 的结果 (索引为分组键) ---&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(agg_result)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Shape: <span class="subst">&#123;agg_result.shape&#125;</span>\n&quot;</span>)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 计算 apply 的结果</span></span><br><span class="line">apply_result = g.apply(<span class="keyword">lambda</span> x: x.mean())</span><br><span class="line"><span class="built_in">print</span>(<span class="string">&quot;--- g.apply() 的结果 (索引为分组键) ---&quot;</span>)</span><br><span class="line"><span class="built_in">print</span>(apply_result)</span><br><span class="line"><span class="built_in">print</span>(<span class="string">f&quot;Shape: <span class="subst">&#123;apply_result.shape&#125;</span>\n&quot;</span>)</span><br></pre></td></tr></table></figure></p></details>]]>
    </content>
    <id>https://cccignore.github.io/2025/06/20/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/</id>
    <link href="https://cccignore.github.io/2025/06/20/Python%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E9%80%89%E6%8B%A9%E9%A2%98%E6%95%B4%E7%90%86/"/>
    <published>2025-06-20T04:04:41.000Z</published>
    <summary>
      <![CDATA[<!-- 文章摘要，会显示在首页 -->]]>
    </summary>
    <title>Python数据分析选择题整理</title>
    <updated>2025-06-20T04:04:41.000Z</updated>
  </entry>
  <entry>
    <author>
      <name>Enoch</name>
    </author>
    <category term="技术教程" scheme="https://cccignore.github.io/categories/%E6%8A%80%E6%9C%AF%E6%95%99%E7%A8%8B/"/>
    <category term="Web开发" scheme="https://cccignore.github.io/categories/%E6%8A%80%E6%9C%AF%E6%95%99%E7%A8%8B/Web%E5%BC%80%E5%8F%91/"/>
    <category term="科学上网" scheme="https://cccignore.github.io/tags/%E7%A7%91%E5%AD%A6%E4%B8%8A%E7%BD%91/"/>
    <content>
      <![CDATA[<p>很多人对于<strong>翻墙</strong>可能都比较陌生，但在学术探索方面，很多时候需要连接外网来获取一些资源。本篇文章就简单分享一下我个人的科学上网方案，成本很低的同时使用体验也不错。那废话不多说直接开始吧！</p><span id="more"></span><h2 id="前置任务"><a href="#前置任务" class="headerlink" title="前置任务"></a>前置任务</h2><p>因为进入购买节点的网站本身就需要vpn，所以先短暂借助一下免费但勉强能用的浏览器插件</p><p><img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/%E4%BD%8E%E6%88%90%E6%9C%AC%E6%A2%AF%E5%AD%90-%E8%B5%94%E9%92%B1%E6%9C%BA%E5%9C%BA/1.png" alt="这里填写图片1的描述"></p><p>首先点击浏览器（这里以edge为例）右上角三个点，在下拉的菜单栏中找到扩展并点击</p><p><img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/%E4%BD%8E%E6%88%90%E6%9C%AC%E6%A2%AF%E5%AD%90-%E8%B5%94%E9%92%B1%E6%9C%BA%E5%9C%BA/2.png" alt="这里填写图片2的描述"></p><p>再点击新弹出小窗口中的<strong>获取Microsoft Edge扩展</strong>进入“扩展商店”</p><p><img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/%E4%BD%8E%E6%88%90%E6%9C%AC%E6%A2%AF%E5%AD%90-%E8%B5%94%E9%92%B1%E6%9C%BA%E5%9C%BA/3.jpg" alt="这里填写图片3的描述"></p><p>在右上角搜索框搜索“free vpn”得到以下结果</p><p><img src="https://cdn.jsdelivr.net/gh/cccignore/my-blog-images/%E4%BD%8E%E6%88%90%E6%9C%AC%E6%A2%AF%E5%AD%90-%E8%B5%94%E9%92%B1%E6%9C%BA%E5%9C%BA/4.png" alt="这里填写图片4的描述"></p><p>下拉找到我标红的这个<strong>1VPN</strong>（目前这个我亲测是ok的）</p>]]>
    </content>
    <id>https://cccignore.github.io/2025/06/18/%E4%BD%8E%E6%88%90%E6%9C%AC%E6%A2%AF%E5%AD%90-%E8%B5%94%E9%92%B1%E6%9C%BA%E5%9C%BA/</id>
    <link href="https://cccignore.github.io/2025/06/18/%E4%BD%8E%E6%88%90%E6%9C%AC%E6%A2%AF%E5%AD%90-%E8%B5%94%E9%92%B1%E6%9C%BA%E5%9C%BA/"/>
    <published>2025-06-17T17:24:26.000Z</published>
    <summary>
      <![CDATA[<p>很多人对于<strong>翻墙</strong>可能都比较陌生，但在学术探索方面，很多时候需要连接外网来获取一些资源。本篇文章就简单分享一下我个人的科学上网方案，成本很低的同时使用体验也不错。那废话不多说直接开始吧！</p>]]>
    </summary>
    <title>低成本梯子-赔钱机场</title>
    <updated>2025-06-17T17:24:26.000Z</updated>
  </entry>
  <entry>
    <author>
      <name>Enoch</name>
    </author>
    <category term="技术教程" scheme="https://cccignore.github.io/categories/%E6%8A%80%E6%9C%AF%E6%95%99%E7%A8%8B/"/>
    <category term="博客搭建" scheme="https://cccignore.github.io/categories/%E6%8A%80%E6%9C%AF%E6%95%99%E7%A8%8B/%E5%8D%9A%E5%AE%A2%E6%90%AD%E5%BB%BA/"/>
    <category term="Hexo" scheme="https://cccignore.github.io/tags/Hexo/"/>
    <category term="Butterfly" scheme="https://cccignore.github.io/tags/Butterfly/"/>
    <category term="GitHub Pages" scheme="https://cccignore.github.io/tags/GitHub-Pages/"/>
    <category term="Live2D" scheme="https://cccignore.github.io/tags/Live2D/"/>
    <category term="博客" scheme="https://cccignore.github.io/tags/%E5%8D%9A%E5%AE%A2/"/>
    <content>
      <![CDATA[<h1 id="博客搭建完整教程"><a href="#博客搭建完整教程" class="headerlink" title="博客搭建完整教程"></a>博客搭建完整教程</h1><blockquote><p>基于 Hexo + Butterfly 主题 + GitHub Pages 的完整博客搭建指南</p></blockquote><p><img src="/img/blog-tutorial/cover.svg" alt="博客搭建教程封面"></p><h2 id="目录"><a href="#目录" class="headerlink" title="目录"></a>目录</h2><ol><li><a href="#1-%E7%8E%AF%E5%A2%83%E5%87%86%E5%A4%87">环境准备</a></li><li><a href="#2-hexo-%E5%AE%89%E8%A3%85%E4%B8%8E%E5%88%9D%E5%A7%8B%E5%8C%96">Hexo 安装与初始化</a></li><li><a href="#3-butterfly-%E4%B8%BB%E9%A2%98%E5%AE%89%E8%A3%85">Butterfly 主题安装</a></li><li><a href="#4-live2d-%E7%9C%8B%E6%9D%BF%E5%A8%98%E9%85%8D%E7%BD%AE">Live2D 看板娘配置</a></li><li><a href="#5-giscus-%E8%AF%84%E8%AE%BA%E7%B3%BB%E7%BB%9F">Giscus 评论系统</a></li><li><a href="#6-%E6%90%9C%E7%B4%A2%E5%8A%9F%E8%83%BD%E9%85%8D%E7%BD%AE">搜索功能配置</a></li><li><a href="#7-%E8%87%AA%E5%AE%9A%E4%B9%89%E6%A0%B7%E5%BC%8F">自定义样式</a></li><li><a href="#8-%E5%88%9B%E5%BB%BA%E9%A1%B5%E9%9D%A2%E5%92%8C%E6%96%87%E7%AB%A0">创建页面和文章</a></li><li><a href="#9-%E9%83%A8%E7%BD%B2%E5%88%B0-github-pages">部署到 GitHub Pages</a></li><li><a href="#10-%E8%BF%9B%E9%98%B6%E9%85%8D%E7%BD%AE">进阶配置</a></li></ol><h2 id="1-环境准备"><a href="#1-环境准备" class="headerlink" title="1. 环境准备"></a>1. 环境准备</h2><h3 id="1-1-Node-js-安装"><a href="#1-1-Node-js-安装" class="headerlink" title="1.1 Node.js 安装"></a>1.1 Node.js 安装</h3><p>访问 <a href="https://nodejs.org/">Node.js 官网</a> 下载并安装 LTS 版本。</p><p>安装完成后，打开终端验证：</p><p><img src="/img/blog-tutorial/nodejs-version.svg" alt="Node.js版本验证"></p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">node --version</span><br><span class="line">npm --version</span><br></pre></td></tr></table></figure><h3 id="1-2-Git-安装"><a href="#1-2-Git-安装" class="headerlink" title="1.2 Git 安装"></a>1.2 Git 安装</h3><p>访问 <a href="https://git-scm.com/">Git 官网</a> 下载并安装。</p><p>配置 Git 用户信息：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">git config --global user.name <span class="string">&quot;你的用户名&quot;</span></span><br><span class="line">git config --global user.email <span class="string">&quot;你的邮箱&quot;</span></span><br></pre></td></tr></table></figure><h2 id="2-Hexo-安装与初始化"><a href="#2-Hexo-安装与初始化" class="headerlink" title="2. Hexo 安装与初始化"></a>2. Hexo 安装与初始化</h2><h3 id="2-1-安装-Hexo-CLI"><a href="#2-1-安装-Hexo-CLI" class="headerlink" title="2.1 安装 Hexo CLI"></a>2.1 安装 Hexo CLI</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">npm install -g hexo-cli</span><br></pre></td></tr></table></figure><h3 id="2-2-初始化博客"><a href="#2-2-初始化博客" class="headerlink" title="2.2 初始化博客"></a>2.2 初始化博客</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 初始化 Hexo 博客</span></span><br><span class="line">hexo init myblog</span><br><span class="line"><span class="built_in">cd</span> myblog</span><br><span class="line">npm install</span><br><span class="line"></span><br><span class="line"><span class="comment"># 启动本地服务器</span></span><br><span class="line">hexo server</span><br></pre></td></tr></table></figure><p><img src="/img/blog-tutorial/hexo-init.svg" alt="Hexo初始化过程"></p><p>访问 <code>http://localhost:4000</code> 查看默认博客。</p><h3 id="2-3-博客文件夹结构"><a href="#2-3-博客文件夹结构" class="headerlink" title="2.3 博客文件夹结构"></a>2.3 博客文件夹结构</h3><p><img src="/img/blog-tutorial/folder-structure.svg" alt="博客文件夹结构"></p><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line">myblog/</span><br><span class="line">├── _config.yml          # 站点配置文件</span><br><span class="line">├── package.json         # 依赖管理</span><br><span class="line">├── scaffolds/           # 文章模板</span><br><span class="line">├── source/              # 源文件目录</span><br><span class="line">│   ├── _drafts/         # 草稿</span><br><span class="line">│   └── _posts/          # 文章</span><br><span class="line">├── themes/              # 主题目录</span><br><span class="line">└── public/              # 生成的静态文件</span><br></pre></td></tr></table></figure><h2 id="3-Butterfly-主题安装"><a href="#3-Butterfly-主题安装" class="headerlink" title="3. Butterfly 主题安装"></a>3. Butterfly 主题安装</h2><h3 id="3-1-下载-Butterfly-主题"><a href="#3-1-下载-Butterfly-主题" class="headerlink" title="3.1 下载 Butterfly 主题"></a>3.1 下载 Butterfly 主题</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 克隆主题到 themes 目录</span></span><br><span class="line">git <span class="built_in">clone</span> -b master https://github.com/jerryc127/hexo-theme-butterfly.git themes/butterfly</span><br><span class="line"></span><br><span class="line"><span class="comment"># 安装必要的渲染器</span></span><br><span class="line">npm install hexo-renderer-pug hexo-renderer-stylus --save</span><br></pre></td></tr></table></figure><p><img src="/img/blog-tutorial/butterfly-install.svg" alt="Butterfly主题安装"></p><h3 id="3-2-启用主题"><a href="#3-2-启用主题" class="headerlink" title="3.2 启用主题"></a>3.2 启用主题</h3><p>修改根目录下的 <code>_config.yml</code>：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line"><span class="attr">theme:</span> <span class="string">butterfly</span></span><br></pre></td></tr></table></figure><h3 id="3-3-复制主题配置文件"><a href="#3-3-复制主题配置文件" class="headerlink" title="3.3 复制主题配置文件"></a>3.3 复制主题配置文件</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">cp</span> themes/butterfly/_config.yml _config.butterfly.yml</span><br></pre></td></tr></table></figure><h3 id="3-4-基础配置"><a href="#3-4-基础配置" class="headerlink" title="3.4 基础配置"></a>3.4 基础配置</h3><p>编辑 <code>_config.butterfly.yml</code>：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 导航菜单</span></span><br><span class="line"><span class="attr">menu:</span></span><br><span class="line">  <span class="string">首页:</span> <span class="string">/</span> <span class="string">||</span> <span class="string">fas</span> <span class="string">fa-home</span></span><br><span class="line">  <span class="string">归档:</span> <span class="string">/archives/</span> <span class="string">||</span> <span class="string">fas</span> <span class="string">fa-archive</span></span><br><span class="line">  <span class="string">标签:</span> <span class="string">/tags/</span> <span class="string">||</span> <span class="string">fas</span> <span class="string">fa-tags</span></span><br><span class="line">  <span class="string">分类:</span> <span class="string">/categories/</span> <span class="string">||</span> <span class="string">fas</span> <span class="string">fa-folder-open</span></span><br><span class="line">  <span class="string">关于:</span> <span class="string">/about/</span> <span class="string">||</span> <span class="string">fas</span> <span class="string">fa-heart</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 网站图标</span></span><br><span class="line"><span class="attr">favicon:</span> <span class="string">/img/favicon.ico</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 头像</span></span><br><span class="line"><span class="attr">avatar:</span></span><br><span class="line">  <span class="attr">img:</span> <span class="string">/img/avatar.jpg</span></span><br><span class="line">  <span class="attr">effect:</span> <span class="literal">false</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 网站副标题</span></span><br><span class="line"><span class="attr">subtitle:</span></span><br><span class="line">  <span class="attr">enable:</span> <span class="literal">true</span></span><br><span class="line">  <span class="attr">sub1:</span> <span class="string">欢迎来到我的博客</span></span><br><span class="line">  <span class="attr">sub2:</span> <span class="string">分享技术与生活</span></span><br></pre></td></tr></table></figure><h2 id="4-Live2D-看板娘配置"><a href="#4-Live2D-看板娘配置" class="headerlink" title="4. Live2D 看板娘配置"></a>4. Live2D 看板娘配置</h2><p><img src="/img/blog-tutorial/live2d-config.svg" alt="Live2D看板娘配置"></p><h3 id="4-1-安装-Live2D-插件"><a href="#4-1-安装-Live2D-插件" class="headerlink" title="4.1 安装 Live2D 插件"></a>4.1 安装 Live2D 插件</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">npm install hexo-helper-live2d --save</span><br><span class="line">npm install live2d-widget-model-haru --save</span><br></pre></td></tr></table></figure><h3 id="4-2-配置-Live2D"><a href="#4-2-配置-Live2D" class="headerlink" title="4.2 配置 Live2D"></a>4.2 配置 Live2D</h3><p>在根目录 <code>_config.yml</code> 中添加：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br></pre></td><td class="code"><pre><span class="line"><span class="attr">live2d:</span></span><br><span class="line">  <span class="attr">enable:</span> <span class="literal">true</span></span><br><span class="line">  <span class="attr">scriptFrom:</span> <span class="string">local</span></span><br><span class="line">  <span class="attr">pluginRootPath:</span> <span class="string">live2dw/</span></span><br><span class="line">  <span class="attr">pluginJsPath:</span> <span class="string">lib/</span></span><br><span class="line">  <span class="attr">pluginModelPath:</span> <span class="string">assets/</span></span><br><span class="line">  <span class="attr">tagMode:</span> <span class="literal">false</span></span><br><span class="line">  <span class="attr">debug:</span> <span class="literal">false</span></span><br><span class="line">  <span class="attr">model:</span></span><br><span class="line">    <span class="attr">use:</span> <span class="string">live2d-widget-model-haru</span></span><br><span class="line">  <span class="attr">display:</span></span><br><span class="line">    <span class="attr">position:</span> <span class="string">right</span></span><br><span class="line">    <span class="attr">width:</span> <span class="number">150</span></span><br><span class="line">    <span class="attr">height:</span> <span class="number">300</span></span><br><span class="line">  <span class="attr">mobile:</span></span><br><span class="line">    <span class="attr">show:</span> <span class="literal">false</span></span><br><span class="line">  <span class="attr">react:</span></span><br><span class="line">    <span class="attr">opacity:</span> <span class="number">0.7</span></span><br></pre></td></tr></table></figure><h3 id="4-3-可选模型"><a href="#4-3-可选模型" class="headerlink" title="4.3 可选模型"></a>4.3 可选模型</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 其他可选模型</span></span><br><span class="line">npm install live2d-widget-model-shizuku --save</span><br><span class="line">npm install live2d-widget-model-miku --save</span><br><span class="line">npm install live2d-widget-model-wanko --save</span><br></pre></td></tr></table></figure><h2 id="5-Giscus-评论系统"><a href="#5-Giscus-评论系统" class="headerlink" title="5. Giscus 评论系统"></a>5. Giscus 评论系统</h2><h3 id="5-1-准备工作"><a href="#5-1-准备工作" class="headerlink" title="5.1 准备工作"></a>5.1 准备工作</h3><ol><li>创建 GitHub 公开仓库用于存储评论</li><li>安装 <a href="https://github.com/apps/giscus">Giscus App</a></li><li>在仓库设置中启用 Discussions 功能</li></ol><h3 id="5-2-获取配置参数"><a href="#5-2-获取配置参数" class="headerlink" title="5.2 获取配置参数"></a>5.2 获取配置参数</h3><p>访问 <a href="https://giscus.app/zh-CN">Giscus 官网</a> 获取配置参数。</p><h3 id="5-3-配置-Giscus"><a href="#5-3-配置-Giscus" class="headerlink" title="5.3 配置 Giscus"></a>5.3 配置 Giscus</h3><p>在 <code>_config.butterfly.yml</code> 中配置：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br></pre></td><td class="code"><pre><span class="line"><span class="attr">comments:</span></span><br><span class="line">  <span class="attr">use:</span> <span class="string">Giscus</span></span><br><span class="line">  <span class="attr">text:</span> <span class="literal">true</span></span><br><span class="line">  <span class="attr">lazyload:</span> <span class="literal">true</span></span><br><span class="line">  <span class="attr">count:</span> <span class="literal">true</span></span><br><span class="line">  <span class="attr">card_post_count:</span> <span class="literal">true</span></span><br><span class="line"></span><br><span class="line"><span class="attr">giscus:</span></span><br><span class="line">  <span class="attr">repo:</span> <span class="string">你的用户名/评论仓库名</span></span><br><span class="line">  <span class="attr">repo_id:</span> <span class="string">你的仓库ID</span></span><br><span class="line">  <span class="attr">category_id:</span> <span class="string">你的分类ID</span></span><br><span class="line">  <span class="attr">theme:</span></span><br><span class="line">    <span class="attr">light:</span> <span class="string">light</span></span><br><span class="line">    <span class="attr">dark:</span> <span class="string">dark</span></span><br><span class="line">  <span class="attr">option:</span></span><br><span class="line">    <span class="attr">data-lang:</span> <span class="string">zh-CN</span></span><br><span class="line">    <span class="attr">data-loading:</span> <span class="string">lazy</span></span><br><span class="line">    <span class="attr">crossorigin:</span> <span class="string">anonymous</span></span><br></pre></td></tr></table></figure><h2 id="6-搜索功能配置"><a href="#6-搜索功能配置" class="headerlink" title="6. 搜索功能配置"></a>6. 搜索功能配置</h2><h3 id="6-1-安装搜索插件"><a href="#6-1-安装搜索插件" class="headerlink" title="6.1 安装搜索插件"></a>6.1 安装搜索插件</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">npm install hexo-generator-search --save</span><br></pre></td></tr></table></figure><h3 id="6-2-配置搜索"><a href="#6-2-配置搜索" class="headerlink" title="6.2 配置搜索"></a>6.2 配置搜索</h3><p>在根目录 <code>_config.yml</code> 中添加：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="attr">search:</span></span><br><span class="line">  <span class="attr">path:</span> <span class="string">search.xml</span></span><br><span class="line">  <span class="attr">field:</span> <span class="string">post</span></span><br><span class="line">  <span class="attr">content:</span> <span class="literal">true</span></span><br><span class="line">  <span class="attr">format:</span> <span class="string">html</span></span><br></pre></td></tr></table></figure><p>在 <code>_config.butterfly.yml</code> 中启用：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="attr">local_search:</span></span><br><span class="line">  <span class="attr">enable:</span> <span class="literal">true</span></span><br><span class="line">  <span class="attr">preload:</span> <span class="literal">false</span></span><br><span class="line">  <span class="attr">CDN:</span></span><br></pre></td></tr></table></figure><h2 id="7-自定义样式"><a href="#7-自定义样式" class="headerlink" title="7. 自定义样式"></a>7. 自定义样式</h2><h3 id="7-1-创建自定义-CSS"><a href="#7-1-创建自定义-CSS" class="headerlink" title="7.1 创建自定义 CSS"></a>7.1 创建自定义 CSS</h3><p>创建 <code>source/css/custom.css</code>：</p><figure class="highlight css"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* 响应式视频容器 */</span></span><br><span class="line"><span class="selector-class">.video-container</span> &#123;</span><br><span class="line">  <span class="attribute">position</span>: relative;</span><br><span class="line">  <span class="attribute">padding-bottom</span>: <span class="number">56.25%</span>;</span><br><span class="line">  <span class="attribute">height</span>: <span class="number">0</span>;</span><br><span class="line">  <span class="attribute">overflow</span>: hidden;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="selector-class">.video-container</span> <span class="selector-tag">iframe</span> &#123;</span><br><span class="line">  <span class="attribute">position</span>: absolute;</span><br><span class="line">  <span class="attribute">top</span>: <span class="number">0</span>;</span><br><span class="line">  <span class="attribute">left</span>: <span class="number">0</span>;</span><br><span class="line">  <span class="attribute">width</span>: <span class="number">100%</span>;</span><br><span class="line">  <span class="attribute">height</span>: <span class="number">100%</span>;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="comment">/* 侧边栏个人信息卡片动态渐变色 */</span></span><br><span class="line"><span class="selector-id">#aside-content</span> <span class="selector-class">.card-widget</span><span class="selector-class">.card-info</span> &#123;</span><br><span class="line">  <span class="attribute">background</span>: <span class="built_in">linear-gradient</span>(-<span class="number">45deg</span>, <span class="number">#ee7752</span>, <span class="number">#e73c7e</span>, <span class="number">#23a6d5</span>, <span class="number">#23d5ab</span>);</span><br><span class="line">  <span class="attribute">background-size</span>: <span class="number">400%</span> <span class="number">400%</span>;</span><br><span class="line">  <span class="attribute">animation</span>: gradientBG <span class="number">15s</span> ease infinite;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="keyword">@keyframes</span> gradientBG &#123;</span><br><span class="line">  <span class="number">0%</span> &#123; <span class="attribute">background-position</span>: <span class="number">0%</span> <span class="number">50%</span>; &#125;</span><br><span class="line">  <span class="number">50%</span> &#123; <span class="attribute">background-position</span>: <span class="number">100%</span> <span class="number">50%</span>; &#125;</span><br><span class="line">  <span class="number">100%</span> &#123; <span class="attribute">background-position</span>: <span class="number">0%</span> <span class="number">50%</span>; &#125;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="comment">/* Follow me 按钮样式 */</span></span><br><span class="line"><span class="selector-class">.button--animated</span> &#123;</span><br><span class="line">  <span class="attribute">background</span>: <span class="built_in">linear-gradient</span>(<span class="number">45deg</span>, <span class="number">#667eea</span> <span class="number">0%</span>, <span class="number">#764ba2</span> <span class="number">100%</span>);</span><br><span class="line">  <span class="attribute">border</span>: none;</span><br><span class="line">  <span class="attribute">border-radius</span>: <span class="number">25px</span>;</span><br><span class="line">  <span class="attribute">color</span>: white;</span><br><span class="line">  <span class="attribute">padding</span>: <span class="number">10px</span> <span class="number">20px</span>;</span><br><span class="line">  <span class="attribute">text-decoration</span>: none;</span><br><span class="line">  <span class="attribute">display</span>: inline-block;</span><br><span class="line">  <span class="attribute">transition</span>: all <span class="number">0.3s</span> ease;</span><br><span class="line">  <span class="attribute">box-shadow</span>: <span class="number">0</span> <span class="number">4px</span> <span class="number">15px</span> <span class="built_in">rgba</span>(<span class="number">102</span>, <span class="number">126</span>, <span class="number">234</span>, <span class="number">0.4</span>);</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="selector-class">.button--animated</span><span class="selector-pseudo">:hover</span> &#123;</span><br><span class="line">  <span class="attribute">transform</span>: <span class="built_in">translateY</span>(-<span class="number">2px</span>);</span><br><span class="line">  <span class="attribute">box-shadow</span>: <span class="number">0</span> <span class="number">8px</span> <span class="number">25px</span> <span class="built_in">rgba</span>(<span class="number">102</span>, <span class="number">126</span>, <span class="number">234</span>, <span class="number">0.6</span>);</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><h3 id="7-2-引入自定义样式"><a href="#7-2-引入自定义样式" class="headerlink" title="7.2 引入自定义样式"></a>7.2 引入自定义样式</h3><p>在 <code>_config.butterfly.yml</code> 中添加：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="attr">inject:</span></span><br><span class="line">  <span class="attr">head:</span></span><br><span class="line">    <span class="bullet">-</span> <span class="string">&lt;link</span> <span class="string">rel=&quot;stylesheet&quot;</span> <span class="string">href=&quot;/css/custom.css&quot;&gt;</span></span><br></pre></td></tr></table></figure><h2 id="8-创建页面和文章"><a href="#8-创建页面和文章" class="headerlink" title="8. 创建页面和文章"></a>8. 创建页面和文章</h2><h3 id="8-1-创建关于页面"><a href="#8-1-创建关于页面" class="headerlink" title="8.1 创建关于页面"></a>8.1 创建关于页面</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">hexo new page about</span><br></pre></td></tr></table></figure><p>编辑 <code>source/about/index.md</code>：</p><figure class="highlight markdown"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line">---</span><br><span class="line">title: 关于我</span><br><span class="line">date: 2024-01-01 00:00:00</span><br><span class="line"><span class="section">type: about</span></span><br><span class="line"><span class="section">---</span></span><br><span class="line"></span><br><span class="line"><span class="section"># 关于我</span></span><br><span class="line"></span><br><span class="line">这里是关于页面的内容...</span><br></pre></td></tr></table></figure><h3 id="8-2-创建标签页面"><a href="#8-2-创建标签页面" class="headerlink" title="8.2 创建标签页面"></a>8.2 创建标签页面</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">hexo new page tags</span><br></pre></td></tr></table></figure><p>编辑 <code>source/tags/index.md</code>：</p><figure class="highlight markdown"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">---</span><br><span class="line">title: 标签</span><br><span class="line">date: 2024-01-01 00:00:00</span><br><span class="line"><span class="section">type: tags</span></span><br><span class="line"><span class="section">---</span></span><br></pre></td></tr></table></figure><h3 id="8-3-创建分类页面"><a href="#8-3-创建分类页面" class="headerlink" title="8.3 创建分类页面"></a>8.3 创建分类页面</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">hexo new page categories</span><br></pre></td></tr></table></figure><p>编辑 <code>source/categories/index.md</code>：</p><figure class="highlight markdown"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">---</span><br><span class="line">title: 分类</span><br><span class="line">date: 2024-01-01 00:00:00</span><br><span class="line"><span class="section">type: categories</span></span><br><span class="line"><span class="section">---</span></span><br></pre></td></tr></table></figure><h3 id="8-4-创建新文章"><a href="#8-4-创建新文章" class="headerlink" title="8.4 创建新文章"></a>8.4 创建新文章</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">hexo new <span class="string">&quot;我的第一篇博客&quot;</span></span><br></pre></td></tr></table></figure><h2 id="9-部署到-GitHub-Pages"><a href="#9-部署到-GitHub-Pages" class="headerlink" title="9. 部署到 GitHub Pages"></a>9. 部署到 GitHub Pages</h2><p><img src="/img/blog-tutorial/github-deploy.svg" alt="GitHub Pages部署流程"></p><h3 id="9-1-创建-GitHub-仓库"><a href="#9-1-创建-GitHub-仓库" class="headerlink" title="9.1 创建 GitHub 仓库"></a>9.1 创建 GitHub 仓库</h3><ol><li>在 GitHub 创建新仓库，命名为 <code>username.github.io</code></li><li>仓库设置为 Public</li></ol><h3 id="9-2-安装部署插件"><a href="#9-2-安装部署插件" class="headerlink" title="9.2 安装部署插件"></a>9.2 安装部署插件</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">npm install hexo-deployer-git --save</span><br></pre></td></tr></table></figure><h3 id="9-3-配置部署"><a href="#9-3-配置部署" class="headerlink" title="9.3 配置部署"></a>9.3 配置部署</h3><p>在根目录 <code>_config.yml</code> 中配置：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># URL</span></span><br><span class="line"><span class="attr">url:</span> <span class="string">https://username.github.io</span></span><br><span class="line"><span class="attr">root:</span> <span class="string">/</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># Deployment</span></span><br><span class="line"><span class="attr">deploy:</span></span><br><span class="line">  <span class="attr">type:</span> <span class="string">git</span></span><br><span class="line">  <span class="attr">repo:</span> <span class="string">git@github.com:username/username.github.io.git</span></span><br><span class="line">  <span class="attr">branch:</span> <span class="string">main</span></span><br></pre></td></tr></table></figure><h3 id="9-4-部署博客"><a href="#9-4-部署博客" class="headerlink" title="9.4 部署博客"></a>9.4 部署博客</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 清理并生成静态文件</span></span><br><span class="line">hexo clean</span><br><span class="line">hexo generate</span><br><span class="line"></span><br><span class="line"><span class="comment"># 部署到 GitHub</span></span><br><span class="line">hexo deploy</span><br><span class="line"></span><br><span class="line"><span class="comment"># 或者一键部署</span></span><br><span class="line">hexo clean &amp;&amp; hexo g &amp;&amp; hexo d</span><br></pre></td></tr></table></figure><h2 id="10-进阶配置"><a href="#10-进阶配置" class="headerlink" title="10. 进阶配置"></a>10. 进阶配置</h2><h3 id="10-1-SEO-优化"><a href="#10-1-SEO-优化" class="headerlink" title="10.1 SEO 优化"></a>10.1 SEO 优化</h3><p>安装 SEO 插件：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">npm install hexo-generator-sitemap --save</span><br><span class="line">npm install hexo-generator-baidu-sitemap --save</span><br></pre></td></tr></table></figure><p>配置 sitemap：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="attr">sitemap:</span></span><br><span class="line">  <span class="attr">path:</span> <span class="string">sitemap.xml</span></span><br><span class="line"></span><br><span class="line"><span class="attr">baidusitemap:</span></span><br><span class="line">  <span class="attr">path:</span> <span class="string">baidusitemap.xml</span></span><br></pre></td></tr></table></figure><h3 id="10-2-图片懒加载"><a href="#10-2-图片懒加载" class="headerlink" title="10.2 图片懒加载"></a>10.2 图片懒加载</h3><p>在 <code>_config.butterfly.yml</code> 中启用：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="attr">lazyload:</span></span><br><span class="line">  <span class="attr">enable:</span> <span class="literal">true</span></span><br><span class="line">  <span class="attr">field:</span> <span class="string">site</span></span><br><span class="line">  <span class="attr">placeholder:</span></span><br><span class="line">  <span class="attr">blur:</span> <span class="literal">false</span></span><br></pre></td></tr></table></figure><h3 id="10-3-代码高亮"><a href="#10-3-代码高亮" class="headerlink" title="10.3 代码高亮"></a>10.3 代码高亮</h3><p>配置代码块主题：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="attr">highlight_theme:</span> <span class="string">mac</span></span><br><span class="line"><span class="attr">highlight_copy:</span> <span class="literal">true</span></span><br><span class="line"><span class="attr">highlight_lang:</span> <span class="literal">true</span></span><br><span class="line"><span class="attr">highlight_shrink:</span> <span class="literal">false</span></span><br></pre></td></tr></table></figure><h3 id="10-4-数学公式支持"><a href="#10-4-数学公式支持" class="headerlink" title="10.4 数学公式支持"></a>10.4 数学公式支持</h3><p>安装 MathJax：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">npm install hexo-filter-mathjax --save</span><br></pre></td></tr></table></figure><p>配置：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="attr">mathjax:</span></span><br><span class="line">  <span class="attr">enable:</span> <span class="literal">true</span></span><br><span class="line">  <span class="attr">per_page:</span> <span class="literal">false</span></span><br></pre></td></tr></table></figure><h2 id="11-移动端优化"><a href="#11-移动端优化" class="headerlink" title="11. 移动端优化"></a>11. 移动端优化</h2><h3 id="11-1-响应式设计"><a href="#11-1-响应式设计" class="headerlink" title="11.1 响应式设计"></a>11.1 响应式设计</h3><p>确保主题支持移动端：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="attr">mobile:</span></span><br><span class="line">  <span class="attr">scale:</span> <span class="number">0.8</span></span><br><span class="line">  <span class="attr">header_height:</span> <span class="string">45px</span></span><br></pre></td></tr></table></figure><h3 id="11-2-PWA-支持"><a href="#11-2-PWA-支持" class="headerlink" title="11.2 PWA 支持"></a>11.2 PWA 支持</h3><p>安装 PWA 插件：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">npm install hexo-offline --save</span><br></pre></td></tr></table></figure><h2 id="12-常用脚本"><a href="#12-常用脚本" class="headerlink" title="12. 常用脚本"></a>12. 常用脚本</h2><p>创建便捷脚本 <code>scripts/blog.sh</code>：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#!/bin/bash</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 新建文章</span></span><br><span class="line"><span class="keyword">if</span> [ <span class="string">&quot;<span class="variable">$1</span>&quot;</span> = <span class="string">&quot;new&quot;</span> ]; <span class="keyword">then</span></span><br><span class="line">    hexo new <span class="string">&quot;<span class="variable">$2</span>&quot;</span></span><br><span class="line">    <span class="built_in">echo</span> <span class="string">&quot;文章 &#x27;<span class="variable">$2</span>&#x27; 创建成功！&quot;</span></span><br><span class="line"><span class="keyword">fi</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 本地预览</span></span><br><span class="line"><span class="keyword">if</span> [ <span class="string">&quot;<span class="variable">$1</span>&quot;</span> = <span class="string">&quot;server&quot;</span> ]; <span class="keyword">then</span></span><br><span class="line">    hexo clean &amp;&amp; hexo g &amp;&amp; hexo s</span><br><span class="line"><span class="keyword">fi</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 部署</span></span><br><span class="line"><span class="keyword">if</span> [ <span class="string">&quot;<span class="variable">$1</span>&quot;</span> = <span class="string">&quot;deploy&quot;</span> ]; <span class="keyword">then</span></span><br><span class="line">    hexo clean &amp;&amp; hexo g &amp;&amp; hexo d</span><br><span class="line">    <span class="built_in">echo</span> <span class="string">&quot;博客部署完成！&quot;</span></span><br><span class="line"><span class="keyword">fi</span></span><br></pre></td></tr></table></figure><p>使用方法：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 新建文章</span></span><br><span class="line">./scripts/blog.sh new <span class="string">&quot;文章标题&quot;</span></span><br><span class="line"></span><br><span class="line"><span class="comment"># 本地预览</span></span><br><span class="line">./scripts/blog.sh server</span><br><span class="line"></span><br><span class="line"><span class="comment"># 部署博客</span></span><br><span class="line">./scripts/blog.sh deploy</span><br></pre></td></tr></table></figure><h2 id="13-常见问题解决"><a href="#13-常见问题解决" class="headerlink" title="13. 常见问题解决"></a>13. 常见问题解决</h2><h3 id="13-1-部署失败"><a href="#13-1-部署失败" class="headerlink" title="13.1 部署失败"></a>13.1 部署失败</h3><p>检查 SSH 密钥配置：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">ssh-keygen -t rsa -C <span class="string">&quot;your_email@example.com&quot;</span></span><br><span class="line"><span class="built_in">cat</span> ~/.ssh/id_rsa.pub</span><br></pre></td></tr></table></figure><h3 id="13-2-主题更新"><a href="#13-2-主题更新" class="headerlink" title="13.2 主题更新"></a>13.2 主题更新</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">cd</span> themes/butterfly</span><br><span class="line">git pull</span><br></pre></td></tr></table></figure><h3 id="13-3-插件冲突"><a href="#13-3-插件冲突" class="headerlink" title="13.3 插件冲突"></a>13.3 插件冲突</h3><p>清理 node_modules：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">rm</span> -rf node_modules</span><br><span class="line">npm install</span><br></pre></td></tr></table></figure><h2 id="14-性能优化"><a href="#14-性能优化" class="headerlink" title="14. 性能优化"></a>14. 性能优化</h2><h3 id="14-1-图片压缩"><a href="#14-1-图片压缩" class="headerlink" title="14.1 图片压缩"></a>14.1 图片压缩</h3><p>安装图片压缩插件：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">npm install hexo-imagemin --save</span><br></pre></td></tr></table></figure><h3 id="14-2-CDN-加速"><a href="#14-2-CDN-加速" class="headerlink" title="14.2 CDN 加速"></a>14.2 CDN 加速</h3><p>配置 CDN：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="attr">CDN:</span></span><br><span class="line">  <span class="attr">internal_provider:</span> <span class="string">local</span></span><br><span class="line">  <span class="attr">third_party_provider:</span> <span class="string">cdnjs</span></span><br></pre></td></tr></table></figure><h3 id="14-3-缓存优化"><a href="#14-3-缓存优化" class="headerlink" title="14.3 缓存优化"></a>14.3 缓存优化</h3><p>启用浏览器缓存：</p><figure class="highlight yaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="attr">open_graph:</span></span><br><span class="line">  <span class="attr">enable:</span> <span class="literal">true</span></span><br><span class="line">  <span class="attr">options:</span></span><br><span class="line">    <span class="attr">twitter_card:</span> <span class="string">summary_large_image</span></span><br><span class="line">    <span class="attr">twitter_image:</span></span><br><span class="line">    <span class="attr">twitter_id:</span></span><br><span class="line">    <span class="attr">twitter_site:</span></span><br><span class="line">    <span class="attr">google_plus:</span></span><br><span class="line">    <span class="attr">fb_admins:</span></span><br><span class="line">    <span class="attr">fb_app_id:</span></span><br></pre></td></tr></table></figure><h2 id="15-总结"><a href="#15-总结" class="headerlink" title="15. 总结"></a>15. 总结</h2><p>通过本教程，你已经成功搭建了一个功能完整的 Hexo 博客，包括：</p><ul><li>✅ Hexo 框架安装和配置</li><li>✅ Butterfly 主题美化</li><li>✅ Live2D 看板娘</li><li>✅ Giscus 评论系统</li><li>✅ 搜索功能</li><li>✅ 自定义样式</li><li>✅ GitHub Pages 部署</li><li>✅ SEO 和性能优化</li></ul><p>现在你可以开始写作，分享你的知识和想法了！</p><h2 id="16-相关资源"><a href="#16-相关资源" class="headerlink" title="16. 相关资源"></a>16. 相关资源</h2><ul><li><a href="https://hexo.io/zh-cn/docs/">Hexo 官方文档</a></li><li><a href="https://butterfly.js.org/">Butterfly 主题文档</a></li><li><a href="https://giscus.app/zh-CN">Giscus 官网</a></li><li><a href="https://docs.github.com/en/pages">GitHub Pages 文档</a></li><li><a href="https://www.markdownguide.org/">Markdown 语法指南</a></li></ul><hr><blockquote><p>💡 <strong>提示</strong>: 定期备份你的博客源码，建议将源码也推送到 GitHub 仓库的 source 分支进行版本管理。</p></blockquote><blockquote><p>🎉 <strong>恭喜</strong>: 你的博客搭建完成！现在开始你的写作之旅吧！</p></blockquote>]]>
    </content>
    <id>https://cccignore.github.io/2025/01/27/hexo-butterfly-blog-setup-guide/</id>
    <link href="https://cccignore.github.io/2025/01/27/hexo-butterfly-blog-setup-guide/"/>
    <published>2025-01-27T04:00:00.000Z</published>
    <summary>基于 Hexo + Butterfly 主题 + GitHub Pages 的完整博客搭建指南，包含详细步骤和图文说明</summary>
    <title>博客搭建完整教程</title>
    <updated>2026-03-31T07:22:43.636Z</updated>
  </entry>
</feed>
