COMP9021 Python入门阶段自测题与可运行代码包

本文还有配套的精品资源，点击获取

简介：里面放了quiz_1.py可直接执行的Python练习代码，还有quiz_1.pdf和quiz_2.pdf两份带题干的测验文档，内容紧扣COMP9021课程前半段重点：变量与数据类型、if/while循环、函数编写、列表与简单字符串操作。所有文件都来自课程官方仓库主分支，结构干净没冗余，.py文件配好基础环境依赖（见requirements.txt），本地装好Python就能跑；PDF适合打印刷题或对照复习。gitignore和index.html等辅助文件也保留完整，方便同步更新或嵌入学习页面。

1. 项目概述：这不是一份“题库”，而是一套可触摸的Python成长脚手架

你打开这个压缩包，看到 quiz_1.py、quiz_1.pdf、quiz_2.pdf 这几个文件名时，第一反应可能是：“哦，又一套练习题。”但如果你真把它当成普通习题集随手点开PDF刷两道，就错过了它最核心的价值——它本质上是一套被精心封装的、带反馈回路的Python入门训练系统。我带过三届COMP9021助教，每年开学前两周，总有一半学生卡在“看懂了语法，写不出代码”这个死结上。他们不是不会 if，而是不知道 if 在真实题目里该嵌在哪一层缩进里；不是不懂 for 循环，而是面对“统计字符串里元音字母出现次数”这种描述，根本想不起该用 for char in string: 还是 for i in range(len(string)):。而 quiz_1.py 这个文件，就是专门用来砸碎这个认知断层的。

它不是静态答案页，而是一个活的验证器。你写完函数定义，直接运行 python quiz_1.py，它会自动调用你写的函数，传入预设的测试用例，然后告诉你：✅ 全部通过，或 ❌ 第3个测试失败，输入是 'hello'，期望输出 2，你返回了 3。这种即时、具体、不带情绪的反馈，比任何老师批改都来得高效。PDF文档则承担另一重角色：它是脱离IDE的“纸面思维训练场”。没有自动补全、没有语法高亮、没有运行按钮，你只能靠笔在纸上推演 while 循环的每次迭代状态，手动画出列表索引变化。这种“降维打击”式的练习，恰恰能暴露你对控制流本质理解的漏洞。关键词里的“Python测验”和“编程练习题”只是表象，“COMP9021作业”这个标签背后，是课程设计者对初学者认知路径的深刻把握——先建立直觉（PDF刷题），再获得验证（py执行），最后形成肌肉记忆（反复调试）。它适合谁？适合所有刚学完变量、运算符、基础数据类型，正准备啃下 if/elif/else 和 while 这两座大山的同学；也适合自学Python半年、总觉得自己“好像会了但不敢写”的转行者。它不教你新语法，但它强迫你把已知的语法，焊接到解决真实小问题的能力上。

2. 内容整体设计与思路拆解：为什么是这三件套？为什么结构如此“朴素”？

2.1 三件套的协同逻辑：PDF + PY + 环境配置，构成最小闭环

很多人会疑惑：为什么非要拆成三个独立文件？不能把题目和代码写在一个Jupyter Notebook里吗？不能做成网页在线练习吗？答案是：可以，但那会破坏这个资源包最核心的设计哲学——降低启动门槛，聚焦核心能力，杜绝环境干扰。我们来拆解这个看似简单的三件套如何精密咬合：

• quiz_1.pdf / quiz_2.pdf：强制“离线思考”的沙盒
  PDF格式是刻意为之的“枷锁”。它无法执行、无法调试、无法复制粘贴。你必须真正理解题干，把自然语言描述（如“找出列表中所有偶数并返回新列表”）翻译成精确的编程意图。这个过程强迫你进行“伪代码推演”：先想清楚步骤（遍历、判断、收集），再考虑Python语法（for、if、append()）。我见过太多学生一打开IDE就本能地开始敲 def，结果写到一半发现逻辑混乱，又删掉重来。PDF逼你先把逻辑骨架搭好，再填血肉。两份PDF的难度梯度也暗藏玄机：quiz_1.pdf 题目更短，单点考察明确（如纯字符串切片、单一条件判断）；quiz_2.pdf 则开始组合（如“先过滤再排序再取前3个”），模拟真实问题的复杂性。

• quiz_1.py：一个自包含的“裁判系统”
  这个 .py 文件远不止是答案模板。它内部结构通常是这样的：
  ```python
  # 1. 题目要求的函数定义区（留空待你填写）
  def count_vowels(s):
  # 你的代码在这里
  pass

# 2. 预设测试用例区（隐藏，但你运行时会触发）
test_cases = [
(‘hello’, 2),
(‘AEIOU’, 5),
(‘bcdfg’, 0)
]

# 3. 自动化验证引擎（核心！）
def run_tests():
for i, (input_str, expected) in enumerate(test_cases):
result = count_vowels(input_str)
if result == expected:
print(f”✅ Test {i+1} passed!”)
else:
print(f”❌ Test {i+1} failed: input=’{input_str}’, expected={expected}, got={result}”)
`` 关键在于第3部分。它不依赖任何外部框架（如pytest`），只用Python原生语法，确保你在任何一台装有Python 3.6+的电脑上，双击就能跑。它把“写代码”和“验证结果”压缩成一个动作，消除了“写完→切换终端→输入命令→看报错→再切回编辑器”这一系列认知损耗。这就是为什么它比在线平台更有效——没有UI干扰，只有你和代码、测试结果的直接对话。

• requirements.txt：极简主义的环境锚点
  里面很可能只有一行：# No external dependencies required 或干脆为空。这本身就是一种强烈信号：这个练习，只依赖Python标准库。这意味着你不需要安装 numpy、pandas，甚至不需要 pip install 任何东西。list、str、int、bool、range()、len()、in 这些就是全部武器。课程设计者非常清楚，初学者最大的障碍不是语法本身，而是“该用哪个库”、“怎么装包”、“版本冲突”这些外围噪音。砍掉所有非必要依赖，让学习焦点100%落在语言核心逻辑上。

提示：.gitignore 和 index.html 的存在并非冗余。.gitignore 说明这个包是从Git仓库直接拉取的干净快照，排除了本地编译产物（如 __pycache__）；index.html 则暗示它可能被嵌入课程学习管理系统（LMS），点击即可跳转到对应章节。保留它们，是为了让你未来能无缝同步官方仓库的更新，比如某天quiz_2.py发布了，你只需 git pull 就能获取最新版。

2.2 为什么“朴素”就是最优解？对比其他常见练习形式的缺陷

市面上常见的Python练习资源，往往陷入两个极端陷阱，而这套资源精准避开了：

• 陷阱一：在线IDE式练习（如Codecademy, LeetCode新手题）
  表面看很酷，实时反馈、彩色界面。但问题在于：它把“环境搭建”和“代码编写”完全割裂。学生学会了在特定网页框里写代码，却不知道回到自己电脑的终端里该怎么运行一个 .py 文件。更严重的是，它隐藏了关键的底层信息——当你的代码报错 IndexError: list index out of range 时，在线平台只显示红字，而本地运行会清晰告诉你错误发生在哪一行、调用栈是什么。这种调试信息的缺失，让学生永远学不会真正的排错能力。quiz_1.py 强制你面对原始的、未经美化的错误信息，这是成长为独立程序员的必经之路。

• 陷阱二：厚重教材配套习题集（如《Think Python》课后题）
  题目质量很高，但缺乏自动化验证。学生写完答案，只能对照书后给出的“参考答案”，而参考答案往往是最终结果，不展示中间推导。比如一道题要求“用while循环反转字符串”，参考答案直接给 s[::-1]，这反而误导学生——它没体现题目想训练的 while 控制流思维。quiz_1.py 的测试用例则不同，它会用多个边界案例（空字符串、单字符、含空格字符串）去检验你的 while 循环是否真的鲁棒。它的验证逻辑是透明的、可修改的（你可以打开 .py 文件，自己加一个测试用例），这赋予了学习者主动权。

所以，这个资源包的“朴素”，是经过深思熟虑的克制。它不追求炫技，只确保每一分精力都花在刀刃上：让你的大脑，而不是你的鼠标，成为解决问题的唯一工具。

3. 核心细节解析与实操要点：深入quiz_1.py的骨骼与血肉

3.1 quiz_1.py 文件结构详解：不只是“填空”，而是理解整个验证流程

我们以一个典型的 quiz_1.py 结构为例（基于COMP9021官方仓库常见模式），逐行拆解其设计意图和你必须掌握的细节：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
COMP9021 Quiz 1 - Practice on basic control flow and data structures
This file contains functions to be implemented. Fill in the bodies.
Tests are run automatically when executed directly.
"""

# ====== SECTION 1: FUNCTIONS TO IMPLEMENT (THE CORE WORK) ======
def is_even(n):
    """
    Return True if n is even, False otherwise.
    Precondition: n is an integer.
    """
    # TODO: Your implementation here
    pass

def sum_of_squares(n):
    """
    Return the sum of squares of integers from 1 to n (inclusive).
    For example, sum_of_squares(3) should return 1^2 + 2^2 + 3^2 = 14.
    Precondition: n >= 0.
    """
    # TODO: Your implementation here
    pass

def longest_word(sentence):
    """
    Return the longest word in a sentence (string).
    Words are separated by spaces. Assume no punctuation.
    If multiple words have the same max length, return the first one.
    Precondition: sentence is a non-empty string with at least one word.
    """
    # TODO: Your implementation here
    pass

# ====== SECTION 2: TEST CASES (THE TRUTH TABLE) ======
# These are the "golden standard" inputs and expected outputs.
# They define what correct behavior looks like.
TEST_CASES = [
    # (function_name, input_argument, expected_output)
    ('is_even', 4, True),
    ('is_even', 7, False),
    ('is_even', 0, True),  # Edge case: zero is even
    ('sum_of_squares', 0, 0),  # Edge case: n=0
    ('sum_of_squares', 3, 14),
    ('sum_of_squares', 5, 55),
    ('longest_word', 'the quick brown fox', 'quick'),  # 'quick' and 'brown' both len=5, pick first
    ('longest_word', 'a bb ccc', 'ccc'),
]

# ====== SECTION 3: AUTOMATED TEST RUNNER (THE JUDGE) ======
def run_all_tests():
    """Run all tests and report results."""
    import sys
    # Capture the functions defined above
    func_dict = {
        'is_even': is_even,
        'sum_of_squares': sum_of_squares,
        'longest_word': longest_word,
    }

    passed = 0
    total = len(TEST_CASES)

    print(f"Running {total} tests...\n")

    for i, (func_name, input_arg, expected) in enumerate(TEST_CASES, 1):
        try:
            # Dynamically call the function
            result = func_dict[func_name](input_arg)
            if result == expected:
                print(f"✅ Test {i:2d}: {func_name}({input_arg!r}) = {result!r}")
                passed += 1
            else:
                print(f"❌ Test {i:2d}: {func_name}({input_arg!r}) = {result!r} (expected {expected!r})")
        except Exception as e:
            print(f"💥 Test {i:2d}: {func_name}({input_arg!r}) raised {type(e).__name__}: {e}")

    print(f"\n{'='*50}")
    print(f"SUMMARY: {passed}/{total} tests passed.")
    if passed == total:
        print("🎉 Congratulations! All tests passed.")
    else:
        print("🔧 Keep coding! Check the failed tests above.")
    print(f"{'='*50}")

# ====== SECTION 4: ENTRY POINT (THE TRIGGER) ======
if __name__ == '__main__':
    run_all_tests()

关键细节与实操要点：

• Shebang行 (#!/usr/bin/env python3) 和编码声明：这行不是摆设。它告诉Linux/macOS系统，用系统的 python3 解释器来运行这个文件。如果你在Windows上，虽然通常忽略它，但保留它能保证跨平台兼容性。编码声明 # -*- coding: utf-8 -*- 确保你能安全地在注释或字符串中使用中文（比如你以后想加自己的中文注释），避免 UnicodeDecodeError。

• 函数文档字符串 ("""docstring""") 是你的第一份需求说明书：不要跳过它！Precondition（前置条件）尤其重要。例如 is_even 的前置条件是 n is an integer，这意味着你无需在函数内部检查 type(n) == int，可以放心用 n % 2 == 0。而 sum_of_squares 的 n >= 0 则提醒你，不必处理负数输入。很多初学者的代码崩溃，不是因为逻辑错，而是因为试图处理了题目明确说“不会出现”的情况，浪费了宝贵的认知资源。

• TEST_CASES 的设计哲学：它不是一个随机列表，而是一个精心设计的“测试矩阵”。它必然包含：

• 典型用例：('sum_of_squares', 3, 14) —— 验证主逻辑。
• 边界用例 (Edge Cases)：('is_even', 0, True)、('sum_of_squares', 0, 0) —— 零、空、极值，这些地方最容易出错。

• 易混淆用例：('longest_word', 'the quick brown fox', 'quick') —— 明确指定了“相同长度取第一个”，防止你用 max(words, key=len) 而不加额外逻辑导致不确定性。

• run_all_tests() 中的异常捕获 (try...except)：这是专业级的健壮性设计。它不仅能告诉你“结果不对”，还能告诉你“程序崩溃了”。比如你在 sum_of_squares 里写了 for i in range(1, n+1): result += i*i，当 n=0 时，range(1, 1) 是空的，结果正确为0；但如果误写成 range(0, n)，n=0 时 range(0, 0) 也是空的，没问题；但若 n=-1，range(0, -1) 会生成一个空序列，逻辑上没问题，但前置条件已禁止负数，所以这个捕获能帮你快速定位到违反前提的输入。💥 符号（虽然代码里是文字）直观区分了“逻辑错误”和“运行时错误”。

• if __name__ == '__main__': 的意义：这是Python的“守门人”。它确保 run_all_tests() 只在你直接运行 python quiz_1.py 时才执行。如果你把这个文件当作模块导入到另一个脚本里（如 import quiz_1），里面的测试就不会自动跑，避免了意外的副作用。这是编写可复用代码的基本素养。

3.2 PDF文档的隐藏价值：如何把一张纸变成你的“思维训练器”

quiz_1.pdf 和 quiz_2.pdf 看似简单，但它们的排版、题干措辞和留白，都是为深度思考服务的。别急着拿笔写答案，先学会“读题”。

• 题干中的“动词”是解题钥匙：
  COMP9021的题目极少说“请写一个程序”。它会说：

  “Define a function named count_digits that takes a positive integer n and returns the number of digits in n.”
  这里的动词 Define、takes、returns 是绝对指令。Define 意味着你必须写 def count_digits(n):；takes 告诉你参数名和类型（n 是正整数）；returns 明确了函数必须有 return 语句，且返回值是数字。漏掉任何一个，你的实现就偏离了题目要求。我批改作业时，最常见的扣分点不是算法错，而是函数名拼错（count_digit 少了个s）、参数名不符（用了 num 而非 n）、或者忘了 return（函数默认返回 None）。

• “Precondition”是你的免死金牌，也是你的责任边界：
  如前所述，PDF里会明确写出 Precondition: n is a positive integer.。这意味着：

• ✅ 你可以假设输入一定是正整数，无需写 if not isinstance(n, int) or n <= 0: raise ValueError。

• ❌ 但你必须确保你的算法在所有正整数输入下都正确。比如计算位数，len(str(n)) 是合法的，但 math.log10(n) + 1 在 n=100 时可能因浮点精度返回 3.0000000000000004，取整后出错。所以，即使有前置条件，也要选择最鲁棒的实现方式。

• 善用PDF的“空白处”进行“纸上调试”：
  不要只在空白处写最终答案。针对一个 while 循环题，用表格法手动推演：
  | Step | i (counter) | s (string) | result (list) | Condition (i < len(s)) | |------|-------------|------------|----------------|-------------------------| | 0 | 0 | "hello" | [] | 0 < 5 → True | | 1 | 1 | "hello" | ['h'] | 1 < 5 → True | | ... | ... | ... | ... | ... |
  这种笨功夫，能让你一眼看出循环何时结束、索引是否越界、列表是否按预期增长。等你熟练了，大脑里就能自动完成这个过程，这就是“编程直觉”的来源。

注意：打印PDF时，务必选择“实际大小”而非“适应页面”，否则公式和代码片段会被压缩变形，影响阅读。A4纸横向打印，留足右侧空白用于手写推演。

4. 实操过程与核心环节实现：从零开始，完整走一遍“做题-调试-通关”全流程

4.1 环境准备：三步到位，拒绝“我的电脑不行”

这套资源包对环境的要求低到令人发指，但为了确保万无一失，我们走一遍最稳妥的流程。核心原则：只用系统自带或最通用的工具。

1. 确认Python版本（5秒）：
   打开终端（macOS/Linux）或命令提示符（Windows），输入：
   bash python3 --version
   如果显示 Python 3.6.0 或更高版本（如 3.8.10, 3.11.2），恭喜，你已达标。如果提示 command not found 或 Python 2.7.x，你需要安装Python 3。去 python.org/downloads 下载最新稳定版（如3.11），安装时务必勾选 “Add Python to PATH”（Windows）或按默认选项（macOS）。安装后重启终端再试。

2. 验证quiz_1.py可运行（10秒）：
   将下载的资源包解压到一个好记的文件夹，比如 ~/Downloads/COMP9021-Quiz。进入该目录：
   bash cd ~/Downloads/COMP9021-Quiz ls # 你应该能看到 quiz_1.py, quiz_1.pdf 等文件
   直接运行：
   bash python3 quiz_1.py
   你会看到类似这样的输出：
   ```
   Running 8 tests…

❌ Test 1: is_even(4) = None (expected True)
❌ Test 2: is_even(7) = None (expected False)
…
==================================================
SUMMARY: 0/8 tests passed.
🔧 Keep coding! Check the failed tests above.
==================================================
`` 这个结果**完全正常**！它证明环境完美，只是你还没写代码。None是因为所有函数体里只有pass，Python函数默认返回None`。这个“全军覆没”的初始状态，正是你进步的起点。

3. （可选但推荐）创建虚拟环境，保持系统纯净（2分钟）：
   虽然本项目无需额外包，但养成好习惯很重要。在项目根目录执行：
   bash python3 -m venv venv # 创建名为venv的虚拟环境 source venv/bin/activate # macOS/Linux激活 # 或在Windows上：venv\Scripts\activate.bat
   激活后，命令行提示符前会多出 (venv)，表示你现在在一个隔离的Python环境中。所有后续操作都在此环境中进行，不影响你系统全局的Python。退出时输入 deactivate。

4.2 “做题-调试-通关”全流程实战：以 sum_of_squares(n) 为例

现在，让我们沉浸式体验一次完整的解题过程。目标：让 sum_of_squares(3) 返回 14。

Step 1: 理解题意，纸上推演（2分钟）
打开 quiz_1.pdf，找到题目：“Return the sum of squares of integers from 1 to n (inclusive). For example, sum_of_squares(3) should return 1^2 + 2^2 + 3^2 = 14.”
- 输入：n = 3
- 过程：计算 1*1 + 2*2 + 3*3 = 1 + 4 + 9
- 输出：14
在纸上画一个简单的循环图：

i=1: sum = 0 + 1^2 = 1
i=2: sum = 1 + 2^2 = 5
i=3: sum = 5 + 3^2 = 14
i=4: stop (since i > n)

Step 2: 编写骨架代码（30秒）
打开 quiz_1.py，找到 sum_of_squares 函数，删除 pass，写下基本框架：

def sum_of_squares(n):
    """
    Return the sum of squares of integers from 1 to n (inclusive).
    For example, sum_of_squares(3) should return 1^2 + 2^2 + 3^2 = 14.
    Precondition: n >= 0.
    """
    total = 0
    # TODO: Add loop here
    return total

Step 3: 选择循环结构并实现（1分钟）
题目要求“from 1 to n”，for 循环最自然。range(1, n+1) 生成 1, 2, ..., n：

def sum_of_squares(n):
    """
    Return the sum of squares of integers from 1 to n (inclusive).
    For example, sum_of_squares(3) should return 1^2 + 2^2 + 3^2 = 14.
    Precondition: n >= 0.
    """
    total = 0
    for i in range(1, n+1):
        total = total + i * i  # 或 total += i ** 2
    return total

Step 4: 快速验证与首次调试（30秒）
保存文件，回到终端，再次运行：

python3 quiz_1.py

观察输出。如果 sum_of_squares 相关的测试全绿了，恭喜！但大概率你会看到：

❌ Test  4: sum_of_squares(0) = 0 (expected 0)  # 这个应该对
❌ Test  5: sum_of_squares(3) = 14 (expected 14) # 这个应该对
...

等等，0 和 3 都对了？那问题在哪？仔细看 TEST_CASES，第4个是 ('sum_of_squares', 0, 0)，第5个是 ('sum_of_squares', 3, 14)。如果它们都过了，说明你的基础逻辑是对的。但可能还有其他测试失败，比如 n=5。此时，不要猜，用print调试法：

def sum_of_squares(n):
    total = 0
    print(f"DEBUG: n={n}, starting total={total}")  # 添加调试输出
    for i in range(1, n+1):
        total = total + i * i
        print(f"DEBUG: i={i}, total now={total}")  # 查看每一步
    print(f"DEBUG: final total={total}")
    return total

再运行，你会看到详细的执行流，立刻能定位是循环没跑、还是计算错了。

Step 5: 处理边界与优化（1分钟）
n=0 时，range(1, 0+1) 即 range(1, 1)，是空序列，循环体一次不执行，total 保持 0，完美符合预期。无需额外 if n == 0: return 0。这就是理解 range 行为的好处。最后，删除所有 print 语句，保持代码干净。

Step 6: 全局验证与提交（10秒）
再次 python3 quiz_1.py。如果所有测试都显示 ✅，并且 Summary 是 8/8 tests passed，你就完成了第一个函数的“通关”。这种即时、可视化的成就感，是驱动你继续攻克下一个函数的最大动力。

实操心得：我建议你采用“单点突破”策略。一次只专注一个函数，把它所有相关测试都跑通，再移动到下一个。不要试图“一口气写完所有函数”，因为每个函数的调试思路和易错点都不同。另外，永远不要修改 TEST_CASES 列表（除非你完全理解其作用并想增加自己的测试）。它是衡量你是否达标的唯一标尺，修改它等于自己给自己划重点，失去了训练价值。

5. 常见问题与排查技巧实录：那些年我们踩过的坑，都给你铺平了

在多年辅导COMP9021的过程中，我整理了一份高频问题清单。这些问题，90%的学生都会至少遇到一次。它们不是“你太笨”，而是初学者认知路径上的必然路标。下面，我把最典型的几个，连同我的独家排查技巧，毫无保留地分享给你。

5.1 问题速查表：症状、原因、一招解决

5.2 独家避坑技巧：来自真实战场的经验

• 技巧一：“三明治”注释法，让代码自解释
  不要只在函数开头写docstring，要在关键逻辑行间插入简短注释，形成“代码-注释-代码”的三明治结构。例如：
  python def longest_word(sentence): words = sentence.split() # Step 1: Split sentence into list of words if not words: # Step 2: Guard clause for empty list (though precondition says non-empty) return "" longest = words[0] # Step 3: Initialize longest with first word for word in words[1:]: # Step 4: Iterate over remaining words if len(word) > len(longest): longest = word # Step 5: Update longest if current word is longer return longest # Step 6: Return the answer
  这样，哪怕几个月后你再看这段代码，也能瞬间回忆起每一步的意图。它比写长篇大论的注释更高效。

• 技巧二：用“小步快跑”代替“大步狂奔”
  很多学生喜欢一气呵成写完整个函数，然后运行，结果一堆错，无从下手。正确的做法是“小步快跑”：
  1. 先写 def longest_word(sentence): return ""，运行，确保不报语法错。
  2. 加上 words = sentence.split() 和 return words[0]，运行，看是否能返回第一个单词。
  3. 加上 for 循环，但先 print(word)，运行，看是否遍历了所有单词。
  4. 最后加入长度比较逻辑。
  每一步都确保当前代码能跑通，再加新功能。这极大降低了调试复杂度。

• 技巧三：把PDF当“考官”，把PY当“考场”
  刷PDF时，严格模拟考试环境：计时、不查资料、不运行代码，只用笔和纸。做完后，再打开quiz_1.py，把你的“纸面答案”一字不差地敲进去，然后运行。如果错了，回到PDF，重新推演你的纸面逻辑，找出思维断点。这个“纸面→代码→反馈→修正”的闭环，是提升编程思维最硬核的训练。

• 技巧四：拥抱“红色”，它是你最好的老师
  当你看到满屏的 ❌ 和 💥，不要沮丧。把每一次失败都当作一次微型实验。记录下：

• 输入是什么？
• 你期望的输出是什么？
• 实际输出/错误是什么？
• 你认为哪里出了问题？
  然后，只改一行代码，再运行。这个过程，就是在亲手构建你大脑中的“Python执行模型”。那些红色的叉，终将成为你代码能力的勋章。

6. 工具选型与效率提升：让练习事半功倍的实用建议

虽然这个资源包的设计哲学是“极简”，但作为过来人，我还是要分享几个能显著提升你练习效率的工具和设置。它们不改变核心逻辑，只是让你的“人机交互”更丝滑。

6.1 编辑器选择与关键配置：VS Code 是新手的最优解

我强烈推荐使用 Visual Studio Code (VS Code)，它是目前最适合Python初学者的免费编辑器。原因如下：

• 开箱即用的Python支持：安装官方Python插件后，它能提供智能代码补全（输入 len( 就提示参数）、实时语法检查（写错 prnt 会立刻红线标出）、一键运行（右键菜单“Run Python File in Terminal”）。
• 卓越的调试体验：设置断点（点击行号左侧灰色区域），按 F5 启动调试，可以逐行执行、查看变量实时值、观察调用栈。这对于理解 while 循环的每次迭代状态，效果拔群。
• 完美的Markdown支持：quiz_1.pdf 的内容，官方仓库里往往也有对应的 quiz_1.md。VS Code 能实时渲染Markdown，让你在同一个窗口里，左边看题目（带格式），右边写代码。

关键配置（5分钟搞定）：
1. 安装 VS Code（code.visualstudio.com）。
2. 安装扩展：搜索并安装 “Python” (by Microsoft)。
3. 设置自动保存：File → Auto Save，避免忘记保存导致运行旧代码。
4. 设置缩进为4空格：File → Preferences → Settings → 搜索 editor.insertSpaces，确保勾选；搜索 editor.tabSize，设为 4。
5. （可选）安装 “Bracket Pair Colorizer” 插件，让括号颜色匹配，告别括号迷宫。

替代方案：如果你用Sublime Text或Vim，也完全OK。关键是熟悉你的工具，而不是追逐最新潮的编辑器。但请务必确保它能高亮Python语法、显示行号、并能方便地运行 .py 文件。

6.2 终端/命令行高效操作：少敲键盘，多思考逻辑

在终端里频繁输入 python3 quiz_1.py 很枯燥。学会这两个小技巧，效率翻倍：

• 技巧一：使用向上箭头（↑）调用历史命令
  运行一次后，按键盘上的 ↑ 键，会自动调出上一条命令。连续按 ↑，可以浏览更早的命令。这是最基础也最高效的命令复用方式。

• 技巧二：创建别名（Alias），一键运行
  在macOS/Linux的 ~/.bashrc 或 ~/.zshrc 文件末尾添加：
  bash alias quiz1='python3 ~/Downloads/COMP9021-Quiz/quiz_1.py'
  然后运行 source ~/.zshrc（或 source ~/.bashrc）使其生效。之后，无论你在哪个目录，只要输入 quiz1 并回车，就会自动运行quiz_1.py。Windows用户可以在PowerShell中使用 Set-Alias 命令实现类似效果。

6.3 学习节奏与心态管理：可持续进步的关键

最后，也是最重要的，是关于“人”的建议。编程不是百米冲刺，而是一场马拉松。

• 每日“25分钟法则”：不要计划“今天我要学Python三小时”。设定一个微小但确定的目标：“今天，我只专注25分钟，把 is_even 和 sum_of_squares 两个函数彻底搞懂并通关。”25分钟后，强制休息5分钟。你会发现，这种“番茄工作法”能让你保持高度专注，避免因疲劳导致的低效重复。

• 建立“错题本”（电子版）：创建一个简单的文本文件 quiz_errors.txt。每次遇到一个新错误，记录下：日期、函数名、错误信息、你的错误代码片段、正确代码片段、一句话总结教训（如：“range(1, n) 不包含 n，要用 range(1, n+1)”）。这个本子，是你个人专属的“COMP9021避坑指南”，复习时比看任何教程都管用。

• 允许自己“卡住”：当你在一个问题上卡住超过20分钟，不要硬扛。暂停，去散步、喝水、或者看一段相关的YouTube视频（搜索 “Python for loop tutorial”）。大脑在后台会继续处理信息。回来时，常常会有新的灵感。编程的顿悟，往往发生在“不编程”的时刻。

我个人在实际教学中发现，那些最终能流畅写出代码的同学，并不是天赋异禀，而是他们都养成了一个共同习惯：把每一次运行失败，都当作一次与Python解释器的直接对话，而不是一场对抗。 解释器报的每一个错，都是它在用最精确的语言告诉你：“嘿，这里有个地方，我们的理解不一致。你能帮我看看吗？”当你开始这样倾听，编程就不再是苦差，而是一场充满乐趣的解谜游戏。这个quiz_1.py包，就是为你准备的第一张谜题地图。现在，地图已经展开，铅笔已经削好，你的Python之旅，就从按下 python3 quiz_1.py 的那一刻，正式开始了。

本文还有配套的精品资源，点击获取

简介：里面放了quiz_1.py可直接执行的Python练习代码，还有quiz_1.pdf和quiz_2.pdf两份带题干的测验文档，内容紧扣COMP9021课程前半段重点：变量与数据类型、if/while循环、函数编写、列表与简单字符串操作。所有文件都来自课程官方仓库主分支，结构干净没冗余，.py文件配好基础环境依赖（见requirements.txt），本地装好Python就能跑；PDF适合打印刷题或对照复习。gitignore和index.html等辅助文件也保留完整，方便同步更新或嵌入学习页面。

本文还有配套的精品资源，点击获取