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

先把这篇的边界说清楚。这是「Python 基础」系列第二篇,接着第一篇往下走:第一篇讲的是把数、字、清单存起来,再用 if、for、while 让程序自己做决定、自己重复干活。这篇讲的是怎么把重复的活收起来、怎么把文件拆开。分工是这样的:第一篇只讲「写一段能跑的代码」,这篇讲「把代码收进函数、把函数分进模块」;函数怎么写、参数怎么传、名字怎么找、文件怎么拆,都是这篇的。类(class)不在这篇里,那是下一系列的起点。示例还是那个虚构的「晨光书店」:一家街边小书店的记账脚本,第一篇里它已经能算库存总值、能给满 50 元的书打九折,这篇把它拆成能反复用的函数和能互相引用的模块。本文所有以它为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。所有关于函数的语法与行为,都来自 Python 官方教程的两篇文档:《More Control Flow Tools》(第 4 章 4.8–4.9 节)与《Modules》(第 6 章),来源见每篇的 meta 信息与 evidence 记录。读完这篇,你应该能做到四件事:会写带参数、带返回值的函数;知道默认参数、关键字参数、*args 与 **kwargs 各自的规矩;知道函数里名字是怎么找的;会把代码拆成模块、会用 __main__ 守卫让一个文件既能被引用、又能当脚本跑。
第一步:def 与 return,把重复的活收进一个名字
第一篇结尾,书店的打折规矩是写在循环里的:价格满 50 就乘 0.9。结账的地方也要打折,进货的地方也要打折,同一段代码抄三遍,改规矩的时候就得改三处。函数就是把这段代码收进一个名字里:以后想打折,就叫这个名字、把价格递进去。写法是 def 加函数名、加括号里的参数、加冒号,下一行缩进四格写函数体。官方文档的例子是把斐波那契数列收进函数:
>>> def fib(n): # 写出小于 n 的斐波那契数列
... """Print a Fibonacci series less than n."""
... a, b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
>>> fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
函数体第一行那个字符串叫「文档字符串」,是写给人看的说明:这个函数是干什么的。官方文档建议养成写它的习惯,因为有工具能直接拿它生成文档。调用的时候写函数名加括号,括号里是「实参」,也就是真正递进去的值;定义时的括号里是「形参」,也就是接值的名字。函数名本身也是一个名字,可以交给另一个变量:f = fib 之后,f(100) 和 fib(100) 是一回事。
fib 只管打印,不管还东西回来。想让函数把算好的结果交回来,用 return:
>>> def fib2(n): # 返回小于 n 的斐波那契数列
... """Return a list containing the Fibonacci series up to n."""
... result = []
... a, b = 0, 1
... while a < n:
... result.append(a)
... a, b = b, a+b
... return result
...
>>> f100 = fib2(100)
>>> f100
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
这里有个新手常懵的点:没有 return 的函数,也会返回一个值,只是那个值叫 None,意思是「什么也没有」。解释器平时不把 None 打印出来,但你硬要看就能看到:
>>> fib(0)
>>> print(fib(0))
None
fib(0) 先打了一个空行(函数体最后那个 print()),然后 print(fib(0)) 打出 None。所以「函数没返回值」这个说法不准确,准确的说法是「函数返回了 None」。书店的打折函数就该用 return 把打完折的价格交回来,而不是只打印:
>>> def price_after_discount(price, rate=0.9):
... """满 50 元打九折,否则原价。"""
... if price >= 50:
... return round(price * rate, 2)
... return price
...
>>> price_after_discount(59.0)
53.1
>>> price_after_discount(39.5)
39.5
59.0 元满了 50,打九折是 53.1;39.5 元不够 50,原价拿回来。注意函数里可以写两个 return:第一个条件成立就从那里返回,后面的不跑了。我的判断是:写函数先想清楚两件事——它要接什么、它要交回什么。接的东西写进括号,交回的东西写进 return。只打印不交回的函数,别人没法接着用它的结果,迟早要重写。
第二步:局部与全局,函数里名字是怎么找的
函数一跑起来,就会新开一张「局部符号表」,专门放这个函数自己的变量。找一个名字的时候,Python 按固定顺序找:先找本函数的局部,再找包着它的外层函数,再找全局,最后找自带的名字。官方文档的原话是:函数里给变量赋值,值存在局部符号表里;读全局变量可以直接读,但想在函数里改全局变量,得先声明。
先看读:函数外面定义的名字,函数里面可以直接读到:
>>> STORE_NAME = '晨光书店'
>>> def read_store():
... return STORE_NAME
...
>>> read_store()
'晨光书店'
再看改:函数里写 GLOBAL_COUNTER = 1,改的不是外面的那个,而是函数自己新开的局部变量,外面的纹丝不动:
>>> GLOBAL_COUNTER = 0
>>> def bump_wrong():
... GLOBAL_COUNTER = 1 # 这是局部的,外面看不见
... return GLOBAL_COUNTER
...
>>> bump_wrong()
1
>>> GLOBAL_COUNTER
0
真想改外面的,得在函数里先写一句 global 声明:
>>> GLOBAL_COUNTER2 = 0
>>> def bump_right():
... global GLOBAL_COUNTER2
... GLOBAL_COUNTER2 += 1
... return GLOBAL_COUNTER2
...
>>> bump_right()
1
>>> GLOBAL_COUNTER2
1
还有一种更隐蔽的错:函数里先读一个名字、后给它赋值,Python 会认为这个名字从头到尾都是局部的,读的那一下就报 UnboundLocalError——局部变量在赋值前被引用了。嵌套函数里想改外层函数的变量,用 nonlocal 声明:
>>> def make_counter():
... n = 0
... def inc():
... nonlocal n
... n += 1
... return n
... return inc
...
>>> c = make_counter()
>>> c()
1
>>> c()
2
每次调函数,哪怕调的是自己,都会新开一张局部符号表,所以递归也不会把各层的变量搅在一起。调用的时候传进去的实参,也是按「传值」理解的:传的永远是对象的引用,不是对象本身的一份拷贝——列表传进函数里改了,外面的列表也会变,这和第一篇里「赋值不复制」是同一个规矩。我的判断是:能不改全局变量就别改。函数要的东西从参数里拿,算好的东西用 return 交回来,这样的函数拿到哪都能跑;一上来就读写全局变量的函数,搬一次家就得改一次。
第三步:默认参数,少传也能跑,但默认值只算一次
有些参数大多数时候都是同一个值,每次都传一遍很烦。可以给它一个默认值:调用的时候不传,就用默认值;传了,就用传进来的。官方文档的例子是个问「行不行」的函数:
>>> def ask_ok(prompt, retries=4, reminder='Please try again!'):
... while True:
... reply = input(prompt)
... if reply in {'y', 'ye', 'yes'}:
... return True
... if reply in {'n', 'no', 'nop', 'nope'}:
... return False
... retries = retries - 1
... if retries < 0:
... raise ValueError('invalid user response')
... print(reminder)
...
>>> ask_ok('Do you really want to quit?') # 只传必填的
>>> ask_ok('OK to overwrite the file?', 2) # 改一个可选的
>>> ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!') # 全传
这个例子还顺带介绍了 in:reply in {'y', 'ye', 'yes'} 是在问,用户的回答是不是这三个之一。三种调用都合法:只传必填的、改一个可选的、全部都传。
默认值有个关键规矩:它是在 def 那一行执行的时候就算好的,不是每次调用才算。官方文档的例子:
>>> i = 5
>>> def f(arg=i):
... print(arg)
...
>>> i = 6
>>> f()
5
i 后来改成了 6,但函数照样打出 5,因为默认值在定义的时候就定格了。这个规矩平时没感觉,一旦默认值是个能改的东西——比如列表、字典——就会出大事。官方文档专门给了个警告:
>>> def f(a, L=[]):
... L.append(a)
... return L
...
>>> print(f(1))
[1]
>>> print(f(2))
[1, 2]
>>> print(f(3))
[1, 2, 3]
三次调用,列表越长越长:因为默认值 [] 只在定义时算了一次,三次调用共用同一只列表。想要每次都是一只新列表,标准写法是默认值写 None,进函数第一件事就是判断:
>>> def f(a, L=None):
... if L is None:
... L = []
... L.append(a)
... return L
...
>>> f(1)
[1]
>>> f(2)
[2]
书店的打折函数 price_after_discount(price, rate=0.9) 就没这个问题:0.9 是个数字,改不了,定义时算一次和每次都算,结果一样。我的判断是:默认值只写「改不了的东西」——数字、字符串、None;凡是列表、字典这种能改的,一律写 None 再在函数里现造。这是 Python 里最出名的坑之一,图里第二类翻车就是它。
第四步:关键字参数,点名道姓地传
位置参数是按顺序对号入座的:第一个实参给第一个形参,第二个给第二个。参数一多,顺序就容易记混。关键字参数是「点名道姓」地传:写上形参的名字、等号、值,顺序就不重要了。官方文档的例子是一只鹦鹉:
>>> def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
... print("-- This parrot wouldn't", action, end=' ')
... print("if you put", voltage, "volts through it.")
... print("-- Lovely plumage, the", type)
... print("-- It's", state, "!")
...
>>> parrot(1000) # 1 个位置参数
>>> parrot(voltage=1000) # 1 个关键字参数
>>> parrot(voltage=1000000, action='VOOOOOM') # 2 个关键字参数
>>> parrot(action='VOOOOOM', voltage=1000000) # 2 个关键字参数,顺序反了也行
>>> parrot('a million', 'bereft of life', 'jump') # 3 个位置参数
>>> parrot('a thousand', state='pushing up the daisies') # 1 个位置,1 个关键字
六种调用都合法。但下面四种不行,官方文档一条一条列出来了:
>>> parrot() # 必填参数没给
>>> parrot(voltage=5.0, 'dead') # 关键字后面又跟了位置参数
>>> parrot(110, voltage=220) # 同一个参数给了两次值
>>> parrot(actor='John Cleese') # 没有这个名字的参数
规矩就三条:关键字参数必须跟在位置参数后面;每个参数只能拿到一个值;传的名字必须在定义里找得到。第二条有个容易踩的变体:
>>> def function(a):
... pass
...
>>> function(0, a=0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: function() got multiple values for argument 'a'
function(0, a=0) 里,a 先按位置拿到了 0,又按关键字拿到了 0,一个参数给了两次,报 TypeError。第二种非法调用还有个细节:parrot(voltage=5.0, 'dead') 在语法那一关就过不去,报的是 SyntaxError 而不是 TypeError——位置参数跟在关键字参数后面,解释器读到就直接拒了,连跑都不跑。
书店的例子:结账的时候,会员价和普通价就靠关键字分清楚:
>>> def checkout(*prices, member=False):
... total = sum(prices)
... if member:
... total = round(total * 0.95, 2)
... return total
...
>>> checkout(39.5, 59.0)
98.5
>>> checkout(40.0, 60.0, member=True)
95.0
member=True 写在最后,一眼就能看出来这次是会员结账。顺便提一句:checkout(39.5, 59.0, member=True) 如果按字面算,98.5 乘 0.95 是 93.575,但浮点数里 39.5 加 59.0 再乘 0.95,实际存的是 93.57499999999999,四舍五入到两位是 93.57,而不是 93.58——同一个数字、不同算出来的路径,结果能差一分钱。算钱的时候记住这个,关键数字用整数「分」算,或者用 decimal 模块,别指望浮点数的尾巴。
第五步:*args 与 **kwargs,多少参数都能接
有时候一个函数要接多少个参数,写代码的时候还不知道:结账可能是一本书,也可能是十本书。星号参数就是干这个的:一个星号 *args 把多出来的位置参数收进一个元组,两个星号 **kwargs 把多出来的关键字参数收进一个字典。官方文档的奶酪店例子:
>>> def cheeseshop(kind, *arguments, **keywords):
... print("-- Do you have any", kind, "?")
... print("-- I'm sorry, we're all out of", kind)
... for arg in arguments:
... print(arg)
... print("-" * 40)
... for kw in keywords:
... print(kw, ":", keywords[kw])
...
>>> cheeseshop("Limburger", "It's very runny, sir.",
... "It's really very, VERY runny, sir.",
... shopkeeper="Michael Palin",
... client="John Cleese",
... sketch="Cheese Shop Sketch")
-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
shopkeeper : Michael Palin
client : John Cleese
sketch : Cheese Shop Sketch
注意第一行打出的是 Limburger ?,问号前面有个空格:因为 print() 会在每个参数之间自动空一格。关键字参数打出来的顺序,和调用时写的顺序是一样的,这一点官方文档写明了是有保证的。
*args 最常见的搭档是 sep 这种「只能用关键字传」的参数:它写在 *args 后面,位置传不进去,只能点名传:
>>> def concat(*args, sep="/"):
... return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'
星号还能反过来用:调用的时候,把一个列表拆开当位置参数传、把一个字典拆开当关键字参数传。这叫「解包」:
>>> list(range(3, 6)) # 正常调用,参数分开写
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args)) # 从列表里解包出来再传
[3, 4, 5]
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !
书店的 checkout(*prices, member=False) 就是这个路数:*prices 收下不管几本书的价格,member 只能用关键字传,checkout(39.5, 59.0, member=True) 不会有人把 True 错当成第三本书的价格。我的判断是:参数超过三个、或者其中有「开关」性质的,就把开关写成关键字参数;数量不定的,就用 *args。这样调用的人不用数位置,读代码的人一眼看懂。
第六步:/ 与 *,把参数的传法也定下来
默认情况下,参数既能按位置传、也能按关键字传。但有些函数想把传法也定下来:有的参数只准按位置传,有的只准按关键字传。管这个的是两个符号:/ 和 *。写在 / 前面的参数只能按位置传,写在 * 后面的参数只能按关键字传,夹在中间的两种都行:
def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
----------- ---------- ----------
| | |
| Positional or keyword |
| - Keyword only
-- Positional only
上面这段是官方文档画的示意图,不是能直接跑的代码:/ 左边是只按位置传,* 右边是只按关键字传,夹在中间的两种都行。下面四个函数才是能跑的例子:
>>> def standard_arg(arg):
... print(arg)
...
>>> def pos_only_arg(arg, /):
... print(arg)
...
>>> def kwd_only_arg(*, arg):
... print(arg)
...
>>> def combined_example(pos_only, /, standard, *, kwd_only):
... print(pos_only, standard, kwd_only)
...
>>> standard_arg(2)
2
>>> standard_arg(arg=2)
2
>>> pos_only_arg(1)
1
>>> pos_only_arg(arg=1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: pos_only_arg() got some positional-only arguments passed as keyword arguments: 'arg'
>>> kwd_only_arg(3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: kwd_only_arg() takes 0 positional arguments but 1 was given
>>> kwd_only_arg(arg=3)
3
>>> combined_example(1, 2, 3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: combined_example() takes 2 positional arguments but 3 were given
>>> combined_example(1, 2, kwd_only=3)
1 2 3
>>> combined_example(1, standard=2, kwd_only=3)
1 2 3
官方文档给的使用建议是:参数名没什么意义、只想强制按顺序传的时候,用只按位置传;参数名本身就是意思、想让人写清楚的时候,用只按关键字传;写给别人用的接口,把参数名锁成只按位置传,以后改参数名也不会把别人的调用弄坏。
只按位置传还有个妙用,能解开一个 **kwargs 的死结。看这个函数:
>>> def foo(name, **kwds):
... return 'name' in kwds
...
>>> foo(1, **{'name': 2})
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foo() got multiple values for argument 'name'
'name' 这个键永远进不了 kwds,因为它先被 name 这个形参抢走了。但只要在 name 后面加个 /,让它只能按位置传,关键字里的 'name' 就能顺利进 kwds 了:
>>> def foo(name, /, **kwds):
... return 'name' in kwds
...
>>> foo(1, **{'name': 2})
True
这一步偏进阶,刚学的时候不用天天用,知道有这么两个符号、读别人代码时认得出来就够了。我的判断是:自己写的小脚本,普通参数就够了;写给别人用的工具函数,再考虑用 / 和 * 把传法锁死。
第七步:lambda,一句话写完的小函数
有时候要的函数特别小,小到只有一句话:比如「按书名的第二个字排序」「把价格加 10」。为这种小事专门写个 def,显得啰嗦。lambda 就是写这种小函数的简写:lambda 参数: 表达式,冒号后面只能写一个表达式,算出来的值就是返回值。官方文档的例子:
>>> def make_incrementor(n):
... return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43
make_incrementor(42) 交回来一个小函数,这个小函数还记得外面的 n 是 42,所以 f(0) 是 42,f(1) 是 43。另一个常见用法是给排序当「钥匙」:
>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]
key=lambda pair: pair[1] 的意思是:排序的时候,别按第一个元素比,按每个元组的第二个元素比。lambda 在语义上就是普通函数的简写,只是只能写一个表达式。我的判断是:lambda 只用在「一眼能看完」的地方,比如排序的 key、临时的小换算;超过一行的逻辑,老老实实写 def,还能顺手写个文档字符串。
第八步:文档字符串与注解,给函数留张名片
第一步讲过,函数体第一行的字符串是文档字符串。官方文档对它的写法有几条约定:第一行永远是简短的一句话总结,说清这个东西是干什么的,首字母大写、句号结尾;如果还有更多说明,第二行空着,从第三行起再写几段,讲调用方法、副作用这些。工具能拿文档字符串自动生成文档,所以写代码的人养成写它的习惯,等于顺手把说明书也写了:
>>> def my_function():
... """Do nothing, but document it.
...
... No, really, it doesn't do anything:
...
... >>> my_function()
... >>>
... """
... pass
...
>>> print(my_function.__doc__)
Do nothing, but document it.
No, really, it doesn't do anything:
>>> my_function()
>>>
文档字符串存在函数的 __doc__ 属性里,随时能取出来看。另一张「名片」是注解:写在参数名后面的冒号、写在括号和冒号之间的 ->,是给人看的类型说明,存在 __annotations__ 这个字典里。关键点是:注解完全是可选的元数据,对函数的运行没有任何影响:
>>> def f(ham: str, eggs: str = 'eggs') -> str:
... print("Annotations:", f.__annotations__)
... print("Arguments:", ham, eggs)
... return ham + ' and ' + eggs
...
>>> f('spam')
Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Arguments: spam eggs
'spam and eggs'
注解说 ham 应该是 str,但你真传个整数进去,Python 不会拦你——f(123) 会在 ham + ' and ' + eggs 这一步报 TypeError,因为整数和字符串不能相加,而不是因为注解不合。想靠注解拦住错类型,得另外用类型检查工具。我的判断是:注解写给读代码的人看,不是写给解释器看的;别指望它帮你拦错,也别因为写了注解就忘了测。
第九步:模块,把定义装进文件,用 import 拿出来
写到这里,书店的函数已经有好几个了:打折、结账、算库存。都挤在一个文件里还行,再长下去就得拆。模块就是「装着 Python 定义和语句的文件」:文件名去掉 .py 就是模块名。官方文档的例子是把斐波那契函数装进 fibo.py:
# Fibonacci numbers module
def fib(n):
"""Write Fibonacci series up to n."""
a, b = 0, 1
while a < n:
print(a, end=' ')
a, b = b, a+b
print()
def fib2(n):
"""Return Fibonacci series up to n."""
result = []
a, b = 0, 1
while a < n:
result.append(a)
a, b = b, a+b
return result
然后在解释器里引用它:
>>> import fibo
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
import fibo 不会把 fib 和 fib2 直接放进当前的名字空间,它只放进一个名字 fibo,再用 fibo.fib 这种「模块名.名字」去取。模块里自己的名字,存在它自己的名字空间里,所以模块作者用全局变量也不用怕和你的撞上。想少打几个字,可以把函数交给一个本地名字:fib = fibo.fib,之后 fib(500) 就行。
引用还有几种写法,各有分工:
>>> from fibo import fib, fib2 # 直接把名字拿进来,不用写模块名
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
>>> import fibo as fib # 换个名字引用
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
>>> from fibo import fib as fibonacci # 拿进来顺便改名
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
还有一种 from fibo import *,会把模块里定义的名字(以下划线开头的除外)一把全拿进来。官方文档的态度很明确:平时别这么干,因为你不知道到底拿进来哪些名字,可能会悄悄盖掉你已经定义好的东西;交互式试代码的时候图省事用用可以。每个模块在一个解释器会话里只会被真正执行一次:第二次 import 同一个模块,拿的是第一次的结果。改了模块想重新测,得重启解释器,或者用 importlib.reload()。
模块第一次被引用的时候,Python 会把编译好的版本存在 __pycache__ 目录里,下次加载能快一点。名字空间里到底有什么,用 dir() 看:
>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
这里要老实交代一个出入:上面这行是官方文档页上印的结果,但本地 Python 3.12.3 实测,dir(fibo) 里的名字比这多得多,还包括 __doc__、__package__、__loader__、__spec__、__file__、__cached__、__builtins__ 这些。文档页是按 Python 3.15.2 写的,列表里的三个名字在两个版本里都有,多的那些是解释器自己加的,不影响 fib 和 fib2 的用法。证据里记下了这条分歧。
第十步:__main__ 守卫、包与搜索路径,让文件既能被引用、又能当脚本跑
模块有个两难:写好的 fibo.py,既想让别人 import 了用,又想自己直接跑一跑看对不对。直接跑的时候,模块里的代码会从头执行一遍;被 import 的时候,你又不希望那些测试代码也跟着跑一遍。解法是 __name__ 这个全局变量:文件被当成脚本直接跑,__name__ 是 "__main__";被别人 import,__name__ 是模块自己的名字。在文件末尾加个守卫:
if __name__ == "__main__":
import sys
fib(int(sys.argv[1]))
这样直接跑就出结果,被引用就不出声:
$ python fibo.py 50
0 1 1 2 3 5 8 13 21 34
>>> import fibo
>>> # 什么都没打印,守卫拦住了测试代码
sys.argv[1] 是命令行里跟在文件名后面的第一个参数,这里是 50,int() 把它转成整数再传给 fib。
解释器找模块的时候,按 sys.path 这个列表里的目录顺序找:先找内建模块,再找脚本所在的目录(没指定文件的时候就是当前目录),再找 PYTHONPATH 环境变量里的目录,最后找安装时定好的默认目录(一般包括 site-packages)。有个坑要记住:脚本所在的目录排在标准库前面,所以你在自己目录里放一个和标准库同名的文件,比如 random.py,你的文件会把标准库的 random 遮住——除非你就是故意的,否则别这么起名。
文件再多,就得分「包」:包就是用带点的文件夹名组织起来的模块。官方文档的例子是个处理声音文件的包:
sound/ Top-level package
__init__.py Initialize the sound package
formats/ Subpackage for file format conversions
__init__.py
wavread.py
wavwrite.py
effects/ Subpackage for sound effects
__init__.py
echo.py
surround.py
reverse.py
filters/ Subpackage for filters
__init__.py
equalizer.py
vocoder.py
karaoke.py
__init__.py 是让 Python 把这个目录当成包的标记,最简单的情况可以是个空文件,也可以放包的初始化代码、或者定义一个 __all__ 列表,告诉别人 from sound.effects import * 的时候该拿哪几个子模块。引用包里的模块有三种写法,意思一样、省字程度不同:
>>> import sound.effects.echo
>>> sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
>>> from sound.effects import echo
>>> echo.echofilter(input, output, delay=0.7, atten=4)
>>> from sound.effects.echo import echofilter
>>> echofilter(input, output, delay=0.7, atten=4)
包里面互相引用的时候,可以用相对引用:from . import echo 是当前包里的 echo,from .. import formats 是上一级包里的 formats。但注意:想当主模块跑的文件必须用绝对引用,因为主模块没有包名,相对引用找不到北。
下面这张图,是虚构的晨光书店记账脚本在学 Python 第二个月里的 100 次函数与模块翻车,按原因分的布。数字是编的、为了讲清楚分布,但每一类都是前面十步里讲过的真坑:
排第一的还是那个老问题:函数只管算、不管交代,return 忘写了,调用的人拿到 None,再往下算就全错了。第二类是默认参数的可变对象陷阱,第三类是在函数里改全局变量忘了声明——这两类加起来 34 次,都是「名字在哪、东西在哪」没想清楚。第四类模块同名遮住标准库,写代码的时候随手起了个 random.py、math.py,标准库就被自己人盖住了。第五类是 *args 的位置放错,后面的参数传不进去。第六类是没加 __main__ 守卫,import 一下就把整个脚本跑了一遍。第七类是 from 模块 import *,名字打架。
读到这里,晨光书店的记账脚本已经从「一段能跑的代码」变成了「几个能反复用的函数、几个能互相引用的模块」:打折的规矩在 pricing.py 里,结账在 checkout.py 里,主程序只负责把它们拼起来。第一篇里写的每一行都还在,只是住进了更整齐的房子里。下一回该讲类了:书店里的「书」不只是字典里的几对键值,还可以是一个自己会算价、自己会报库存的对象。但那是下一个系列的起点,这篇先到这里。
评论 (0)
原始来源
相关文章
推导式先说要什么,生成器一次只吐一个。本文按 Python 官方教程第 5 章与第 9 章讲清楚:列表、字典、集合推导式,双重 for 与嵌套推导式,* 解包,yield 与生成器函数,生成器表达式,以及列表和生成器怎么选,另附虚构晨光书店记账脚本第六个月 100 次翻车的分布。
账只存在内存里,程序一关就全没了。本文按 Python 官方教程第 7 章与 csv 模块文档讲清楚:f 字符串与 format、str 与 repr、open 的 r/w/a/r+ 四种模式、with、五种读法、write 与 tell/seek、JSON 整存整取、CSV 的 DictReader/DictWriter,另附虚构晨光书店记账脚本第五个月 100 次翻车的分布。
异常不是程序坏了,是 Python 在用有名字的办法告诉你哪里出了问题。本文按 Python 官方教程第 8 章讲清楚:语法错误与异常、try/except、except 按继承匹配、哪些错该接哪些不该接、raise、else、finally、with、自定义异常、异常链与 ExceptionGroup,另附虚构晨光书店记账脚本第四个月 100 次翻车的分布。