在纸上写 Python 代码

像计算机一样读代码

学完你能 你能一行一行地手动运行一小段 Python 程序，并写下它用到的每个名字和值。

在纸上写代码时，没有任何东西会告诉你某一行写错了。你唯一的检查办法，是自己把程序运行一遍：一半在脑子里，一半写在纸上。这叫手动跟踪（英文叫 dry run）：你扮演计算机，拿着笔，一行一行地运行程序。

计算机不知道你的程序是做什么用的。它严格按每一行写的内容，按顺序执行，并且只记得存在各个名字之下的东西。在 Python 里，名字就是一个值的标签，例如 count 或 items。你在跟踪时也要这样做：按这一行实际写的内容去做，而不是按你原本想写的内容去做。

用的工具叫跟踪表。跟踪表里每个名字占一列，每执行一行代码占一行。分四步来做。

1. 在页边给程序的每一行编号，从 1 开始。
2. 画表格。第一列是“行号”，接着每个名字一列，最后一列叫“备注”，用来写发生了什么，例如“条件为真”，或者程序输出了什么。
3. 开始运行。Python 从第 1 行开始，往下执行。每执行一行，就加一行记录：先写行号，再写这一行执行完之后每个名字的值。没有变化的值要从上一行抄下来，这样每一行单独看也能读懂。
4. 对还不存在的名字写短横线（–）。在 Python 里，名字是在第一次有东西存到它下面时才出现的。在此之前使用它，程序会因 NameError 而停止。

以 def 开头的那一行只是创建函数。函数里面的代码要等到有人调用这个函数时才会运行。所以 def 那一行只占一行记录，函数体的记录要到调用的时候才出现。

Python 用缩进（行首的空格）表示哪些代码属于一起。在 for、if 或 def 下面缩进的行，属于它们。回到左边，就离开了那个代码块。

循环语句会执行很多次，所以会有很多行记录。对于 for x in items 这种形式，每当 x 取到下一个元素，就加一行记录，写下 x 的新值。元素取完之后，再加最后一行记录，表示循环结束。和 C、Java 不同，循环结束之后名字 x 仍然存在，保留着最后一个元素。

if 语句只占一行记录。如果条件为假，下一行记录就是缩进代码块之后的第一行代码。

程序调用函数时，函数的参数会成为新的名字，初始值就是你传进去的值。把它们放在同一张表里，并在备注里说明现在在函数内部。函数返回时，把返回值写在备注里。

def count_big(items, limit):
    count = 0
    for x in items:
        if x > limit:
            count = count + 1
    return count


print(count_big([3, 8, 5], 4))

2

for i in range(1, 4):
    print(i)

for i in range(1, 5):
    print(i)

for i in range(7 / 2):
    print(i)

for i in range(7 // 2):
    print(i)

for i in range(3):
    print(i)
    print("done")

for i in range(3):
    print(i)
print("done")

def add(a, b):
    result = a + b

print(add(1, 2))

def add(a, b):
    result = a + b
    return result

print(add(1, 2))

画出名字和对象

学完你能 你能画出 Python 程序在任意一行时的名字和对象，说清 = 做了什么，并分辨可变对象和不可变对象。

在 Python 里，名字不是装着值的盒子。名字是贴在对象上的标签，就像贴在罐子上的标签。两张标签可以贴在同一个罐子上。这一点从代码里看不出来，必须画出来。每次都用同一种画法。

画两列：左边是名字，右边是对象。

对象。每个值都是对象：数字 5、文字 "hi"、列表 [1, 2]。把每个对象画成一个方框，写上它的类型和值，例如 int 10 或 str "hi"。给每个对象一个标签 O1、O2、O3，按创建的顺序编号。列表是一个方框，每个元素占一个单元。单元里如果是数字或文字，可以直接写出值；如果是列表或别的可以改变的对象，就画一支箭头指向它。

名字。名字是左边的一个标签，恰好有一支箭头指向一个对象。名字自己没有值。函数里的名字画在栈帧里，也就是围住它们的一个方框，只在函数运行期间存在。

= 做了什么。语句 b = a 从不复制任何东西。它只是在 a 已经指向的对象上，再贴一张标签 b。语句 a = 5 找到或创建对象 5，并把 a 的箭头移过去。赋值移动的是箭头，不是复制对象。

不可变与可变。不可变对象在创建之后永远不会改变。数字、字符串、元组和 None 是不可变的。可变对象可以原地改变。列表、字典和集合是可变的，你自己定义的类的对象也是。

对不可变对象，s = s + "!" 不会碰旧的字符串，而是创建一个新字符串，并把 s 的箭头移过去。旧字符串上的其他标签看到的仍然是旧文字。对可变对象，b.append(3) 改变的是列表本身，贴在这个列表上的每张标签看到的都是改变后的内容。同一个对象有两个名字，叫做别名。

复制。b = a.copy() 创建一个新列表，单元与原来相同。这是浅拷贝：单元里存的是指向原来那些元素的箭头。如果某个元素本身是列表，两个外层列表就共用它。把箭头画出来，你就会看到这一点。

函数调用。调用会产生新的栈帧。它的参数名是贴在调用者传入的那些对象上的新标签。所以函数可以就地修改可变的实参。但是像 param = something 这样的语句，只会移动栈帧里的标签。

相等与同一个。a == b 问的是两个对象看上去是否相等。a is b 问的是两个名字是否贴在同一个对象上。

垃圾。既没有标签、也没有箭头指向的对象，再也不可能被访问到。Python 会把它清除。在图里把它划掉。

a = [1, 2]
b = a
b.append(3)
c = a.copy()
c.append(4)
x = 10
y = x
y = y + 1
nested = [a, [5]]
dup = nested.copy()
dup[1].append(6)
dup[0] = [0]
print(a, b, c)
print(x, y)
print(nested)
print(dup)

[1, 2, 3] [1, 2, 3] [1, 2, 3, 4]
10 11
[[1, 2, 3], [5, 6]]
[[0], [5, 6]]

scores = [70, 80]
backup = scores
scores.append(90)

scores = [70, 80]
backup = scores.copy()
scores.append(90)

def add_item(item, items=[]):
    items.append(item)
    return items

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

grid = [[0] * 3] * 3
grid[0][0] = 1

grid = [[0] * 3 for _ in range(3)]
grid[0][0] = 1

s = "hi"
s[0] = "H"

s = "hi"
s = "H" + s[1:]

要背熟的语法

学完你能 你能凭记忆写出下面八个 Python 骨架，从最短的开始，每个冒号和缩进都不缺。

有些代码没法当场推出来，你必须不看资料就知道它的形状。这一课的八个骨架，是 Python 里反复要用的。它们都很短，可以背下来。按下面的顺序学，从最短的开始，上一个背牢了，再加下一个。

1. def，以及 if、elif、else。2. for。3. f 字符串。4. 列表的方法。5. 字典的方法。6. 推导式。7. try 和 except。8. 带 __init__ 的类。

背诵的办法：盖住页面，在纸上默写这个骨架，再和页面逐个字符对照。只有完全对、中途没有偷看，才打勾。明天再来一遍。连续三天都能写对的骨架，才算学会。

下面的程序包含全部八个骨架，每个骨架旁边有一条形如 (2) 的注释。先读一遍，再盖住它，在你自己的纸上把每个骨架单独默写出来，每个只写几行。

有两件事永远不能忘。每一个开启代码块的行都以冒号结尾：def、if、elif、else、for、while、class、try、except。每个代码块的缩进量都要一致，通常是四个空格。

列表的方法。words.append(x) 在末尾添加。words.pop() 删除最后一个元素并把它交还给你。words.insert(i, x) 把 x 放在位置 i。words.remove(x) 删除第一个 x。words.sort() 原地排序，返回 None。sorted(words) 返回一个新的排好序的列表。len(words) 是长度。words[0] 是第一个元素，words[-1] 是最后一个，words[1:3] 是切片：位置 1 和 2，因为不包括末尾位置。

字典的方法。d[key] = value 存入。d[key] 读取，键不存在时会以 KeyError 停止。d.get(key, default) 读取，键不存在时给出默认值。key in d 问键是否存在。d.keys()、d.values() 和 d.items() 分别给出键、值和（键，值）对。del d[key] 删除。

# (1) def, with if, elif and else
def average(nums):
    return sum(nums) / len(nums)


def label(score):
    if score >= 8:
        return "high"
    elif score >= 4:
        return "mid"
    else:
        return "low"


# (4) list methods
words = ["pear", "fig", "apple"]
words.append("kiwi")
words.sort()
last = words.pop()
print(words, last, len(words))

# (5) dict methods, and (2) for
lengths = {}
for w in words:
    lengths[w] = len(w)
for key, value in lengths.items():
    # (3) f-string
    print(f"{key} has {value} letters")
print(lengths.get("plum", 0), "fig" in lengths)

# (6) comprehensions
squares = [n * n for n in range(4)]
long_words = [w for w in words if len(w) > 3]
sizes = {w: len(w) for w in words}
print(squares, long_words, sizes)


# (8) class and __init__
class Counter:
    def __init__(self, name):
        self.name = name
        self.total = 0

    def add(self, amount):
        self.total += amount


c = Counter("steps")
c.add(5)
c.add(7)
print(f"{c.name}: {c.total}, average {average([c.total, 8]):.1f}, {label(c.total)}")

# (7) try and except
try:
    n = int("12a")
except ValueError:
    n = -1
print(n)

['apple', 'fig', 'kiwi'] pear 3
apple has 5 letters
fig has 3 letters
kiwi has 4 letters
0 True
[0, 1, 4, 9] ['apple', 'kiwi'] {'apple': 5, 'fig': 3, 'kiwi': 4}
steps: 12, average 10.0, high
-1

words = ["pear", "fig"]
ordered = words.sort()

words = ["pear", "fig"]
ordered = sorted(words)

ages = {"Leon": 20}
age = ages["Emma"]

ages = {"Leon": 20}
age = ages.get("Emma", 0)

words = ["pear", "fig"]
n = words.length
m = words.size()

words = ["pear", "fig"]
n = len(words)

name = "Mia"
print("Hello {name}")

name = "Mia"
print(f"Hello {name}")

手写时常见的错误

学完你能 你能把自己写的 Python 答案像解释器那样再读一遍，抓住本来会丢分的小错。

在计算机上，Python 会在第一个语法错误处拦住你，并告诉你是哪一行。在纸上，没有人拦你，而这些小错每一个都会丢分，尽管它们和你是否理解题目毫无关系。所以你必须自己当自己的解释器。

答案写完之后，再读第二遍。这一遍不要问逻辑对不对，只问形式对不对。照下面的清单，用笔逐项打勾。

1. 每一个开启代码块的行都以冒号结尾：def、if、elif、else、for、while、class、try、except。
2. 同一个代码块的各行缩进量一致。代码块之后的行要退回左边。
3. 每个 ( [ { 都有配对的另一半，每个左引号都有同一种的右引号。
4. = 是存入一个值，== 是提出一个问题。Python 没有 ++：要写 += 1。
5. 用 and、or、not。用 elif，不要写 else if。True、False、None 的首字母要大写。
6. 名字区分大小写：count 和 Count 是不同的名字。
7. 类的每个方法的第一个参数都是 self，读写属性时要用 self。
8. 需要交还一个值的函数要有 return。没有 return，它交还的是 None。
9. 文字和数字不能混着算："5" + 1 是错误。要用 int() 或 str() 转换。
10. 拼错的名字，Python 要等那一行真正运行时才会指出来。把每个名字都和它第一次被存入的地方核对一遍。

下面是最容易丢分的四组错误。每组里第一块是常见的错误写法，第二块是改正后的写法。

def double(x)
    return x * 2

for i in range(3):
print(i)

def double(x):
    return x * 2

for i in range(3):
    print(i)

if x > 0 && y > 0:
    count++
else if x == 0:
    print("zero")

if x > 0 and y > 0:
    count += 1
elif x == 0:
    print("zero")

if x = 3:
    print("three")
if x == 3 or 4:
    print("three or four")

if x == 3:
    print("three")
if x == 3 or x == 4:
    print("three or four")

class Dog:
    def __init__(name):
        self.name = name

    def rename(self, new):
        name = new

class Dog:
    def __init__(self, name):
        self.name = name

    def rename(self, new):
        self.name = new

给自己打分

学完你能 你能对照评分标准诚实地给自己的手写答案打分，找出分数丢在哪里，安排明天的练习，并在限时下写代码。

在纸上，一页写满的答案看起来像是完成了，其实可能是错的。给自己打分能解决这个问题。你拿答案去对照评分标准。评分标准是一组条目，每条值若干分，每条描述一件你能在答案里看到的东西。要严格。真正算数的分数，是一个陌生人会给你的分数。

怎样逐条读评分标准。

1. 读一条。问自己：一个正确的答案里，我到底会看到什么？
2. 在你的答案里找到那样东西，用笔尖点住它。指得出来，就打勾并写下这条的分数；指不出来，这一条就是零分。
3. “差不多”不给半分。只有评分标准写明怎么拆分时，才给一条的部分分数。
4. 检查每一条路径。像“处理空字符串”这样的条目，如果只有正常情况能工作，就是零分。
5. 把各条加起来，把总分写成“得分/满分”的形式放在页面上。

怎样找出分数丢在哪里。把每一个丢掉的分放进四个格子之一。思路：我不知道怎么解。记忆：我知道，但记不起语法或方法名。小错：在我本来会的东西上犯的小错误，例如漏了冒号或漏了 return。时间：我没写完。数一数每个格子。最大的格子告诉你该练什么。思路：重读对应的课。记忆：多做“盖住再默写”。小错：用上一课的解释器检查清单，再加一个很小的测试。时间：练习先做计划。

第二天要做什么。第一，在空白页上不看资料，把同一道题的答案重写一遍。第二，做一道同类型的不同题目。第三，把两份答案再各打一次分。三天后和一周后再重复。当最大的格子换了，说明你在进步。

怎样在限时下写。

1. 先做计划。用掉最初的十分之一时间。写出 def 那一行，再写三四行说明步骤的注释。不要跳过这一步。
2. 代码块之间空一行。你会需要空间补写漏掉的一行。Python 对缩进很敏感，所以缩进要写得尽量清楚，并且每次都用同样的四个空格。
3. 名字要起得清楚：用 count，不要用 c；用 longest，不要用 l。名字清楚，就不会把两个名字混在一起。
4. 用一个很小的输入手算测试。代码写完后，用最小的情况走一遍：只有一项、空列表、只有一个字母的单词。再走一个有重复值的情况。这只要一分钟，却能找出大部分边界错误。
5. 大约每分花一分钟。某一部分卡住了，就写一行注释说明你打算怎么做，然后往下写，回头再补。
6. 留出两分钟做解释器检查。

在“练习”页面里，题型为“手写代码”的题目有手写模式：有计时器、参考答案，以及可以打勾的评分标准。完全按这一课的办法用它：先在纸上写，再打分。

def count_letters(word):
    counts = {}
    for ch in word:
        counts[ch] = counts.get(ch, 0) + 1


print(count_letters("aba"), "(expected {'a': 2, 'b': 1})")

None (expected {'a': 2, 'b': 1})

counts = {}
for ch in word:
    counts[ch] += 1

counts = {}
for ch in word:
    counts[ch] = counts.get(ch, 0) + 1

total = 0
for i in range(1, len(items)):
    total += items[i]

total = 0
for x in items:
    total += x

def total(items):
    s = 0
    for x in items:
        s += x
    print(s)

def total(items):
    s = 0
    for x in items:
        s += x
    return s