先把东西放进盒子,再让程序做决定:Python 变量、数据类型与流程控制
变量是放东西的盒子,列表和字典是装一堆东西的盒子,if、for、while 让程序自己做决定、自己重复干活。本文按 Python 官方教程第 3、4、5 章讲清楚:数字的四种除法与浮点数小毛病、字符串的索引与切片、列表的赋值不复制、字典的 get 与 KeyError、真假判断与短路、if/elif/else、for 与 range、while 与 break/continue/循环 else,另附虚构晨光书店记账脚本一个月 100 次翻车的分布。

先把这篇的边界说清楚。这是站里新开的「Python 基础」系列第一篇,讲的是 Python 这门语言本身怎么用:变量怎么放东西、数字和文字有哪些规矩、列表和字典怎么装一堆东西、程序怎么做决定、怎么重复做一件事。它和站里已有的 JavaScript 系列没有重叠:那边的定时器、事件循环、生成器、Web Workers,讲的都是浏览器里的 JavaScript;这篇讲的是 Python 解释器里的 Python,两门语言的写法和规矩都不一样。下面用到的「晨光书店」是个虚构的练手项目:一家街边小书店,店主想用 Python 写个记账小脚本,算算书多少钱、还剩几本、打几折。本文所有以它为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。所有关于 Python 的语法与行为,都来自 Python 官方教程的三篇文档:《An Informal Introduction to Python》(第 3 章)、《More Control Flow Tools》(第 4 章)、《Data Structures》(第 5 章),来源见每篇的 meta 信息与 evidence 记录。读完这篇,你应该能做到四件事:会用变量把数、字、清单存起来;知道数字和字符串各自的规矩;会用列表和字典装一堆相关的数据;会用 if、for、while 让程序自己做决定、自己重复干活。下一回再讲怎么把重复的活收进函数、把文件拆成模块。
第一步:先跑起来,在解释器里打个招呼
Python 不用先编译再运行,它有个「解释器」:你敲一行,它算一行,立刻给你结果。装好 Python 之后,在终端里输入 python3,看到 >>> 这个提示符,就说明解释器在等你说话了。先打个招呼:
>>> print('你好,晨光书店')
你好,晨光书店
>>> print('今天卖了', 3, '本书')
今天卖了 3 本书
print() 是 Python 自带的函数,括号里放什么,它就把什么打印出来,不带引号;放几个东西,中间自动空一格。写在 # 后面的字是注释,解释器会直接跳过,只给人看:
>>> # 下面这行算今天第一笔账
>>> 39.5 + 29.0
68.5
光会算还不够,算出来的东西得有个地方放。这个地方叫「变量」,写法就是一个名字、一个等号、一个值:
>>> price = 39.5
>>> count = 3
>>> price * count
118.5
price = 39.5 的意思是:把 39.5 这个数交给名字 price 保管,以后再写 price,指的就是 39.5。等号在这里不是数学里的「等于」,而是「交给」的意思。这一点后面还会回来,因为它和比较用的 == 长得很像,却是两回事。如果用了还没交过东西的名字,解释器会直接报错,告诉你这个名字没定义过:
>>> total
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'total' is not defined
看到 NameError 不用慌,它只是在说:这个名字我不认识,你是不是还没给它赋值,或者拼错了。我的判断是:刚学 Python 的头几天,先养成两个习惯——给变量起一眼能看懂的名字,比如 price 而不是 p1;算出来的中间结果先 print() 看一眼再往下写。这两个习惯不花时间,但能省掉一半的找错时间。
第二步:数字会算,但先搞清四种除法和一个浮点数小毛病
解释器最开始就是个计算器。整数叫 int,带小数点的叫 float,加减乘除的符号和数学课上一样,括号可以分组:
>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # 除法永远得到浮点数
1.6
注意第三行:(50 - 5*6) / 4 的结果是 5.0 而不是 5。官方文档的原话是:除法 / 永远返回浮点数。想要整数结果,要用地板除 //;想要余数,用 %;想算乘方,用 **:
>>> 17 / 3 # 普通除法
5.666666666666667
>>> 17 // 3 # 地板除,丢掉小数部分
5
>>> 17 % 3 # 余数
2
>>> 5 * 3 + 2 # 商乘除数加余数,回到 17
17
>>> 5 ** 2 # 5 的平方
25
>>> 2 ** 7 # 2 的 7 次方
128
整数和浮点数混在一起算,整数会先变成浮点数,结果也是浮点数:4 * 3.75 - 1 得 14.0。官方文档里有个算税的例子,正好拿来算书店的账:一本书 100.50 元,税率 12.5%,先算税钱,再算含税价,最后四舍五入到两位小数:
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + 12.5625
113.0625
>>> round(113.0625, 2)
113.06
round() 的第二个参数是保留几位小数。这里还有个新手常踩的小坑:浮点数在计算机里是二进制近似存的,所以 0.1 + 0.2 并不正好等于 0.3,而是 0.30000000000000004。这不是 Python 的 bug,几乎所有语言都这样。我的判断是:算钱的时候别直接拿浮点数比相等,要么用 round() 先修到两位小数再比,要么把钱换算成「分」用整数算。书店的例子里,39.5 元就是 3950 分,整数加减不会出这种尾巴。
第三步:字符串,字是字,数是数
文字在 Python 里叫 str,用单引号或者双引号包起来,效果一样。引号里的数字也还是文字,不是数:
>>> 'spam eggs' # 单引号
'spam eggs'
>>> "Paris rabbit got your back :)! Yay!" # 双引号
'Paris rabbit got your back :)! Yay!'
>>> '1975' # 引号里的数字还是字符串
'1975'
想在单引号包着的字符串里写一个单引号,要么在前面加反斜杠转义,要么改用双引号包起来:
>>> 'doesn\'t' # 用 \' 转义
"doesn't"
>>> "doesn't" # 或者直接用双引号
"doesn't"
反斜杠还有别的用处:\n 是换行,\t 是制表符。print() 会把它们真的解释出来,而直接看一个字符串,看到的是带反斜杠的原样:
>>> s = 'First line.\nSecond line.'
>>> s
'First line.\nSecond line.'
>>> print(s)
First line.
Second line.
如果你就是想让反斜杠保持原样,比如写 Windows 路径,在引号前面加个 r,变成「原始字符串」:print(r'C:\this\name') 会原样打出 C:\this\name,而没有 r 的版本会把 \t 当成制表符、把 \n 当成换行。三引号 """...""" 可以让字符串跨好几行,适合写多行说明。
字符串能拼接,也能重复:
>>> 3 * 'un' + 'ium'
'unununium'
>>> 'Py' 'thon'
'Python'
注意第二行:两个挨在一起的「字符串字面量」会自动拼起来,但这只对字面量管用。变量和字面量挨在一起会报语法错,想拼变量和字符串,得用 +:prefix + 'thon',其中 prefix = 'Py'。
字符串还能按位置取字,这叫「索引」和「切片」。第一个字符的位置是 0,不是 1;负数是从右边往回数:
>>> word = 'Python'
>>> word[0] # 第 0 个字符
'P'
>>> word[5] # 第 5 个字符
'n'
>>> word[-1] # 倒数第一个
'n'
>>> word[-2] # 倒数第二个
'o'
>>> word[0:2] # 从 0 到 2,不含 2
'Py'
>>> word[2:5] # 从 2 到 5,不含 5
'tho'
切片的规矩是「含头不含尾」:开头含,结尾不含。开头不写就是从头开始,结尾不写就是切到最后。所以 word[:2] 是 'Py',word[4:] 是 'on'。这个规矩有个好处:word[:2] + word[2:] 永远等于原来的 word,切开再拼回去,一点不少。下标写超了会报错,但切片写超了不会:
>>> word[42] # 只有 6 个字符
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> word[4:42] # 切片超了只给到有的为止
'on'
>>> word[42:]
''
字符串是「不可变」的:不能直接改其中某一个位置,想改就拼个新的:
>>> word[0] = 'J'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'
最后记住 len() 这个自带函数,它能数出字符串有多长:len('supercalifragilisticexpialidocious') 是 34。书店里用得上:书名太长要截断显示,先 len() 数一数再动手。
第四步:列表,一只盒子装一堆东西
一本书的价格用一个变量就够了,但一整个书架的书,得用一只盒子装起来。这只盒子叫「列表」,用方括号写,里面用逗号隔开。列表里通常装同一类东西,但装不同类型也不会报错:
>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]
列表和字符串一样能索引、能切片,切片出来的是一个新列表:
>>> squares[0] # 取出第一个
1
>>> squares[-1] # 取出最后一个
25
>>> squares[-3:] # 最后三个
[9, 16, 25]
>>> squares + [36, 49, 64, 81, 100] # 拼起来
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
和字符串不一样的是,列表是「可变」的:里面的东西可以直接换、可以直接加。官方文档里有个改错的例子,4 的立方写成了 65,改成 64,再往后加 6 和 7 的立方:
>>> cubes = [1, 8, 27, 65, 125] # 65 写错了,4 的立方是 64
>>> 4 ** 3
64
>>> cubes[3] = 64 # 把错的换掉
>>> cubes
[1, 8, 27, 64, 125]
>>> cubes.append(216) # 在末尾加上 6 的立方
>>> cubes.append(7 ** 3) # 再加上 7 的立方
>>> cubes
[1, 8, 27, 64, 125, 216, 343]
append() 是列表自带的方法,写法是 列表.方法():点前面的东西是对象,点后面的东西是它会干的活。列表的方法还有不少,常用的有 extend()(把另一个可迭代的东西一个个接进来)、insert()(插到指定位置)、remove()(删掉第一个等于这个值的)、pop()(拿走指定位置的并把它还给你,不写位置就拿最后一个)、clear()(清空)、index()(找值的位置)、count()(数出现几次)、sort()(就地排好)、reverse()(就地倒过来)、copy()(浅复制一份)。官方文档的例子:
>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4) # 从位置 4 开始找下一个
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
注意两点。第一,只改列表、不返回新列表的方法,比如 insert、remove、sort,返回值是 None,别指望 fruits.sort() 会给你一个排好的新列表——它直接把原来的排好了。第二,不是所有东西都能排:[None, 'hello', 10] 排不了,因为整数没法和字符串比大小,会报 TypeError。这是官方文档明说的一条设计原则:只改东西的方法一律返回 None。
列表还有个新手最容易踩的坑:赋值从来不复制数据。把一个列表交给另一个变量,两个变量指的是同一只盒子,从一边改,另一边也看得见:
>>> rgb = ["Red", "Green", "Blue"]
>>> rgba = rgb
>>> id(rgb) == id(rgba) # 两个名字指向同一个对象
True
>>> rgba.append("Alph")
>>> rgb
["Red", "Green", "Blue", "Alph"]
想要一份真正的副本,用切片 [:] 或者 copy():切出来的是一只新盒子,再改就不影响原来那只了:
>>> correct_rgba = rgba[:]
>>> correct_rgba[-1] = "Alpha"
>>> correct_rgba
["Red", "Green", "Blue", "Alpha"]
>>> rgba
["Red", "Green", "Blue", "Alph"]
切片还能用来改一段、删一段,甚至清空整个列表。把一段换成新的,把一段换成空列表就是删掉它,把整个列表换成空列表就是清空:
>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters[2:5] = ['C', 'D', 'E'] # 换掉中间一段
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> letters[2:5] = [] # 删掉这一段
>>> letters
['a', 'b', 'f', 'g']
>>> letters[:] = [] # 清空
>>> letters
[]
列表里还能再装列表,也就是「嵌套」:x = [['a', 'b', 'c'], [1, 2, 3]],x[0] 是 ['a', 'b', 'c'],x[0][1] 是 'b'。书店的书单就可以这么装:每一本书是一个小列表,书架就是装着小列表的大列表。不过书有名字、有价格、有库存,用小列表装就得死记「第 0 个是书名、第 1 个是价格」,容易记混。更好的装法在下一步。
第五步:字典,用名字找东西,不用数位置
列表是按位置找东西的:想找第三本书,得数到 2。字典是按名字找东西的:一组「键:值」配对,键是名字,值是东西。电话本就是字典:人名是键,电话是值。官方文档的例子:
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127 # 加一对
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack'] # 按键取值
4098
字典的键在一个字典里是唯一的:用已经用过的键再存一次,旧的值就被忘掉了。键可以是任何不可变的东西,字符串和数字永远可以当键;列表不能当键,因为列表能改,改了就找不到了。拿一个不存在的键去取,会报 KeyError:
>>> tel['irv']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'irv'
不想因为缺键就崩掉,用 get():键在就返回值,键不在就返回 None,或者返回你指定的默认值:
>>> print(tel.get('irv'))
None
>>> tel.get('irv', 0)
0
删掉一对用 del;想知道某个键在不在,用 in;list(字典) 会按放进去的顺序列出所有的键;sorted(字典) 会把键排好序再列出来:
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False
字典还能用 dict() 从一串键值对直接造出来,用「字典推导式」从别的序列算出来,或者用 ** 把两个字典拼起来:
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> {**{'a': 1}, **{'b': 2}}
{'a': 1, 'b': 2}
回到书店:一本书用字典装就清楚多了,书名、价格、库存各有自己的键,不用死记位置:
>>> book = {'title': '三体', 'price': 59.0, 'stock': 7}
>>> book['price']
59.0
>>> book['stock'] = 6 # 卖掉一本,库存减一
>>> book
{'title': '三体', 'price': 59.0, 'stock': 6}
我的判断是:新手先记住三条就够了——列表按位置、字典按名字;改数据之前先想清楚要不要副本;取字典的值先问一句「这个键在不在」,在就用中括号直接取,不在就用 get() 给个默认值。这三条能挡住字典和列表的大部分翻车。
第六步:真假与比较,程序先学会分对错
程序做决定之前,得先会判断一句话是对还是错。比较运算符和数学课上写的一样:< 小于、> 大于、== 等于、<= 小于等于、>= 大于等于、!= 不等于。官方文档的斐波那契例子里就用到了 while a < 10:只要 a 小于 10,就一直循环。
比较可以连起来写:a < b == c 的意思是 a 小于 b,而且 b 等于 c,两个都对才算对。序列之间比较是按字典序一个个比下去的:
>>> (1, 2, 3) < (1, 2, 4)
True
>>> [1, 2, 3] < [1, 2, 4]
True
>>> 'ABC' < 'C' < 'Pascal' < 'Python'
True
但不同类型之间用 < 比大小会报错:3 < 'a' 报 TypeError,因为整数和字符串没有公认的大小关系。官方文档的原话是:解释器不会随便给个顺序,而是直接报错。
判断可以组合起来:and 是「而且」,or 是「或者」,not 是「不是」。这三个是「短路」运算符:从左往右算,答案一旦定了,后面的就不算了。比如 A and B and C 里 B 是假的,C 根本不会被算到。还有一个容易忽略的点:or 返回的不是 True 或 False,而是最后算到的那个值本身:
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'
空字符串是第一个值,但它是「假」的,所以 or 继续往后找,找到了 'Trondheim'。这就是「真假」的另一层意思:在 Python 里,不只是 True 和 False 才算真假——任何非零的整数是真,零是假;任何非空的序列是真,空序列是假:
>>> bool(0)
False
>>> bool(3)
True
>>> bool('')
False
>>> bool([])
False
>>> bool([0])
True
注意最后一行:[0] 里装的是 0,但列表本身不是空的,所以是真。别把「列表里装的东西是真是假」和「列表本身空不空」混在一起。还有两个成员运算符:in 问「在不在里面」,is 问「是不是同一个对象」——第五步的 id(rgb) == id(rgba) 就是在问后一件事。另外提一句:Python 里想在表达式里顺手赋值,得显式用「海象运算符」:=,比如 (n := 6) 会把 6 交给 n 再继续算。这是为了避免把 = 误写成 == 的老毛病带进表达式里。
第七步:if,分情况说话
会判断对错之后,程序就能分情况说话了。if 的写法是:if 加一个条件,加一个冒号,下一行缩进四格写条件成立时要干的事。条件不成立想再分一档,用 elif;所有条件都不成立时要干的事,写在 else 里。elif 可以有零个或多个,else 可写可不写。官方文档的例子是把一个数分类:
>>> x = int(input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
... x = 0
... print('Negative changed to zero')
... elif x == 0:
... print('Zero')
... elif x == 1:
... print('Single')
... else:
... print('More')
...
More
输入 42,前面三条都不成立,落到 else,打出 More。同一段代码,输入 -3 会打出 Negative changed to zero,输入 0 是 Zero,输入 1 是 Single。这里有个细节:int(input(...)) 是把人输入的文字先转成整数再比较——input() 拿到的永远是字符串,直接拿字符串和数字比大小会报 TypeError,第三步讲过。
书店的例子:按库存量给一本书贴标签:
>>> stock = 0
>>> if stock == 0:
... print('没货了,该进货了')
... elif stock < 5:
... print('只剩几本了')
... else:
... print('货还够')
...
没货了,该进货了
冒号和缩进是 Python 分组的办法:冒号说「下面这几行是一伙的」,缩进说「这一伙到哪里结束」。同一层里的每一行,缩进必须一样多。官方文档的风格建议是缩进四格、不用制表符。我的判断是:新手期的缩进错,十有八九不是「不会缩进」,而是混用了空格和制表符,或者从别处粘过来的代码缩进不一样。让编辑器显示不可见字符,或者干脆统一用四个空格,能省很多事。
顺便提一句:要拿同一个值跟好几个常量一个个比,match 语句也可以做到,它是 Python 3.10 加上的「模式匹配」,能按字面量、元组、字典、类去匹配,第一个对上的分支才执行。这篇先不展开,知道有这么个东西、以后写多分支判断时可以回来查就够了。
第八步:for 与 range,一个一个来
书店有几十本书,一本一本手写 print() 不现实。for 循环就是「一个一个来」:它会按顺序拿出序列里的每一项,轮流干同一件事。Python 的 for 和 C 语言的不一样:它不数数,它直接遍历一个序列里的东西:
>>> words = ['cat', 'window', 'defenestrate']
>>> for w in words:
... print(w, len(w))
...
cat 3
window 6
defenestrate 12
如果确实要数数,用自带的 range()。它生成一串等差数字,但注意:终点那个数永远不包含在内。range(10) 生成 10 个值,刚好是长度为 10 的序列的合法下标:
>>> for i in range(5):
... print(i)
...
0
1
2
3
4
>>> list(range(5, 10))
[5, 6, 7, 8, 9]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(-10, -100, -30))
[-10, -40, -70]
>>> sum(range(4)) # 0 + 1 + 2 + 3
6
range(5, 10) 是从 5 开始、到 10 之前;range(0, 10, 3) 是步长 3;步长还能是负数。直接打印一个 range 会看到 range(0, 10),它不是列表,只是一个「能一个一个吐出数字」的东西,官方文档叫它「可迭代对象」:它不真的把整张表造出来,所以省地方。想把它变成真的列表,用 list() 包一下。
循环里常要同时拿到位置和值,用 enumerate();要同时走两个序列,用 zip();想倒着走,用 reversed();想排好序再走,用 sorted();想去重再排好序,用 sorted(set(...)):
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear
还有一个官方文档特意提醒的坑:循环的时候不要直接改正在循环的那个集合,容易改漏或者改错。稳妥的办法是循环一份副本,或者另外造一个新集合:
>>> users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}
>>> for user, status in users.copy().items():
... if status == 'inactive':
... del users[user]
>>> users
{'Hans': 'active', '景太郎': 'active'}
书店的例子:把三本书的书名、价格、库存装进一个列表,每个元素是一本字典,循环一遍就能算出库存总价值,还能挑出有货的:
>>> books = [
... {'title': '海底两万里', 'price': 39.5, 'stock': 12},
... {'title': '小王子', 'price': 29.0, 'stock': 0},
... {'title': '三体', 'price': 59.0, 'stock': 7},
... ]
>>> in_stock = [bk['title'] for bk in books if bk['stock'] > 0]
>>> in_stock
['海底两万里', '三体']
>>> total = sum(bk['price'] * bk['stock'] for bk in books)
>>> round(total, 2)
887.0
库存总价值是 887.0 元:39.5 乘 12 是 474.0,59.0 乘 7 是 413.0,加起来 887.0。第一行那种方括号里带 for 的写法叫「列表推导式」,是官方文档第 5 章教的简写:先写要什么,再写从哪来、要满足什么条件,意思和先建空列表、再循环 append() 完全一样,只是更短。
第九步:while、break、continue,循环的三种刹车与一个占位符
for 是「把这些挨个过一遍」,while 是「只要条件还对,就一直干」。官方文档的斐波那契例子就是 while 的经典用法:
>>> a, b = 0, 1
>>> while a < 10:
... print(a)
... a, b = b, a+b
...
0
1
1
2
3
5
8
第一行是「多重赋值」:a 和 b 同时拿到 0 和 1;最后一行也一样,右边的两个值先算好,再同时交给左边的两个名字。条件 a < 10 一直成立就一直循环,a 长到 10 就停下。print(a, end=',') 还能把每次输出的换行换成逗号,一行打出 0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,。
while 最怕的就是条件永远成立:忘了更新条件,循环就停不下来了。图里的第九类翻车就是这个。下面两种刹车是 break 和 continue:break 是跳出最里面那层循环,continue 是跳过这一轮、直接下一轮:
>>> for n in range(2, 10):
... for x in range(2, n):
... if n % x == 0:
... print(f"{n} equals {x} * {n//x}")
... break
...
4 equals 2 * 2
6 equals 2 * 3
8 equals 2 * 4
9 equals 3 * 3
>>> for num in range(2, 10):
... if num % 2 == 0:
... print(f"Found an even number {num}")
... continue
... print(f"Found an odd number {num}")
...
Found an even number 2
Found an odd number 3
Found an even number 4
Found an odd number 5
Found an even number 6
Found an odd number 7
Found an even number 8
Found an odd number 9
第一个例子里,break 一找到因子就跳出内层循环,所以每个合数只打出第一个因子。第二个例子里,偶数打完就 continue,跳过了下面那句「找到奇数」,所以偶数只出现一次、奇数也只出现一次。
循环还能配一个 else:循环正常跑完、没有遇到 break,else 里的代码才执行;中途 break 了,else 就不执行了。找质数的例子最能说明这点:
>>> for n in range(2, 10):
... for x in range(2, n):
... if n % x == 0:
... print(n, 'equals', x, '*', n//x)
... break
... else:
... # 循环跑完没找到因子
... print(n, 'is a prime number')
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3
注意 else 是对着 for 的,不是 if 的——缩进就能看出来。官方文档还给了个小建议:可以把循环的 else 理解成 try 的 else:try 的 else 是「没出异常才跑」,循环的 else 是「没遇到 break 才跑」。
最后是 pass:它什么都不干,只是个占位符。语法上必须写点什么、但你还没想好写什么的时候,先放个 pass 顶着:
>>> while True:
... pass # 等键盘中断,先占个位
...
>>> def initlog(*args):
... pass # 记得回来实现它!
...
第十步:数一数新手最常翻的七种车,再往下走
下面这张图,是虚构的晨光书店记账脚本在学 Python 第一个月里的 100 次翻车,按原因分的布。数字是编的、为了讲清楚分布,但每一类都是前面九步里讲过的真坑:
排前三的加起来 58 次,都是把 Python 当成别的语言来写:忘了冒号,是因为别的语言靠大括号分组,Python 靠冒号加缩进;缩进对不齐,是因为别的语言缩进只是好看,Python 的缩进就是分组本身;把 = 写成 ==,是因为别的语言里这俩也长得像,但 Python 里一个是「交给」、一个是「比较」。第四类是数字和字符串直接相加:Python 不会悄悄帮你把数字变成文字,39.5 + '元' 会直接报 TypeError,想拼得先用 str() 转,或者用 f 字符串。第五类下标越界和第七类字典缺键,前面都讲过:切片超了没事,下标超了报错;字典缺键用 get()。第六类是 while 忘了更新条件,循环停不下来,写 while 的时候先想好「什么情况下它会停」,再写循环体。
读到这里,晨光书店的记账脚本已经能跑起来了:书单存在列表里,每本书是字典,循环一遍算出库存总值 887.0 元,满 50 元的打九折——三体 59.0 元打完折是 53.1 元,海底两万里 39.5 元不够 50,不打折。下一回我们把这些零散的步骤收进函数:打折的规矩写成一个函数,结账写成一个函数,再把函数们分到不同的文件里,变成能互相 import 的模块。那时候你会发现,第一篇里写的每一行,都还在,只是住进了更整齐的房子里。
评论 (0)
原始来源
相关文章
异常不是程序坏了,是 Python 在用有名字的办法告诉你哪里出了问题。本文按 Python 官方教程第 8 章讲清楚:语法错误与异常、try/except、except 按继承匹配、哪些错该接哪些不该接、raise、else、finally、with、自定义异常、异常链与 ExceptionGroup,另附虚构晨光书店记账脚本第四个月 100 次翻车的分布。
类是把数据和规矩打包在一起的办法:一个 Book 类做出每本书自己的状态,方法让对象自己干活,继承让电子书站在纸书肩膀上。本文按 Python 官方教程第 9 章讲清楚:class 与 __init__、self、方法、类变量与实例变量、属性查找、继承与覆盖、super()、下划线私有约定、dataclass、__iter__ 与 __next__,另附虚构晨光书店记账脚本第三个月 100 次翻车的分布。
函数是把重复的活收进一个名字,模块是把定义装进文件、用 import 拿出来。本文按 Python 官方教程第 4 章 4.8–4.9 节与第 6 章讲清楚:def 与 return、局部与全局、默认参数只算一次、关键字参数、*args 与 **kwargs、/ 与 *、lambda、文档字符串与注解、模块的几种引用、__main__ 守卫、包与搜索路径,另附虚构晨光书店记账脚本第二个月 100 次翻车的分布。