一、函数定义与返回值

函数是「组织好的、可复用的、实现特定功能的代码片段」。Python 用 def 定义:

1
2
3
4
5
6
7
8
9
10
def circle_area(r):
"""
计算圆的面积
:param r: 半径
:return: 圆面积
"""
import math
return math.pi * r ** 2

print(circle_area(5)) # 78.539...

要点:

  • 函数必须先定义再调用(解释型语言,顺序执行)。
  • 三引号写在函数体第一行是 docstring(文档字符串),可用 help(函数名) 查看。
  • 没有 return 或 return 后无值时,函数返回 None。

1.1 多返回值(本质是元组)

Python 函数可以「返回多个值」,本质是返回一个元组(自动组包):

1
2
3
4
5
6
7
8
9
10
11
12
def circle_area_len(r):
import math
area = math.pi * r ** 2
length = 2 * math.pi * r
return area, length # 组包成元组返回

res = circle_area_len(5)
print(type(res)) # <class 'tuple'>
print(res) # (78.539..., 31.415...)

# 解包接收
area, length = circle_area_len(5)

多返回值 + 解包是 Python 很常用的组合,例如 max_score, min_score, avg = calc(scores)。


二、函数参数(Python 特有重点)

Python 的参数体系是所有语言里最灵活的之一,也是重点难点。

2.1 位置参数与关键字参数

1
2
3
4
5
6
7
8
9
10
11
def reg_stu(name, age, gender, city):
print(f"{name} {age} {gender} {city}")

# 位置参数:按顺序一一对应
reg_stu("张三", 18, "男", "北京")

# 关键字参数:按名字指定,顺序可乱
reg_stu(age=20, gender="女", city="北京", name="李慕婉")

# 混合:位置参数必须在前,关键字参数在后
reg_stu("李慕婉", 20, gender="女", city="北京")

2.2 默认参数

1
2
3
4
5
6
def reg_stu(name, age, gender="男", city="北京"):
print(f"{name} {age} {gender} {city}")

reg_stu("王林", 20) # 用默认性别、城市
reg_stu("李慕婉", 18, "女") # 覆盖性别
reg_stu("韩立", 22, city="上海") # 只覆盖城市

可变默认参数陷阱(高频面试题):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 反例:默认参数是可变对象,会被所有调用共享!
def add_item(item, lst=[]):
lst.append(item)
return lst

print(add_item(1)) # [1]
print(add_item(2)) # [1, 2] ← 上一次的结果还在!

# 正例:默认值用 None,函数内部再创建
def add_item(item, lst=None):
if lst is None:
lst = []
lst.append(item)
return lst

print(add_item(1)) # [1]
print(add_item(2)) # [2] ← 正常

原因:默认参数在函数定义时只求值一次,可变对象会被多次调用共享。默认值请用不可变对象或 None。

2.3 可变位置参数 *args

用 *参数名 接收任意数量的位置参数,打包成元组:

1
2
3
4
5
def calc(*args):
print(type(args)) # <class 'tuple'>
return min(args), max(args), sum(args) / len(args)

print(calc(2, 7, 9, 10, 45)) # (2, 45, 14.6)

2.4 可变关键字参数 **kwargs

用 **参数名 接收任意数量的关键字参数,打包成字典:

1
2
3
4
5
6
7
8
9
def calc(*args, **kwargs):
avg = sum(args) / len(args)
if kwargs.get("round") is not None:
avg = round(avg, kwargs["round"])
if kwargs.get("print"):
print(f"avg = {avg}")
return avg

print(calc(2, 7, 9, round=3, print=True)) # avg = 6.0

*args 和 **kwargs 同时存在时,*args 必须在前。命名约定上 args/kwargs 只是惯例,也可用其他名字,但全行业通用这两个名字。

2.5 keyword-only 参数(仅关键字参数)

* 之后的参数只能用关键字传入,不能按位置传:

1
2
3
4
5
def f(name, *, age, city):
print(name, age, city)

f("张三", age=18, city="北京") # 正确
# f("张三", 18, "北京") # TypeError,age/city 不能用位置传

用途:强制调用者写清楚参数含义,提高可读性,尤其参数较多时。

2.6 仅位置参数 /(3.8+)

/ 之前的参数只能用位置传入,不能用关键字:

1
2
3
4
5
def f(a, b, /, c):
print(a, b, c)

f(1, 2, c=3) # 正确
# f(a=1, b=2, c=3) # TypeError,a/b 不能用关键字传

这在标准库(如 range、str.split)里常见。日常自己写代码用得不多。

2.7 完整参数顺序

把所有参数形式合起来的顺序是:

1
位置参数, 仅位置标记 /, 默认位置参数, *args, keyword-only参数, **kwargs
1
2
def f(a, b=2, *args, c, d=4, **kwargs):
pass

2.8 调用时解包参数

调用时用 * / ** 把容器拆开传参(与接收端 *args/**kwargs 正好对称):

1
2
3
4
5
6
7
8
def f(x, y, z):
print(x, y, z)

args = [1, 2, 3]
f(*args) # 等价 f(1, 2, 3)

kwargs = {"x": 1, "y": 2, "z": 3}
f(**kwargs) # 等价 f(x=1, y=2, z=3)

三、作用域与变量查找

3.1 LEGB 规则

Python 查找变量名时按 LEGB 顺序(由内向外):

字母 作用域 说明
L(Local) 局部 函数内部
E(Enclosing) 闭包外层 嵌套函数的外层函数
G(Global) 全局 模块级别
B(Built-in) 内建 len、print 等内置名字

3.2 全局变量与 global

函数内直接赋值会创建局部变量,不会修改全局变量(摘自练习代码):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
num = 100

def func_a():
num = 10000 # 这是新建局部变量,不是改全局
print(num) # 10000

func_a()
print(num) # 100,全局变量没变

def func_b():
global num # 声明使用全局变量
num = 10000

func_b()
print(num) # 10000

要点:读全局变量不需要声明,写(重新赋值)全局变量必须先用 global 声明。修改可变对象(如 lst.append)不算重新赋值,无需 global。

3.3 nonlocal

嵌套函数里要修改外层函数的变量,用 nonlocal(不能用于全局,全局用 global):

1
2
3
4
5
6
7
8
9
10
11
def outer():
count = 0
def inner():
nonlocal count # 声明修改外层函数的 count
count += 1
return count
return inner

c = outer()
print(c()) # 1
print(c()) # 2

四、lambda 与高阶函数

4.1 函数是一等对象

Python 中函数本身是对象,可以赋值给变量、作为参数传递、作为返回值——这是「函数式编程」能力的基础:

1
2
3
4
5
6
7
def add(x, y):
return x + y

def calc(x, y, oper):
return oper(x, y) # 函数作为参数传入

print(calc(10, 20, add)) # 30

4.2 lambda 匿名函数

lambda 参数列表: 表达式 定义一个匿名函数,只能有一行表达式,自动返回结果,无需 return:

1
2
3
4
5
6
add = lambda x, y: x + y
print(add(100, 200)) # 300

# 最常用于 sort 的 key、map/filter 等一次性场景
words = ["C++", "Python", "Go", "JavaScript"]
words.sort(key=lambda s: len(s), reverse=True) # 按长度降序

lambda 适合「一次性的简单函数」;逻辑复杂、需要多行时请用 def 定义具名函数,可读性更好。

4.3 内置高阶函数

函数 作用 返回值
map(fn, iterable) 对每个元素应用 fn 迭代器
filter(fn, iterable) 保留 fn 为真的元素 迭代器
reduce(fn, iterable) 两两累积计算(functools) 单值
zip(*iterables) 并行打包多个序列 迭代器
sorted(iterable, key=) 排序返回新列表 列表
any(iterable) / all(iterable) 任一为真 / 全为真 布尔
1
2
3
4
5
6
7
8
9
10
11
12
13
nums = [1, 2, 3, 4, 5]

list(map(lambda x: x * 2, nums)) # [2, 4, 6, 8, 10]
list(filter(lambda x: x % 2 == 0, nums)) # [2, 4]

from functools import reduce
reduce(lambda x, y: x + y, nums) # 15(累加)

a, b = [1, 2, 3], ['x', 'y', 'z']
list(zip(a, b)) # [(1,'x'), (2,'y'), (3,'z')]

any([0, "", 3]) # True
all([1, 2, 3]) # True

map/filter 返回的是惰性迭代器,需 list() 转成列表才能直接看到结果。多数场景下列表推导式比 map/filter 更可读(见第 2 篇 3.6 节)。


五、递归

递归是函数调用自身的编程方式,必须有基准条件(终止条件)防止无限递归:

1
2
3
4
5
6
def jc(n):               # 阶乘
if n == 1: # 基准条件
return 1
return n * jc(n - 1) # 递归调用

print(jc(10)) # 3628800

递归的两个要点:

  1. 基准条件:递归到某一步必须能停止。
  2. 规模递减:每次调用让问题向基准条件靠近。

Python 对递归深度有限制(默认约 1000 层,sys.setrecursionlimit 可调),且没有尾递归优化,深层递归会栈溢出。因此能用循环解决的优先用循环,递归主要用于树、图、分治等天然递归的结构(如遍历目录、解析嵌套结构)。


六、类型注解

类型注解是给变量、函数参数和返回值标注类型,只是提示、不是强制约束——它不会改变 Python 的动态类型特性,但能帮助 IDE 补全、让工具(mypy、pylint)做静态检查,大幅减少类型错误(摘自练习代码 chapter02/18.类型注解.py)。

6.1 变量注解

1
2
3
4
5
6
7
8
9
10
11
12
a: int = 596
score: float = 98.5
hobby: str = "Python"
flag: bool = True

names: list[int] = ["A", "C", "E"] # 列表,元素是 int
phones: set[str] = {"13309091111", "15209101902"}
options: dict[str, int] = {"count": 2} # 字典,key 是 str,value 是 int
goods: tuple[str, int, int] = ("手机", 6999, 1) # 元组,各元素类型

# 联合类型:3.10+ 用 |
data: list[str | int] = ["A", 100]

注解是「提示」不是「约束」:给 list[int] 追加 10010.0(float)也不会报错,运行时照常执行。

6.2 函数注解

1
2
3
def circle_area_len(r: float) -> tuple[float, float]:
import math
return round(math.pi * r ** 2, 2), round(2 * math.pi * r, 2)

格式:def 函数名(参数: 类型) -> 返回值类型。

6.3 typing 模块(进阶)

基础类型不够用时,用 typing 模块的泛型(企业级常用):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from typing import Optional, Union, Any, Callable, Literal

# Optional[X] = X 或 None(旧写法,3.10+ 可直接写 X | None)
def find(name: str) -> Optional[int]:
return None

# Union[X, Y] = X 或 Y(旧写法,3.10+ 可用 |)
def f(x: Union[int, float]) -> Union[int, float]:
return x

# Any:任意类型(少用,等于放弃类型检查)
def f(x: Any) -> Any: ...

# Callable:函数类型
def apply(fn: Callable[[int, int], int], a: int, b: int) -> int:
return fn(a, b)

# Literal:限定具体取值(3.8+)
def set_mode(mode: Literal["read", "write"]) -> None: ...

3.10+ 推荐用 X | None、X | Y 替代 Optional[X]、Union[X, Y],写法更简洁。类型注解的完整进阶(泛型、Protocol)在第 6 篇《面向对象》配合 dataclass 一起讲。


七、functools 常用工具

functools 提供了几个高频使用的高阶函数工具:

7.1 partial 偏函数(固定部分参数)

1
2
3
4
5
6
7
8
from functools import partial

def power(base, exp):
return base ** exp

square = partial(power, exp=2) # 固定 exp=2
print(square(3)) # 9,等价 power(3, 2)
print(square(5)) # 25

适合「预先固定某些参数,生成专用函数」的场景(如固定数据库连接、固定默认配置)。

7.2 lru_cache 缓存(记忆化)

@lru_cache 自动缓存函数结果,重复调用直接返回缓存,是性能优化的利器:

1
2
3
4
5
6
7
8
9
from functools import lru_cache

@lru_cache(maxsize=128) # maxsize 缓存条目数,None 表示不限
def fib(n):
if n < 2:
return n
return fib(n - 1) + fib(n - 2)

print(fib(100)) # 没有缓存的话递归会算到天荒地老

适合「纯函数」(同样的输入永远同样的输出、无副作用)的重复计算,如递归、解析配置、数据库查询缓存。

7.3 reduce 累积计算

reduce(fn, 序列) 把序列两两累积,得到单值(见 4.3 节示例)。


小结

函数篇的核心是参数体系,这是 Python 与多数语言差异最大、最易失分的地方:

  1. 参数五种形式:位置、默认、*args、**kwargs、keyword-only,及调用时的 */** 解包。
  2. 可变默认参数陷阱:默认值必须是不可变对象或 None。
  3. 作用域 LEGB:读全局无需声明,写全局要 global,改闭包外层要 nonlocal。
  4. lambda 与高阶函数:函数是一等对象,sort(key=)、map/filter、partial/lru_cache 是生产高频。
  5. 类型注解:变量: 类型、参数: 类型 -> 返回类型、list[int]、X | None 联合类型,只是提示不做强制。