函数
函数用于封装一段可重复使用的逻辑。使用函数的目的通常有 3 个：
- 减少重复代码
- 让程序结构更清晰
- 让代码更容易测试和维护
调用函数
函数名本身其实就是指向函数对象的引用，所以完全可以把函数名赋值给另一个变量，相当于给这个函数起了一个“别名”：
a = abs
print(a(-1)) # 1
练习：请利用 Python 内置的 hex() 函数，把一个整数转换成十六进制表示的字符串。
>>> hex(255)
'0xff'
>>> hex(1000)
'0x3e8'
调用 Python 的函数时，需要根据函数定义传入正确的参数。函数调用出错时，要重点看报错信息中的：
- 错误类型
- 出错位置
- 具体提示内容
定义函数
定义函数的基本形式如下：
def 函数名(参数1, 参数2, ...):
函数体
return 返回值
如果没有 return 语句，函数执行完毕后也会返回结果，只是结果为 None。
def show():
print('hello')
result = show()
print(result) # None
return None 通常可以简写为 return，甚至直接省略 return。
空函数
如果想定义一个什么事也不做的空函数，可以用 pass 语句：
def nop():
pass
pass 也可以出现在其他语句中，用来占位：
if age >= 18:
pass
参数检查
我们自己定义的函数如果接收到不合适的参数，解释器不一定会自动给出符合业务语义的错误，这时可以主动检查并抛出异常：
def my_abs(x):
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x >= 0:
return x
return -x
上面的代码会先检查 x 是否是 int 或 float，如果不是，就主动报错。
返回多个值
函数看起来可以“返回多个值”：
import math
def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print(x, y)
151.96152422706632 70.0
但这本质上不是同时返回多个独立对象，而是返回了一个 tuple：
>>> r = move(100, 100, 60, math.pi / 6)
>>> print(r)
(151.96152422706632, 70.0)
也就是说：
return nx, ny
等价于：
return (nx, ny)
之所以默认表现为 tuple，核心原因不是“必须更安全”，而是：
- Python 会把逗号分隔的返回值自动打包为元组
tuple很适合表达“固定数量、固定位置含义”的返回结果- 后续解包也很方便，例如
x, y = move(...)
如果你确实想返回一个列表，也完全可以显式写成：
return [nx, ny]
练习
请定义一个函数 quadratic(a, b, c)，接收 3 个参数，返回一元二次方程 ax^2 + bx + c = 0 的两个解。
>>> def quadratic(a, b, c):
... return (
... (-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a),
... (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
... )
...
>>> quadratic(2, 3, 1)
(-0.5, -1.0)
>>> quadratic(1, 3, -4)
(1.0, -4.0)
说明：
- 这个写法默认判别式
b ** 2 - 4 * a * c >= 0 - 实际开发中，还应考虑
a == 0和无实数解的情况
小结
- 定义函数时，需要确定函数名和参数个数
- 如果有必要，可以先对参数类型或取值范围做检查
- 函数体内部可以用
return随时返回结果 - 函数执行完毕但没有
return语句时，会自动返回None - 函数“返回多个值”时，本质上返回的是一个
tuple
函数的参数
位置参数
例如：
def power(x, n):
return x ** n
这里的 x 和 n 就是位置参数。调用函数时，实参会按照位置顺序依次赋值给对应参数。
power(2, 3) # 8
默认参数
可以给参数提供默认值：
def power(x, n=2):
return x ** n
此时：
power(5)
等价于：
power(5, 2)
默认参数有几点需要注意：
- 必选参数在前，默认参数在后
- 有多个参数时，通常把变化大的参数放前面，变化小的参数放后面
默认参数的好处是：降低调用函数的难度。
def enroll(name, gender, age=6, city='Beijing'):
print('name:', name)
print('gender:', gender)
print('age:', age)
print('city:', city)
调用时：
enroll('Bob', 'M', 7)
enroll('Adam', 'M', city='Tianjin')
注意：当不按顺序传入部分默认参数时，需要显式写参数名。
默认参数的坑
先定义一个函数，传入一个列表，添加一个 'END' 再返回：
def add_end(L=[]):
L.append('END')
return L
当显式传入列表时，结果看起来没什么问题：
>>> add_end([1, 2, 3])
[1, 2, 3, 'END']
>>> add_end(['x', 'y', 'z'])
['x', 'y', 'z', 'END']
但当使用默认参数调用时，结果就开始出现问题：
>>> add_end()
['END']
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']
原因是：默认参数的值会在函数定义时计算一次，而不是在每次调用时重新创建。
也就是说，上面的 [] 只创建了一次。之后每次调用 add_end()，如果没有显式传入 L，用的都是同一个列表对象。
因此，更准确的说法不是“默认参数必须指向不变对象”，而是：
- 语法上，不变对象和可变对象都可以作为默认参数
- 实践上，默认参数应尽量使用不变对象，避免共享可变状态带来的逻辑错误
推荐写法如下：
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L
这里用 None 作为默认值，是因为 None 是不可变对象，而且常用来表示“没有传值”。
可变参数
在 Python 函数中，还可以定义可变参数，也就是参数个数可变：
def calc(*numbers):
total = 0
for n in numbers:
total = total + n * n
return total
调用示例：
calc(1, 2, 3) # 14
calc() # 0
这里的 numbers 接收到的是一个 tuple。
如果已经有一个 list 或 tuple，调用可变参数函数时可以用 * 展开：
>>> nums = [1, 2, 3]
>>> calc(*nums)
14
关键字参数
关键字参数允许传入 0 个或任意个带参数名的参数，这些参数在函数内部会自动组装为一个 dict：
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
调用示例：
>>> person('Michael', 30)
name: Michael age: 30 other: {}
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
关键字参数的作用是扩展函数能力。比如做用户注册时，name 和 age 是必填项，其它信息可以放进关键字参数里。
也可以先组装出一个字典，再用 ** 展开：
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
注意：**extra 表示把 extra 中的键值对作为关键字参数传入。函数内部的 kw 会得到一个新的字典对象，对 kw 的修改不会影响外部的 extra。
命名关键字参数
对于普通关键字参数 **kw，调用者可以传入任意名字的关键字参数。如果想限制关键字参数的名字，可以使用命名关键字参数。
例如，只允许传入 city 和 job：
def person(name, age, *, city, job):
print(name, age, city, job)
这里的 * 是特殊分隔符，* 后面的参数都必须用“参数名=值”的形式传入。
>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer
如果函数定义中已经有了可变参数，那么后面的命名关键字参数就不再需要额外写 *：
def person(name, age, *args, city, job):
print(name, age, args, city, job)
命名关键字参数必须传入参数名，否则会报错：
>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
...
TypeError: person() missing 2 required keyword-only arguments: 'city' and 'job'
命名关键字参数也可以有默认值：
def person(name, age, *, city='Beijing', job):
print(name, age, city, job)
此时可以省略 city：
>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer
如果没有可变参数，就必须保留这个特殊分隔符 *：
def person(name, age, city, job):
# 这里没有 *，city 和 job 是位置参数，不是命名关键字参数
pass
参数组合
Python 中常见的 5 类参数分别是：
- 必选参数
- 默认参数
- 可变参数
- 命名关键字参数
- 关键字参数
它们组合使用时，参数定义顺序通常应为：
必选参数 -> 默认参数 -> 可变参数 -> 命名关键字参数 -> 关键字参数
例如：
def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
调用示例：
>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}
也可以通过一个 tuple 和一个 dict 来调用：
>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}
所以，对于任意函数，只要参数匹配，都可以通过 func(*args, **kw) 的形式调用。
练习
以下函数允许计算两个数的乘积，请稍加改造，变成可接收一个或多个数并计算乘积：
def mul(x, y):
return x * y
# 测试
print('mul(5) =', mul(5))
print('mul(5, 6) =', mul(5, 6))
print('mul(5, 6, 7) =', mul(5, 6, 7))
print('mul(5, 6, 7, 9) =', mul(5, 6, 7, 9))
if mul(5) != 5:
print('mul(5)测试失败!')
elif mul(5, 6) != 30:
print('mul(5, 6)测试失败!')
elif mul(5, 6, 7) != 210:
print('mul(5, 6, 7)测试失败!')
elif mul(5, 6, 7, 9) != 1890:
print('mul(5, 6, 7, 9)测试失败!')
else:
try:
mul()
print('mul()测试失败!')
except TypeError:
print('测试成功!')
参考解答：
def mul(x, *numbers):
product = x
for n in numbers:
product = product * n
return product
说明：这里故意把第一个参数写成必选参数 x，这样 mul() 不传任何参数时就会触发 TypeError，与题目测试保持一致。
小结
- Python 的函数参数形式非常灵活
- 默认参数建议使用不可变对象，或者用
None作为占位默认值 *args接收的是一个tuple**kw接收的是一个dict- 调用函数时，可以用
*展开序列，用**展开字典 - 命名关键字参数用于限制允许传入的关键字名称
递归函数
在函数内部，可以调用其他函数。如果一个函数在内部调用自身，这个函数就是递归函数。
举个例子，我们来计算阶乘 n! = 1 x 2 x 3 x ... x n，用函数 fact(n) 表示：
fact(n) = n! = 1 × 2 × 3 × ... × (n - 1) × n = fact(n - 1) × n
因此，fact(n) 可以表示为 n * fact(n - 1)，只有 n == 1 时需要特殊处理。
def fact(n):
if n == 1:
return 1
return n * fact(n - 1)
>>> fact(1)
1
>>> fact(5)
120
计算 fact(5) 的过程如下：
fact(5)
= 5 * fact(4)
= 5 * (4 * fact(3))
= 5 * (4 * (3 * fact(2)))
= 5 * (4 * (3 * (2 * fact(1))))
= 5 * (4 * (3 * (2 * 1)))
= 120
递归函数的优点是定义简单、逻辑清晰。理论上，大多数递归都能改写成循环。
递归的风险：栈溢出
函数调用是通过栈（stack）实现的。每进入一层函数调用，就会新增一层栈帧；每返回一次，就会减少一层栈帧。栈空间不是无限的，所以递归层数过深时，会导致栈溢出。
>>> fact(1000)
Traceback (most recent call last):
...
RecursionError: maximum recursion depth exceeded
尾递归
尾递归是指：函数返回时，直接返回递归调用本身，并且 return 语句外层不再包含额外表达式。
上面的 fact(n)：
return n * fact(n - 1)
不是尾递归，因为返回前还要做乘法。
可以改写为：
def fact(n):
return fact_iter(n, 1)
def fact_iter(num, product):
if num == 1:
return product
return fact_iter(num - 1, num * product)
调用过程如下：
fact_iter(5, 1)
= fact_iter(4, 5)
= fact_iter(3, 20)
= fact_iter(2, 60)
= fact_iter(1, 120)
= 120
理论上，如果语言或解释器支持尾递归优化，那么尾递归不会随着调用次数增加而不断增长栈空间。
但要注意：Python 标准解释器并不会做尾递归优化。所以即使写成尾递归，递归层数过深时仍然会栈溢出。
练习
汉诺塔可以用递归函数非常简洁地实现。
请编写 move(n, a, b, c) 函数，它接收参数 n，表示第一个柱子 a 上有 n 个盘子，目标是借助柱子 b 把所有盘子移动到柱子 c。
示例调用：
move(3, 'A', 'B', 'C')
期待输出：
A --> C
A --> B
C --> B
A --> C
B --> A
B --> C
A --> C
参考解答：
def move(n, a, b, c):
if n == 1:
print(a, '-->', c)
else:
move(n - 1, a, c, b) # 先把 n-1 个盘子从 a 借助 c 移到 b
print(a, '-->', c) # 再把底部盘子从 a 移到 c
move(n - 1, b, a, c) # 最后把 n-1 个盘子从 b 借助 a 移到 c
小结
- 递归适合描述“问题可以拆成更小的同类问题”的场景
- 写递归时必须明确终止条件
- Python 不做尾递归优化，递归层数过深时会触发
RecursionError - 能用循环清楚表达时，循环通常更直接
补充：文档字符串与类型标注
前面的内容足够入门函数的定义与调用。如果希望函数更容易被别人理解，还可以补充以下两点。
文档字符串
文档字符串用于说明函数的用途、参数和返回值：
def add(x, y):
"""返回两个数的和。"""
return x + y
查看方式：
print(add.__doc__)
类型标注
类型标注不会强制 Python 运行时做类型检查，但能提升可读性，并帮助编辑器提示：
def add(x: int, y: int) -> int:
return x + y
对于初学阶段，不要求到处都写，但建议开始认识这种写法。
常见误区
- “函数返回多个值”并不是真的返回多个对象，本质上通常是返回一个
tuple - 默认参数不是语法上必须用不可变对象，而是为了避免共享可变状态，实践上应尽量这样做
*args是把多余的位置参数收集为元组，**kw是把多余的关键字参数收集为字典- 递归不一定比循环高级；只是某些问题用递归表达更自然
练习题
下面这组练习按难度从低到高排列，建议独立完成。
基础题
- 编写函数
temperature_convert(celsius)，把摄氏度转换成华氏度并返回结果。 - 编写函数
is_even(n)，判断一个整数是否为偶数，返回True或False。 - 编写函数
max_of_three(a, b, c)，返回 3 个数中的最大值。 - 编写函数
triangle_area(base, height)，返回三角形面积。 - 编写函数
login(username, password='123456')，体验默认参数的作用。
参数练习
- 编写函数
average(*numbers)，接收任意个数字并返回平均值；如果没有传入数字，返回0。 - 编写函数
student_info(name, age, **extra)，打印学生基本信息和扩展信息。 - 编写函数
book_info(title, *, author, price)，要求author和price必须按关键字形式传入。 - 编写函数
append_item(item, target=None)，把item追加到列表中，并正确处理默认参数。 - 编写函数
calc_stats(*numbers)，返回最小值、最大值和平均值。
综合题
- 编写函数
quadratic(a, b, c)，要求额外处理：a == 0时给出合理提示- 判别式小于 0 时给出合理提示
- 编写函数
register(name, age, gender='未填写', **extra)，模拟一个用户注册函数。 - 编写函数
factorial(n)，分别用循环和递归实现，并比较两种写法。 - 编写函数
fib(n)，返回斐波那契数列第n项。 - 编写函数
move_count(n)，不打印汉诺塔过程，只返回移动总步数。
小项目练手
项目：个人记账小助手
目标：用函数把一个命令行小程序拆分清楚，练习“参数设计、返回值设计、数据校验和功能拆分”。
建议功能：
- 显示菜单
- 添加一条收入记录
- 添加一条支出记录
- 查看所有记录
- 按类型统计总金额
- 统计总收入、总支出、当前结余
- 按关键词查询记录
- 删除指定记录
建议拆分的函数：
def show_menu():
pass
def add_record(records, kind, amount, note):
pass
def show_records(records):
pass
def delete_record(records, index):
pass
def search_records(records, keyword):
pass
def calc_summary(records):
pass
def calc_by_kind(records, kind):
pass
def is_valid_amount(amount):
pass
def main():
pass
可以约定每条记录都长这样：
{'kind': '支出', 'amount': 35.5, 'note': '午饭'}
建议要求：
- 金额必须大于
0 - 收支类型只能是“收入”或“支出”
- 删除记录时要检查下标是否合法
- 所有菜单操作尽量通过函数完成，不要把逻辑全堆在
main()中
进阶版本
如果基础版完成了，可以继续扩展：
- 支持按日期查看记录
- 支持将记录保存到文件、从文件读取
- 支持按“餐饮、交通、学习、娱乐”等分类统计
- 支持设置每月预算，并提示是否超支
项目收获
做完这个项目后，你应该重点回顾这些问题：
- 我是否把重复逻辑提取成了函数？
- 每个函数职责是否单一？
- 哪些参数应该用位置参数，哪些适合默认参数？
- 有没有错误地把可变对象写成默认参数？
- 返回值设计是否清晰，调用方是否容易使用？
浙公网安备 33010602011771号