返回探索
指南VibeFix 内容整理更新于 2026年11月22日

程序翻车别慌,先把错接住:Python 异常处理

异常不是程序坏了,是 Python 在用有名字的办法告诉你哪里出了问题。本文按 Python 官方教程第 8 章讲清楚:语法错误与异常、try/except、except 按继承匹配、哪些错该接哪些不该接、raise、else、finally、with、自定义异常、异常链与 ExceptionGroup,另附虚构晨光书店记账脚本第四个月 100 次翻车的分布。

真实照片:一位开发者指着笔记本电脑屏幕上的代码,身后还有两台显示代码的显示器

先把这篇的边界说清楚。这是「Python 基础」系列第四篇,接着前三篇往下走:第一篇讲了变量、类型和流程控制,第二篇讲了函数与模块,第三篇讲了类与继承。这篇讲异常处理:程序翻车的时候,怎么把错接住、怎么自己喊停、怎么保证收尾一定跑。它和第三篇是互相独立的两套本事,但有一个交点:这篇最后讲的自定义异常,本身就是用类写出来的——到时候你会发现,类那篇不是白学的。下面用到的「晨光书店」还是那个虚构的练手项目:一家街边小书店,店主的记账小脚本已经会算库存、会打折、会用类管书了。这篇要解决的新问题是:脚本跑着跑着总会遇到意外——店主输错一个数、要读的文件不存在、库存不够还要硬卖——以前这些意外一来程序就直接崩掉,什么都不剩。所有关于异常的说法,都来自 Python 官方教程第 8 章《Errors and Exceptions》,来源见每篇的 meta 信息与 evidence 记录;本文所有以晨光书店为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。读完这篇,你应该能做到四件事:分得清语法错误和异常,会读报错的最后一行;会写 try/except 接住指定的错,知道多个 except 子句按什么顺序匹配;会用 raise 自己抛错、用 else 和 finally 分清「没出错才跑」和「不管怎样都跑」;会给书店的错起个自己的异常名字,知道什么时候该用 with 收尾。

第一步:两种错——语法错是写错了,异常是跑错了

官方教程第 8 章开头先分了两种错,至少有两种可以区分的错误:语法错误和异常。语法错误也叫解析错误,是学 Python 时最常见的抱怨:程序还没跑,解析器先不干了。官方例子是少了个冒号:

>>> while True print('Hello world')
  File "<stdin>", line 1
    while True print('Hello world')
               ^^^^^
SyntaxError: invalid syntax

解析器会把出错的那行重复一遍,用小箭头指着它发现问题的地方。注意箭头指的地方不一定是该改的地方:这个例子里错是在 print 前面少了个冒号,但箭头指在 print 上。文件名和行号会一起印出来,告诉你该去哪找。

异常不一样:语句本身写得没错,跑起来才出问题。官方例子一口气给了三个:

>>> 10 * (1/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    10 * (1/0)
          ~^~
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    4 + spam*3
        ^^^^
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    '2' + 2
    ~~~~^~~
TypeError: can only concatenate str (not "int") to str

三个错的名字各不相同:ZeroDivisionError 是除以零,NameError 是用了没定义的名字,TypeError 是把字符串和整数直接相加。报错的最后一行告诉你发生了什么,前面那几行叫「回溯」,列出出错时的调用栈。我的判断是:新手读报错先看最后一行就够了——它直接告诉你错的类型和原因;回溯是顺着找「错从哪一行开始」的地图,程序越长越用得上。记住这句话:异常不是「程序坏了」,它是 Python 在用一种有名字的办法告诉你「这里出问题了」。有名字,就能接住它,这就是下一篇……不,这就是这一篇要讲的事。

第二步:try/except——先接住再说

官方教程 8.3 节的办法是:写一段能处理指定异常的程序。官方例子是反复问用户要一个整数,直到拿到合法的数为止,同时允许用户用 Ctrl-C 中断程序(中断会以 KeyboardInterrupt 异常的形式发出来):

>>> while True:
...     try:
...         x = int(input("Please enter a number: "))
...         break
...     except ValueError:
...         print("Oops!  That was no valid number.  Try again...")
...

官方把 try 语句的工作方式列了四条:先执行 try 子句;没出异常就跳过 except 子句,整条 try 语句结束;try 子句里出了异常,剩下的部分跳过,如果异常类型和 except 后面写的类型对得上,就执行 except 子句,然后继续往下跑;如果对不上,就交给外层的 try 语句,要是一直没人接,就是未处理的异常,程序停下来并打印报错信息。

书店的版本:店主在终端里输价格,输错了不该整个脚本崩掉,该提示一句再问一遍。为了不用真的等人敲键盘,下面的例子用一个列表假装是店主先后输的东西:

def parse_price(text):
    """把店主输的价格转成数字,转不成返回 None。"""
    try:
        return float(text)
    except ValueError:
        return None

>>> parse_price('59.0')
59.0
>>> parse_price('五十九')
>>> parse_price('39.5')
39.5

parse_price('五十九') 打印出来是空的,因为返回的是 None。一个 try 语句可以有多个 except 子句,给不同的异常各配一个处理办法,但最多只有一个处理办法会被执行。官方教程还提醒:处理办法只处理对应 try 子句里发生的异常,同一个 try 语句的其他处理办法里出的异常,它不管。多个异常可以写进一个元组里一起接:

try:
    n = int(text)
    total = 100 / n
except (ValueError, ZeroDivisionError):
    total = None

输的不是数,或者输了 0,都会让 total 变成 None。我的判断是:try 里只放「可能出这一种错的那几行」,别把整个函数都塞进 try——塞得越多,出错时越不知道是哪一行出的错。这条规矩在第十步的图里排第三。

第三步:异常也有亲戚——except 的匹配按继承来

except 后面写的类,会接住这个类本身和它的派生类的实例,反过来不行:写了派生类的 except 子句,接不住基类的实例。官方教程用三个异常类把这件事讲得很干净:

class B(Exception):
    pass
class C(B):
    pass
class D(C):
    pass

for cls in [B, C, D]:
    try:
        raise cls()
    except D:
        print("D")
    except C:
        print("C")
    except B:
        print("B")

这段代码会按顺序打印 B、C、D。官方还补了一句:如果把 except 子句的顺序颠倒过来,先写 except B,那就会打印 B、B、B——因为第一个匹配上的 except 子句就被触发了。B 是 C 和 D 的长辈,写在前面就把后辈的全接走了,后面的子句永远轮不上。所以规矩是:具体的异常写前面,宽泛的写后面。这和第三篇讲的继承查找是一个道理:越具体的越先匹配。

异常发生时还可以带上一些值,叫异常的「参数」。except 子句可以在异常名后面指定一个变量,这个变量会绑到异常实例上;异常实例通常有个 args 属性存着这些参数。官方例子:

>>> try:
...     raise Exception('spam', 'eggs')
... except Exception as inst:
...     print(type(inst))    # the exception type
...     print(inst.args)     # arguments stored in .args
...     print(inst)          # __str__ allows args to be printed directly
...     x, y = inst.args     # unpack args
...     print('x =', x)
...     print('y =', y)
...
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs

内建异常类型都定义了 __str__(),可以直接把参数打印出来,不用显式取 .args。书店的例子:卖书时库存不够,异常里带上书名、要的数量和实际库存,处理的人一眼就知道差多少——第九步会写这个例子。我的判断是:except Xxx as err 这个写法要养成习惯,不写 as err 就等于把错因扔了;报错信息是留给处理代码和以后查账的人看的,不是摆设。

第四步:哪些错该接,哪些不该接

不是所有异常都该被接住。官方教程 8.3 节讲了异常家族的家谱:BaseException 是所有异常的共同基类;它的一个子类 Exception 是所有非致命异常的基类;不是 Exception 子类的异常通常不处理,因为它们表示程序应该终止,包括 sys.exit() 抛出的 SystemExit 和用户想中断程序时抛出的 KeyboardInterrupt。

这就是「裸 except」和「except Exception」的区别所在。except Exception 能接住几乎所有非致命异常,但接不住 KeyboardInterrupt 和 SystemExit——用户按 Ctrl-C 还是能停掉程序。而不写异常名的裸 except: 什么都接,连中断都拦下来,程序就停不掉了。官方教程的建议是:处理异常时,类型写得越具体越好,让没想到的异常继续往上传。我的判断是:把这句话当成这篇的中心思想——接异常不是为了「让程序永远不崩」,而是为了「让预料之中的错有预料之中的处理,让预料之外的错继续往上走、被人看见」。

官方教程给了一个处理 Exception 的最常见模式:打印或记录异常,然后重新抛出来,让调用者也有机会处理:

import sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error:", err)
except ValueError:
    print("Could not convert data to an integer.")
except Exception as err:
    print(f"Unexpected {err=}, {type(err)=}")
    raise

文件打不开是 OSError,内容转不成整数是 ValueError,别的意外先记下来再用裸 raise 原样抛出去。注意最后的 raise 后面什么都不写——它会把当前正在处理的那个异常重新抛出去,调用链上层的人还能再接一次。书店的版本:读进货单文件时文件不存在,提示一句「进货单文件没找到」;文件里某一行不是数字,提示「第几行不是数字」;别的意外先记下来再抛出去,别悄悄吞掉。

异常处理还有一个容易被忽略的点:处理办法不只处理 try 子句里直接发生的异常,也处理 try 子句里调的函数(哪怕是间接调的)里发生的异常。官方例子:

>>> def this_fails():
...     x = 1/0
...
>>> try:
...     this_fails()
... except ZeroDivisionError as err:
...     print('Handling run-time error:', err)
...
Handling run-time error: division by zero

1/0 写在 this_fails 里,错却被外面的 try 接住了。异常是会「冒泡」的:哪一层都没接住,它就一路冒到最外层,程序停下。这也是为什么「在 try 里只放可能出错的那几行」重要——放得越多,冒泡的源头越难找。

第五步:raise——自己喊停

有时候不是等错发生,而是程序自己发现不对劲,主动让一个指定的异常发生。官方教程 8.4 节:raise 语句让程序员强制一个指定的异常发生。官方例子:

>>> raise NameError('HiThere')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    raise NameError('HiThere')
NameError: HiThere

raise 唯一的参数说明要抛的异常,必须是异常实例或异常类(从 BaseException 派生的类,比如 Exception 或它的子类)。如果传的是类,Python 会隐式地用无参构造把它实例化:raise ValueError 就是 raise ValueError() 的简写。

书店的例子:卖书之前先检查库存,库存不够就主动喊停,而不是等到库存变成负数才发现账错了:

def check_stock(stock, wanted):
    """库存不够就主动抛错,别等账算错了才发现。"""
    if wanted > stock:
        raise ValueError(f"只要 {wanted} 本,库存只有 {stock} 本")
    return stock - wanted

>>> check_stock(7, 2)
5
>>> check_stock(7, 99)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    check_stock(7, 99)
  File "<stdin>", line 4, in check_stock
ValueError: 只要 99 本,库存只有 7 本

7 本卖 2 本剩 5 本;要 99 本,库存只有 7 本,直接抛 ValueError,错因写在异常的消息里。第三篇里 sell() 用的是「不够就返回 False」;两种写法各有用的地方:返回 False 是把决定权交给调用的人,调用的人忘了检查返回值,错就悄悄过去了;抛异常是「这件事不能就这么过去」,调用的人必须处理,不处理程序就停下。我的判断是:调用的人「必须知道」的事,用 raise;调用的人「可以自己决定怎么办」的事,用返回值。库存不够硬卖,账会错,属于前者。

还有一种 raise 是不带参数的:如果你只需要知道异常发生了、但不打算处理它,可以用这种更简单的形式重新抛出:

>>> try:
...     raise NameError('HiThere')
... except NameError:
...     print('An exception flew by!')
...     raise
...
An exception flew by!
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
    raise NameError('HiThere')
NameError: HiThere

先打印一句「有个异常飞过去了」,再原样抛出去。第四步那个「记下来再抛」的模式,用的就是这个写法。

第六步:else——没出错才跑的代码

try...except 还有一个可选的 else 子句,放在所有 except 子句之后:只有 try 子句没抛异常时,它才执行。官方例子是打开几个文件、数行数:

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except OSError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

文件打不开,打印一句打不开;打得开,就数行数、关文件。官方还说了一句关键的话:用 else 子句比把额外代码加进 try 子句更好,因为这样可以避免不小心接住那些「本来不在 try 保护范围里」的异常。举个书店的例子:读价格文件,转数字这一步要是放在 try 里,转数字出的 ValueError 会被当成「文件打不开」处理,错上加错;放在 else 里,转数字的错就不会被文件那一层的 except 误接。

def read_first_price(path):
    """读进货单第一行的价格:文件打不开提示文件问题,数字转不成提示数字问题。"""
    try:
        f = open(path, 'r')
    except OSError:
        return '文件打不开'
    else:
        with f:
            text = f.readline().strip()
        try:
            return float(text)
        except ValueError:
            return '数字转不成'

这里的 with f: 是第八步要讲的写法,先看个样子。我的判断是:else 是 try 语句里最容易被跳过的一节,但它解决的是一个真问题——「成功之后要做的事」和「可能出错的事」得分开写。写 try 的时候先问一句:这段代码是「可能出错」,还是「出错了才不用跑」?前者放 try,后者放 else。

第七步:finally——不管怎样都要收尾

try 语句还有一个可选子句 finally,专门用来定义「在任何情况下都必须执行的收尾动作」。官方例子:

>>> try:
...     raise KeyboardInterrupt
... finally:
...     print('Goodbye, world!')
...
Goodbye, world!
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
    raise KeyboardInterrupt
KeyboardInterrupt

KeyboardInterrupt 没人接,但 finally 里的「Goodbye, world!」还是先打印了,异常随后才继续往上抛。官方把规则列得很细:如果 try 子句里出了异常,异常可能被 except 接住;如果没被接住,异常会在 finally 执行完之后重新抛出来;如果 except 或 else 子句里又出了异常,同样先跑 finally 再重新抛;如果 finally 子句里执行了 break、continue 或 return,异常就不会重新抛出来——这容易让人糊涂,所以不提倡,文档还注明从 3.14 版起编译器会对它发出 SyntaxWarning;如果 try 语句走到了 break、continue 或 return,finally 会先执行,再执行那个 break、continue 或 return。

官方还给了两个会让人愣一下的例子。第一个是 bool_return():

>>> def bool_return():
...     try:
...         return True
...     finally:
...         return False
...
>>> bool_return()
False

try 里要返回 True,finally 里又返回 False,最后拿到的就是 False:如果 finally 子句里有 return,返回的就是 finally 那个 return 的值,不是 try 那个。第二个是官方的 divide 例子,把 except、else、finally 全用上了:

>>> def divide(x, y):
...     try:
...         result = x / y
...     except ZeroDivisionError:
...         print("division by zero!")
...     else:
...         print("result is", result)
...     finally:
...         print("executing finally clause")
...
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    divide("2", "1")
  File "<stdin>", line 3, in divide
    result = x / y
TypeError: unsupported operand type(s) for /: 'str' and 'str'

2 除以 1 得 2.0,else 打印结果,finally 照常跑;2 除以 0,except 打印「除以零」,finally 照常跑;两个字符串相除,except 只接 ZeroDivisionError,接不住 TypeError,finally 先跑,然后异常重新抛出来。我的判断是:finally 只干一件事——收尾。关文件、关连接、把「正在处理」的牌子摘下来,这些事不管成功失败都得做,就写进 finally;别在 finally 里写业务逻辑,更别在 finally 里写 return,官方文档明确说不提倡,3.14 版起还会警告。

第八步:with——自带收尾的写法

有些对象自带标准的收尾动作:不管用它的操作成功还是失败,不再需要它的时候都该收尾。官方例子是读文件:

for line in open("myfile.txt"):
    print(line, end="")

这段代码的问题是,文件会在这部分代码跑完之后、一段不确定的时间里一直开着。小脚本没事,大应用就可能出问题。with 语句让文件这样的对象保证及时、正确地收尾:

with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

这条语句跑完之后,文件 f 一定是关着的,哪怕处理这些行的时候出了问题也一样。官方原话:像文件这样提供预定义收尾动作的对象,会在自己的文档里说明这一点。书店的例子:读进货单、写日报,统统用 with open(...) as f,文件一定会被关上,不用自己写 finally 去关。我的判断是:with 就是「自带 finally 的简写」,但它只管收尾、不管接错——文件里某一行转不成数字,该接的 ValueError 还得在 with 里面或外面另写 try。收尾和接错是两件事,别指望一个 with 全包了。

第九步:自定义异常——给书店的错起个名字

程序可以自己定义异常:新建一个异常类。官方教程 8.6 节说,异常通常应该直接或间接从 Exception 类派生;异常类可以做任何别的类能做的事,但通常保持简单,往往只提供一些属性,让异常的处理者能提取到关于错误的信息。大多数标准异常的名字都以 Error 结尾。

书店的例子:库存不够是个「业务上的错」,不是 Python 自带的哪种错,值得起个自己的名字:

class OutOfStockError(Exception):
    """库存不够:想卖的数量超过了现有库存。"""
    def __init__(self, title, wanted, stock):
        super().__init__(f"{title} 只要 {wanted} 本,库存只有 {stock} 本")
        self.title = title
        self.wanted = wanted
        self.stock = stock

def sell_book(title, stock, wanted):
    """卖书:够卖返回剩下的库存,不够就抛 OutOfStockError。"""
    if wanted > stock:
        raise OutOfStockError(title, wanted, stock)
    return stock - wanted

>>> sell_book('三体', 7, 2)
5
>>> try:
...     sell_book('三体', 7, 99)
... except OutOfStockError as err:
...     print(err)
...     print(err.title, err.wanted, err.stock)
...
三体 只要 99 本,库存只有 7 本
三体 99 7

7 本卖 2 本剩 5 本;要 99 本,抛 OutOfStockError,异常消息里写着「三体 只要 99 本,库存只有 7 本」,异常对象身上还挂着 title、wanted、stock 三个属性,处理代码想拿哪个拿哪个。因为 OutOfStockError 是从 Exception 派生的,except Exception 也能接住它;反过来,要是自定义异常没从 Exception 派生(比如直接从 BaseException 派生),except Exception 就接不住——这是第十步图里的一类翻车。

起名字也有讲究:异常类名以 Error 结尾是惯例,OutOfStockError 比 OutOfStock 一眼就能看出是个异常。我的判断是:别什么错都自定义——文件打不开、数字转不成,Python 自带的 OSError、ValueError 已经够用了;只有「这个错是你的业务独有的、调用的人需要专门处理」的时候,才值得新起一个名字。书店的「库存不够」就是这样的错:调用的人要根据它决定是提示缺货、还是去进货,和「数字转不成」完全是两回事。

第十步:错上加错——异常链、notes 与 ExceptionGroup,以及一张翻车分布图

最后三件官方教程里的进阶工具,各讲一句,知道有这回事就行。第一件是异常链:如果在 except 里面又抛了新的异常,没处理的旧异常会被附在新异常上一起显示。官方例子是打开数据库文件失败,又抛了个 RuntimeError:

>>> try:
...     open("database.sqlite")
... except OSError:
...     raise RuntimeError("unable to handle error")
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
    open("database.sqlite")
FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
    raise RuntimeError("unable to handle error")
RuntimeError: unable to handle error

想明确说「新异常就是旧异常直接导致的」,用 raise ... from ...:raise RuntimeError('Failed to open database') from exc,报错里会写「The above exception was the direct cause of the following exception」;想关掉自动链,用 raise RuntimeError from None。我的判断是:转换异常的时候写上 from 是个好习惯——不写的话,查错的人看到两个异常,还得猜它们有没有关系;写了 from,关系就写在报错里了。

第二件是 add_note:异常创建之后,还能往上加信息。官方例子:

>>> try:
...     raise TypeError('bad type')
... except Exception as e:
...     e.add_note('Add some information')
...     e.add_note('Add some more information')
...     raise
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
    raise TypeError('bad type')
TypeError: bad type
Add some information
Add some more information

两条备注按加的顺序出现在异常后面。第三件是 ExceptionGroup:把一串异常实例包在一起一次抛出来,专门用来「一次收集多个错、而不是抛第一个就停」。官方例子:

>>> def f():
...     excs = [OSError('error 1'), SystemError('error 2')]
...     raise ExceptionGroup('there were problems', excs)
...
>>> try:
...     f()
... except Exception as e:
...     print(f'caught {type(e)}: {e}')
...
caught <class 'ExceptionGroup'>: there were problems (2 sub-exceptions)

用 except* 代替 except,还能从组里按类型挑着接:except* OSError 只接组里的 OSError,剩下的继续往上传。书店脚本用不上异常组——一次只卖一本书;但批量处理进货单、一批里好几行都有错的时候,攒起来一次报,比第一行错了就停要实用得多。

最后是这篇的翻车分布图。示例:虚构晨光书店记账脚本学 Python 第四个月,100 次和异常处理有关的翻车,原因分布如下。图里排第一的错,是不写异常名、什么都接的裸 except——连用户按 Ctrl-C 想停程序都被拦下来了。

学 Python 第四个月 100 次异常处理翻车的原因分布:裸 except 什么都接、连 KeyboardInterrupt 都拦了 22 次,只写 except Exception 不分种类 18 次,try 里塞太多代码、不知道哪行出的错 16 次,忘了 finally、文件没关 14 次,raise 新异常丢了原来错因、没写 from 12 次,自定义异常没继承 Exception、except Exception 接不住 10 次,finally 里写 return、把原来的返回值盖掉 8 次

回头看这篇的十步,其实只讲了三件事。第一,错分两种:语法错是写错了,跑之前就被拦下;异常是跑错了,有名字、能接住,读报错先看最后一行。第二,接错有分寸:类型写具体,具体的写前面、宽泛的写后面;该接的接,不该接的(比如 KeyboardInterrupt)放它走;记下来再抛,别悄悄吞掉。第三,收尾有保证:没出错才跑的放 else,不管怎样都跑的放 finally,自带收尾的用 with;业务独有的错值得起个自己的异常名字。下一篇留给文件读写:进货单和日报总不能只存在内存里——到时候这篇的 try/except/finally 和 with 会再回来,因为读文件和写文件是最常出异常的地方。

阅读 1评论 0

评论 (0)

ME
0/1000
评论加载中...

原始来源

浏览项目广场发布你的项目

相关文章

真实照片:一家独立书店的书架走道,木质书架上摆满了彩色书脊,暖色灯光
指南
把书做成对象,把规矩写进类里:Python 类与对象

类是把数据和规矩打包在一起的办法:一个 Book 类做出每本书自己的状态,方法让对象自己干活,继承让电子书站在纸书肩膀上。本文按 Python 官方教程第 9 章讲清楚:class 与 __init__、self、方法、类变量与实例变量、属性查找、继承与覆盖、super()、下划线私有约定、dataclass、__iter__ 与 __next__,另附虚构晨光书店记账脚本第三个月 100 次翻车的分布。

项目创作Python学习与成长
真实照片:双手在一台笔记本电脑上打字,屏幕上是带 def 语句的 Python 代码,旁边放着蓝色笔记本和眼镜
指南
把重复的活收进函数,把文件拆成模块:Python 函数与模块

函数是把重复的活收进一个名字,模块是把定义装进文件、用 import 拿出来。本文按 Python 官方教程第 4 章 4.8–4.9 节与第 6 章讲清楚:def 与 return、局部与全局、默认参数只算一次、关键字参数、*args 与 **kwargs、/ 与 *、lambda、文档字符串与注解、模块的几种引用、__main__ 守卫、包与搜索路径,另附虚构晨光书店记账脚本第二个月 100 次翻车的分布。

项目创作Python学习与成长
真实照片:一家独立书店的室内,木质书架摆满了书,皮扶手椅旁边的桌上堆着书,暖色吊灯
指南
先把东西放进盒子,再让程序做决定:Python 变量、数据类型与流程控制

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

项目创作Python学习与成长