Lab 0：起步与工具链ok 2 个测试用例通过1 题需课程私有口令

0. 这份作业在练什么

Lab 0 的标题是 Getting Started。官方题面里绝大部分篇幅在讲怎么装 Python、怎么装终端、怎么装 VS Code——这些是一次性的体力活。真正需要动脑、并且会一直用到期末的，只有三件事：

做之前你需要掌握的，只有 Lecture 1 前半段的内容：表达式与值、名字绑定、函数调用的三步求值规则。如果这三个词你还说不清，先回去看第一讲，再回来做这份 lab——否则第 2 节的 WWPD 你会「蒙对但不知道为什么对」，那等于没做。

整份作业在本仓库里的落地位置是 labs/lab00/，包含四个文件：

1. 先把「我在哪」搞清楚：工作目录与 ok 的运行前提

题目要什么

官方题面里有一句话，读起来像客套，其实是这份 lab 最容易失分的地方：

Open your terminal, and make sure you are in the lab00 directory that
contains the unzipped lab files for this assignment. In that directory,
type ls to verify that there are the following files:
  - lab00.py
  - ok
  - lab00.ok

Attempting to run ok in a directory that does not have ok will produce an error.

翻成人话：你敲 python3 ok 的时候，Python 是去「当前工作目录」里找一个叫 ok 的文件。它不会满硬盘搜。如果你的终端此刻停在家目录，而 ok 躺在 ~/Downloads/lab00/ 里，那么 Python 找不到它，会报：

python3: can't open file '/home/you/ok': [Errno 2] No such file or directory

边界情况在于：这个报错不是「你代码写错了」，也不是「Python 没装好」。它是一个纯粹的位置问题。新手最容易在这里浪费一小时，因为报错信息里出现了 python3，于是他去重装 Python。

怎么想到的

要理解这件事，得先接受一个反直觉的设定：终端（terminal）永远「站在」某一个目录里。这个目录叫 working directory（工作目录），也叫 current directory。你敲的每一条命令，凡是提到文件名而没写完整路径的，都是相对这个目录去解释的。

为什么要有这么个设定？因为如果没有它，你每次提到一个文件都得写全 /home/qingyu/cs61a-lesson/labs/lab00/lab00.py，写十次就疯了。有了工作目录，你先 cd 过去「站好」，之后就只需要写 lab00.py。

由此引出两种路径写法，这是本节唯一需要真正记住的概念：

两个特殊名字要记住：. 表示当前目录本身，.. 表示上一层目录。所以 cd .. 是「退回上一级」，../lab01 是「上一级里那个叫 lab01 的兄弟目录」。

代码：三条命令就够了

题面附录里给了三条终端命令，这就是本课需要的全部 shell 知识：

ls                      # 列出当前目录下的所有文件
cd <path to directory>  # 切换到指定目录
mkdir <directory name>  # 新建一个目录

逐条说为什么是这三条而不是别的：

• ls（list）不需要任何参数，它回答「我这儿有什么」。它是只读的，敲多少次都不会弄坏东西，所以放心敲。
• cd（change directory）改变的是终端的「站位」，不是文件本身。cd 后面既可以跟绝对路径也可以跟相对路径——这正是上面那张表的用处。cd 后面什么都不跟，多数系统会把你送回家目录。
• mkdir（make directory）用来给这门课建一个专门的文件夹。官方建议你建一个 cs61a 目录，把每次作业解压进去，别全堆在 Downloads 里。这不是洁癖，是因为半学期后你会有二十多个作业包，同名文件互相覆盖是真的会发生的事。

本仓库里对应的一次完整操作长这样（这就是我们真实跑测试的方式）：

cd /home/qingyu/cs61a-lesson/labs/lab00
ls
# lab00.ok  lab00.py  ok  tests
python3 ok --local

注意最后那个 --local。官方题面里写的是直接 python3 ok，那会额外尝试把你的代码备份到课程服务器并要求你输入 bCourses 邮箱。我们不是选课学生，服务器会拒绝或超时。--local 的意思是「只在本地评分，别联网」，输出的测试结果与联网时完全一致。题面自己也说了，看到 Connection timed out 不用慌，那不影响评分。

验证

把「工作目录」这个抽象概念落到一次真实的追踪上。假设文件系统长这样：

/home/qingyu/
└── cs61a-lesson/
    ├── index.html
    └── labs/
        ├── lab00/
        │   ├── lab00.ok
        │   ├── lab00.py
        │   └── ok
        └── lab01/

2. WWPD：python-basics

题目要什么

WWPD 是 What Would Python Do 的缩写：给你一串按顺序输入解释器的语句，你要预测每一行会在屏幕上显示什么。它不给你写代码，它逼你在脑子里当一次解释器。

题面给出的原始形式是这样（下划线处是要你填的）：

>>> x = 20
>>> x + 2
______
>>> x
______
>>> y = 5
>>> y = y + 3
>>> y * 2
______
>>> y + x
______

运行方式是：

python3 ok -q python-basics -u

三个部分各是什么意思：-q python-basics 指定只跑名叫 python-basics 的那道题（-q 是 question）；-u 是 unlock（解锁），表示「进入交互问答模式，一行行问我答案」。答错没有分数惩罚，但你必须答对才能往下走——这个设计是故意的：它不允许你跳过不懂的地方。

怎么想到的

如果你只是把 x = 20 读成「x 是 20」，那这道题你会全对，但你什么也没学到。要看到它背后的机制，得先把「语句」和「表达式」分开。

Python 交互式解释器（那个 >>> 提示符）的行为规则只有一句话，但它统治了整个学期：

接下来是第二个关键点，也是 y = y + 3 这一行存在的全部理由。在数学里，y = y + 3 是个无解方程。在 Python 里它完全合法，因为等号不是等式，是赋值。赋值语句的执行规则是：

把这两条规则合起来，题目就变成了一次机械推演，不需要任何灵感。我第一次做的时候的确停顿了一下，卡在「x + 2 之后 x 还是不是 20」——如果 x + 2 把 x 改成了 22 呢？题目故意在 x + 2 后面紧跟一行光秃秃的 x，就是要打消这个疑虑：x + 2 只是算了个值，没有赋值语句就没有任何绑定被改变。这是「求值」和「改变状态」的分野，第一次见的人真的会搞混。

代码：官方测试文件里的答案

WWPD 的答案在官方 tests/ 目录里原本是哈希加密的（防止直接看答案）。本仓库的做法是真的推演出答案再与哈希比对，比对通过后解锁成明文。labs/lab00/tests/python-basics.py 现在长这样：

test = {
  'name': 'Python Basics',
  'points': 0,
  'suites': [
    {
      'cases': [
        {
          'code': r"""
          >>> x = 20
          >>> x + 2
          22
          >>> x
          20
          >>> y = 5
          >>> y = y + 3
          >>> y * 2
          16
          >>> y + x
          28
          """,
          'hidden': False,
          'locked': False,
          'multiline': False
        }
      ],
      'scored': False,
      'type': 'wwpp'
    }
  ]
}

顺带把这个文件读懂，因为后面每一份 lab 的测试文件都是这个结构：

• 'type': 'wwpp'——这道题的类型，wwpp 就是 WWPD 那类交互问答题。别的题会是 'doctest' 或 'concept'。
• 'locked': False——已解锁。如果是 True，22 那些地方会是一串哈希，你必须用 -u 答对才会变成明文。
• 'points': 0 与 'scored': False——这道题不计分。题面也明说了：WWPD 的答案不提交到 Gradescope，lab 学分只看写代码的题。它的价值全在过程。
• r"""...""" 前面那个 r 是 raw string，让反斜杠不被转义。这里其实用不上，是模板统一写法。

验证：逐行手动追踪

把八行输入当成八个时刻，追踪全局环境（global frame）里的绑定。这就是环境图的最简形态：

时刻 0  Global frame:  (空)

>>> x = 20
   右边 20 求值 → 20
   把名字 x 绑定到 20
时刻 1  Global frame:  x → 20
   这是语句，无输出

>>> x + 2
   这是表达式：查 x 得 20，算 20 + 2 → 22
   有值，打印
   输出：22
时刻 2  Global frame:  x → 20        ← 没变！加法不修改绑定

>>> x
   表达式：查 x → 20
   输出：20
时刻 3  Global frame:  x → 20

>>> y = 5
时刻 4  Global frame:  x → 20, y → 5
   无输出

>>> y = y + 3
   步骤 1：先算右边 y + 3 → 查 y 得旧值 5 → 5 + 3 = 8
   步骤 2：再把 y 绑定到 8，覆盖原来的 5
时刻 5  Global frame:  x → 20, y → 8
   无输出

>>> y * 2
   表达式：查 y 得 8 → 8 * 2 = 16
   输出：16
时刻 6  Global frame:  x → 20, y → 8

>>> y + x
   表达式：查 y 得 8，查 x 得 20 → 28
   输出：28
时刻 7  Global frame:  x → 20, y → 8

四个输出依次是 22、20、16、28，与解锁后的测试文件逐字一致。

3. 实现函数：twenty_twenty_six

题目要什么

打开 lab00.py，里面有一个函数，函数体是一条空白的 return。题面的要求是：

You should see a function called twenty_twenty_six that has a blank return
statement. That blank is the only part you should change. Replace it with an
expression that evaluates to 2026. What's the most creative expression you
can come up with?

而函数自己的 docstring 把约束写得更具体：

"""Come up with the most creative expression that evaluates to 2026
using only numbers and the +, *, and - operators (or ** and % if you'd like).

>>> twenty_twenty_six()
2026
"""

翻成人话：写一个算术表达式，值必须正好等于 2026，只许用数字和 + - *（外加可选的 ** 乘方、% 取余）。不许用 /，也不许调用别的函数。

需要留意的边界情况有三个，全都不在题面明文里，但会真实卡住人：

• 必须是 return，不能是 print。 doctest 里写的是 >>> twenty_twenty_six() 下面一行 2026，这检查的是函数的返回值。用 print(2026) 的话，屏幕上确实会出现 2026，但函数返回的是 None，doctest 会失败。第 6 节专门讲这个区别。
• 必须是整数 2026，不是浮点数 2026.0。 doctest 是逐字符比对文本的：期望 2026，你返回 2026.0 会打印成 2026.0，四个字符对上了、多出来的 .0 对不上，判错。这就是为什么题面把 / 排除在允许的运算符之外——Python 3 里 4052 / 2 得到的是 2026.0，不是 2026。
• 函数不接受参数。 括号里是空的，所以它每次调用都返回同一个数。它没有任何实用价值，纯粹是一个「你会不会改文件、会不会跑测试」的检查点。

怎么想到的

最省事的答案是 return 2026。它能过测试。但题面用了 most creative 这个词，说明出题人想让你多花三十秒，把 2026 拆开看看。这三十秒其实很值——它是这门课第一次要求你「把一个数看成一个结构，而不是一个符号」。

我的思考过程是这样走的，包括走进死胡同的部分：

代码逐行讲

这是 labs/lab00/lab00.py 里真实通过 ok 的代码：

def twenty_twenty_six():
    """Come up with the most creative expression that evaluates to 2026
    using only numbers and the +, *, and - operators (or ** and % if you'd like).

    >>> twenty_twenty_six()
    2026
    """
    return 45 ** 2 + 1  # 2025 = 45 * 45，所以 2026 = 45² + 1

逐行说为什么是这样：

行尾的 # 注释是我们自己加的，说明这个表达式的来历。注释对 Python 完全透明——它读到 # 就忽略这一行剩下的内容。给一个「魔法数字」写清出处，是从第一份作业就该养成的习惯。

>>> twenty_twenty_six()
2026

TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

验证：手动追踪一次调用

Global frame
    twenty_twenty_six  ─────→  func twenty_twenty_six()

f1: twenty_twenty_six          [parent = Global]
    (无参数，无局部绑定)
    当前在算：45 ** 2 + 1
    Return value: 2026

真实跑一遍的结果：

$ cd labs/lab00 && python3 -i lab00.py
>>> twenty_twenty_six()
2026
>>> type(twenty_twenty_six())
<class 'int'>

type(...) 那一行是自己加的确认：结果确实是 int 而不是 float，所以打印出来不会带 .0。

4. 开学问卷：presem_survey（本仓库无法通过，原因如实说明）

题目要什么

题面的要求是：

As part of this assignment, fill out the Pre-Semester Survey form.

Once you finish the survey, you will be presented with a passphrase. Put this
passphrase, as a string, on the line that says
passphrase = 'REPLACE_THIS_WITH_PASSPHRASE' in the Python file for this
assignment. E.g. if the passphrase is abc, then the line should be
passphrase = 'abc'.

也就是：去填一份开学问卷 → 问卷提交后网页会显示一串口令 → 把这串口令原样写进 lab00.py 的 passphrase 变量 → 用 python3 ok -q presem_survey 验证。

这道题的本体在 lab00.py 底部：

passphrase = 'REPLACE_THIS_WITH_PASSPHRASE'

def presem_survey(p):
    """
    You do not need to understand this code.
    >>> presem_survey(passphrase)
    '490cbafdbd19352a62ff3988211180244329a1d311d1ee5e4a452791'
    """
    import hashlib
    return hashlib.sha224(p.encode('utf-8')).hexdigest()

怎么想到的：这段代码在防什么

docstring 第一句就写着 You do not need to understand this code（你不需要看懂这段代码）。但恰恰是这段「不需要看懂」的代码，藏着一个很漂亮的设计，值得花几分钟拆开——它是本课后面 WWPD 解锁机制的同一套思路。

出题人面对的问题是：怎么在不把口令写进作业文件的前提下，让作业文件自己能验证口令对不对？

docstring 里那串 '490cbafdbd19352a62ff3988211180244329a1d311d1ee5e4a452791' 就是真口令的 SHA-224 哈希值。它有 56 个十六进制字符 = 224 位。这就是为什么我们知道自己填的口令是错的（哈希对不上），却无法从这个哈希反推出正确口令。

代码逐行讲

还有一个容易被略过的细节：docstring 里期望的输出是 '490cbaf...'，带单引号。因为返回的是一个字符串对象，而交互解释器显示字符串时用的是 repr 形式，会把引号一起打出来。如果你在 doctest 里把引号漏了，即使哈希算对了也会判错。这个「repr vs str」的区别第一次见很容易吃亏。

验证：用一个已知的口令走一遍

既然真口令拿不到，就换一个我们能完全掌控的例子，把机制跑通。题面自己举的例子是「如果口令是 abc」，那就试 abc：

$ python3 -c "import hashlib; print(hashlib.sha224('abc'.encode('utf-8')).hexdigest())"
23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7

这就是 ok 判这道题不通过时给出的报告形式：

---------------------------------------------------------------------
Doctests for presem_survey

>>> from lab00 import *
>>> presem_survey(passphrase)
'c0e1eeb...（REPLACE_THIS_WITH_PASSPHRASE 的哈希）'

# Error: expected
#     '490cbafdbd19352a62ff3988211180244329a1d311d1ee5e4a452791'
# but got
#     '...'

顺带注意这个哈希函数的一个性质：哪怕只改一个字符，输出也会面目全非。'abc' 和 'abd' 的 SHA-224 之间没有任何可见的相似性。这叫雪崩效应（avalanche effect），它保证了你不能靠「越试越接近」来逼近答案。

5. 学会用 ok 与 Python 命令行：一整个学期的调试基础设施

这一节要什么

Lab 0 的编程量小到近乎为零，但它把整个学期要用的两套工具摆在了台面上：课程自带的 ok 评分器，和 Python 解释器自己的几个命令行选项。这两样东西决定了你遇到 bug 时是「有办法查」还是「只能盯着代码看」。这一节把它们讲透。

ok 的几种用法

-q 后面能填什么，由 lab00.ok 这个配置文件决定。它是本次作业的「说明书」，值得读一遍：

{
    "name": "Lab 0",
    "endpoint": "cal/cs61a/su26/lab00",
    "src": [
        "lab00.py"
    ],
    "tests": {
        "lab*.py": "doctest",
        "tests/*.py": "ok_test"
    },
    "default_tests": [
        "twenty_twenty_six",
        "python-basics",
        "presem_survey"
    ],
    "protocols": [
        "restore",
        "file_contents",
        "analytics",
        "unlock",
        "grading",
        "backup"
    ]
}

• "src"：只有 lab00.py 会被提交和评分，其他文件都不会。
• "tests"：告诉 ok 去哪儿找测试，以及用什么方式跑。lab*.py 里的测试是 doctest（也就是 docstring 里的 >>> 行）；tests/ 目录下的 .py 是 ok_test（就是第 2 节那种 test = {...} 结构）。本课的两类测试就是这两种，没有第三种。
• "default_tests"：不加 -q 时会跑的三道题，正是本页第 2、3、4 节讲的那三个。这三个名字也正是 -q 的合法取值。
• "protocols"：ok 会依次执行的动作。unlock 对应 -u，grading 是评分，backup 是往课程服务器备份——这最后一项就是校外用户会看到 Connection timed out 的来源，也是我们加 --local 的理由。

怎么读 ok 的失败报告

比起「怎么让它变绿」，更值钱的技能是看懂它红的时候在说什么。题面给了一个标准的失败样例：

---------------------------------------------------------------------
Doctests for twenty_twenty_six

>>> from lab00 import *
>>> twenty_twenty_six()
0

# Error: expected
#     2026
# but got
#     0

---------------------------------------------------------------------
Test summary
    0 test cases passed before encountering first failed test case

这段报告分四块，每块都要会读：

成功时的输出则是这样，这也是本仓库跑出来的真实结果（除去需要私有口令的那题）：

---------------------------------------------------------------------
Test summary
    2 test cases passed! No cases failed.

Python 自己的三个命令行选项

题面附录列了三种运行 Python 文件的方式。它们的差别不是「风格问题」，是三种不同的调试场景：

-i 是这三个里最该记住的。它把「改代码」和「试代码」之间的往返成本降到最低：

$ python3 -i lab00.py
>>> twenty_twenty_six()
2026
>>> 45 ** 2
2025
>>> presem_survey('abc')
'23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7'
>>> exit()

验证：三条命令在本仓库的真实输出

6. 整份作业回顾

Lab 0 只让你写了一行代码。但如果把它当成「一行代码的作业」，你就浪费了它。这份作业真正交付的是三种思维方式，它们会在后面十周里反复出现。

一、位置是一种状态

「工作目录」是你在这门课里遇到的第一个隐式状态（implicit state）：它不在你敲的命令里，但它决定了命令的含义。同一条 python3 ok，在这个目录里能跑，在那个目录里报错。

这个模式会一直复现。函数调用时的「当前环境」是隐式状态，决定了同一个名字 x 查出来是什么值；对象方法里的 self 是隐式状态，决定了你改的是哪个实例。每当代码「明明一样却行为不同」，先问一句：是不是有个我没看见的状态在起作用。

二、名字绑定不是等式

y = y + 3 这一行是第 2 节的全部价值所在。它逼你接受：等号右边先算完，左边的名字才被改写。这条规则本身两句话就讲完了，但它是整个环境模型的种子。

后面所有让人头大的东西——函数的局部帧、闭包捕获了哪个变量、列表被两个名字同时指着改一个另一个也变——追到底都是这一条规则在不同场景下的展开。如果你现在还觉得「便利贴」这个比喻幼稚，等学到可变列表的别名问题时你会回来找它。

三、能验证 ≠ 能求解

presem_survey 那段「不需要看懂」的代码，其实演示了本课测试体系的底层逻辑：把答案哈希掉，于是验证变得廉价而求解变得不可能。WWPD 题目锁着的时候你答不上来，但一旦答对，ok 立刻能确认——就是这个机制。

更一般地：写代码时，「我怎么知道它对了」这个问题，往往比「我怎么写出来」更值得先想。 doctest 存在的理由就是这个。这门课后面每一道题都会先给你 doctest，再让你写实现——顺序不是偶然的。

动手自测

下面几题不需要写代码，在脑子里做完再展开对答案。做不对说明第 2、3 节还得回去看。

>>> a = 3
>>> b = a
>>> a = a * 2
>>> b
>>> a