Python 二级备考笔记（三）：函数和代码复用

1、函数的定义

函数是一段具有特定功能的、可重用的语句组，是一种功能的抽象。
用函数名来表示并通过函数名进行完成功能调用。
两个作用：降低编程难度和代码复用。
Python定义一个函数语法形式：

1
2
3

def <函数名>(<参数列表>):
    <函数体>
    return <返回值列表>

注意：函数体相对于 def 关键字必须缩进（通常为 4 个空格或 1 个 Tab），这是 Python 语法的强制要求。
即便函数没有参数，括号也不能省略，如 def func():。
函数定义时参数列表中的变量称为形参，函数体中的代码不会立即执行，只有在函数被调用时才会运行。

2、函数的调用

调用程序在 调用处 暂停执行；
在调用时将 实参复制 给函数的形参；
执行函数体语句；
函数执行结束给出返回值，程序回到调用前的 暂停处 继续执行。

调用方式：直接使用 函数名(实参列表) 即可，如 result = add(3, 5)。在调用之前，函数必须已经被定义。

3、lambda函数（匿名函数）

一种特殊的函数——匿名函数，又称 lambda 函数；
匿名函数并非没有名字，而是将函数名作为函数结果返回；
lambda 函数用于定义简单的、能够在一行内表示的函数；
定义形式：<函数名> = lambda <参数列表> : <表达式>

1 2	f = lambda x, y: x + y print(f(3, 5)) # 输出 8

二级考试常考结合：lambda 常作为 sort()、sorted()、map()、filter() 等高阶函数的参数使用。

# 按元组第二个元素排序
pairs = [(1, 'one'), (3, 'three'), (2, 'two')]
pairs.sort(key=lambda pair: pair[1])
print(pairs)  # 按字母顺序排序

4、函数参数的传递

4.1、基本概念：形参与实参

形参：函数定义时函数头中所包含的参数，类似于占位符，本身并不是拥有值的变量。
实参：函数调用时所使用的实际参数。
传递机制：只有当函数被调用时，调用者将实参的值传递给形参，形参才具有值。

4.2、可选参数和可变数量参数

1. 可选参数（默认参数）

在定义函数时，允许某些参数存在默认值，调用时若未传入该参数，则使用默认值。

示例：

def dup(str, times=2):
    print(str * times)

>>> dup("knock~")        # 未传 times，使用默认值 2
knock~knock~

>>> dup("knock~", 4)     # 传入 times=4，覆盖默认值
knock~knock~knock~knock~

⚠️ 重要规则：如果函数中混用默认值参数和非默认值参数，则非默认值参数必须定义在默认值参数之前。即 def func(a, b=1): 合法，def func(a=1, b): 非法。

2. 可变数量参数

指在函数定义时可以使用个数不确定的参数，使得同一函数可以接受不同数量的实参。
定义方式：在参数前增加星号（*）来指定该参数为可变数量参数。
特性：传入的多个实参会自动打包成一个元组（tuple） 类型。

示例：

def vfunc(a, *b):
    print(type(b))       # <class 'tuple'>
    for n in b:
        a += n
    return a

>>> vfunc(1, 2, 3, 4, 5)
15                       # 返回 1+2+3+4+5 的结果

双星号（**）可变参数：接收关键字参数，打包成字典（dict），形如 def func(**kwargs):，二级考试偶有出现，了解即可。

4.3、参数的位置和名称传递

1. 位置传递（默认方式）

实参默认按照位置顺序一一对应地传递给形参。
示例：调用 dup("knock~", 4) 时，第一个实参 "knock~" 默认赋值给形参 str，第二个实参 4 赋值给形参 times。

2. 名称传递（关键字传递）

调用函数时，通过指定参数名称来传递实参。
优点：由于显式指定了形参名，参数之间的顺序可以任意调整，不影响传递结果。
调用示例：dup(times=4, str="knock~")，顺序颠倒依然有效。
⚠️ 混用规则：位置参数必须在关键字参数之前，如 dup("knock~", times=4) 合法，dup(times=4, "knock~") 非法。

5、函数的返回值

return 语句用来退出函数，并将程序返回到函数被调用的位置继续执行。
可以将 0 个、1 个或多个 结果返回给函数被调用处的变量。
当返回多个值时，这些值以 元组（tuple）类型 保存。
函数可以没有 return 语句，此时函数并不返回值（相当于返回 None）。
执行机制：函数一旦执行到 return 语句，立即结束函数执行，后续代码不再运行。

6、变量作用域（全局变量与局部变量）

程序中的变量分为两类：全局变量 和 局部变量。
全局变量：在函数之外定义的变量，一般没有缩进，在程序执行全过程有效。
局部变量：在函数内部使用的变量，仅在函数内部有效，当函数退出时变量将不存在。

6.1、变量的作用域原则

简单数据类型变量（如 int、float、str、bool 等）：无论是否与全局变量重名，在函数内部默认均为 局部变量，仅在函数内部创建和使用，函数退出后变量被释放。

若要将简单数据类型变量声明为全局变量，需在函数内部使用 global 保留字显式声明。

x = 10
def func():
    global x
    x = 20
func()
print(x)   # 输出 20（全局变量被修改）

组合数据类型变量（如 list、dict、set 等）：

如果在函数内部没有被真实创建（即未赋值）的同名变量，则函数内部会将其视为 全局变量，可直接使用并修改其内容（如 append、update 等操作）。
如果在函数内部 真实创建（即赋值）了组合数据类型变量，则无论是否存在同名全局变量，该变量均为 局部变量，函数仅对局部变量进行操作，不影响全局变量。

lst = [1, 2, 3]
def func1():
    lst.append(4)    # 未赋值，视为全局变量，修改生效
def func2():
    lst = [5, 6]     # 赋值了，视为局部变量，全局不受影响
    lst.append(7)
func1()
func2()
print(lst)           # 输出 [1, 2, 3, 4]

7、递归函数（新增 ⭐ 考纲必考）

定义：函数在内部调用自身，称为递归调用。
两个必要条件：
1. 递归基例（终止条件）：明确指定函数在什么情况下不再调用自身，直接返回结果。
2. 递归链条（递推公式）：将原问题分解为规模更小的子问题，通过调用自身来解决。

经典示例 —— 阶乘：

def factorial(n):
    if n == 0:          # 递归基例
        return 1
    else:               # 递归链条
        return n * factorial(n - 1)

print(factorial(5))    # 输出 120

经典示例 —— 斐波那契数列：

def fib(n):
    if n <= 1:          # 递归基例
        return n
    else:               # 递归链条
        return fib(n - 1) + fib(n - 2)

print(fib(6))           # 输出 8（第6项为8）

⚠️ 易错点：
- 必须保证递归能在有限次调用后终止，否则会触发 RecursionError（超过递归深度限制）。
- Python 默认递归深度限制约为 1000，二级考试中递归深度很小，无需担心。
常见考题形式：给出递归函数代码，要求填写缺失部分，或写出函数执行结果。

8、高阶函数与函数作为参数（扩展，二级常考）

Python 中函数也是对象，可以像其他数据类型一样赋值给变量，或作为参数传递给另一个函数。

map(function, iterable)：将 function 依次作用于 iterable 的每个元素，返回一个迭代器。

1
2
3

nums = [1, 2, 3, 4]
squared = map(lambda x: x**2, nums)
print(list(squared))    # 输出 [1, 4, 9, 16]

filter(function, iterable)：保留 function 返回 True 的元素，返回一个迭代器。

1
2
3

nums = [1, 2, 3, 4, 5, 6]
evens = filter(lambda x: x % 2 == 0, nums)
print(list(evens))      # 输出 [2, 4, 6]

sorted(iterable, key=func)：通过 key 指定的函数来提取排序依据。

1
2
3

words = ["apple", "banana", "kiwi"]
sorted_words = sorted(words, key=lambda w: len(w))
print(sorted_words)     # 按长度排序：['kiwi', 'apple', 'banana']

🧾 函数模块速查表

考点	说明	示例
函数定义	`def` + 函数名 + 括号 + 冒号	`def add(a, b): return a + b`
可选参数	默认值参数，必须放在非默认参数之后	`def func(a, b=1):`
*可变参数 ``**	接收多个位置参数，打包为元组	`def func(*args):`
可变参数 ``**	接收多个关键字参数，打包为字典	`def func(**kwargs):`
关键字传递	指定形参名传参，顺序可调	`func(b=2, a=1)`
`return`	返回结果并结束函数	`return x, y` 返回元组
`global`	函数内声明使用全局变量	`global x`
递归	函数调用自身，须有终止条件	阶乘 / 斐波那契
`lambda`	一行匿名函数	`lambda x: x*2`
`map`	对可迭代对象每个元素应用函数	`map(lambda x: x*2, [1,2,3])`
`filter`	筛选满足条件的元素	`filter(lambda x: x>0, [-1,2,-3])`
`sorted(key=...)`	按指定规则排序	`sorted(lst, key=lambda x: len(x))`