第四章 函数与模块化 —— 代码复用的艺术
4.1 函数的定义与调用
函数的基本结构
# Python函数完整定义
def calculate_bmi(weight_kg, height_m):
"""
计算身体质量指数(BMI)
参数:
weight_kg: 体重（千克）
height_m: 身高（米）
返回:
BMI值（浮点数）
"""
if height_m <= 0:
raise ValueError("身高必须为正数")
bmi = weight_kg / (height_m ** 2)
return bmi
# 调用函数
bmi = calculate_bmi(70, 1.75)
print(f"BMI: {bmi:.2f}")
# 参数传递的深度理解
# Python中参数传递是"对象引用传递"
def modify_list(lst):
lst.append(4) # 修改传入的列表对象
lst = [1, 2, 3] # 重新绑定，不影响外部
print(f"函数内部: {lst}")
my_list = [1, 2, 3]
modify_list(my_list)
print(f"函数外部: {my_list}") # [1,2,3,4] - append生效
// Java方法定义
public class Calculator {
// 基本方法
public static int add(int a, int b) {
return a + b;
}
// 重载（Overloading）：相同方法名，不同参数
public static int add(int a, int b, int c) {
return a + b + c;
}
public static double add(double a, double b) {
return a + b;
}
// 可变参数
public static int sum(int... numbers) {
int total = 0;
for (int num : numbers) {
total += num;
}
return total;
}
// 递归方法：阶乘
public static long factorial(int n) {
if (n <= 1) return 1;
return n * factorial(n - 1);
}
// 方法调用示例
public static void main(String[] args) {
System.out.println(add(5, 3)); // 8
System.out.println(add(5, 3, 2)); // 10
System.out.println(add(5.5, 3.2)); // 8.7
System.out.println(sum(1, 2, 3, 4, 5)); // 15
// 递归陷阱：栈溢出
// factorial(10000); // 可能抛出 StackOverflowError
}
}
4.2 参数的进阶特性
默认参数与关键字参数（Python）
# 默认参数
def greet(name, greeting="Hello", punctuation="!"):
print(f"{greeting}, {name}{punctuation}")
greet("Alice") # Hello, Alice!
greet("Bob", "Hi") # Hi, Bob!
greet("Charlie", punctuation="?") # Hello, Charlie?
# 默认参数的陷阱（可变对象）
def add_item(item, lst=[]): # 危险！默认参数在定义时计算
lst.append(item)
return lst
print(add_item(1)) # [1]
print(add_item(2)) # [1, 2] ！不是[2]
print(add_item(3)) # [1, 2, 3]
# 正确做法
def add_item_safe(item, lst=None):
if lst is None:
lst = []
lst.append(item)
return lst
# 关键字参数
def create_user(name, age, email):
print(f"Name: {name}, Age: {age}, Email: {email}")
create_user(age=25, name="Alice", email="alice@example.com") # 顺序任意
# 强制关键字参数（*号后的参数必须用关键字传递）
def config(host, port, *, timeout, retry):
print(f"Host: {host}, Port: {port}, Timeout: {timeout}, Retry: {retry}")
config("localhost", 8080, timeout=30, retry=3) # 正确
# config("localhost", 8080, 30, 3) # 错误！
4.3 变量作用域与闭包
// JavaScript作用域与闭包示例
function outerFunction(x) {
// 外部函数变量
let outerVar = 10;
// 内部函数（闭包）
function innerFunction(y) {
// 可以访问外部函数的变量
console.log(x + outerVar + y);
}
return innerFunction;
}
const closure = outerFunction(5);
closure(3); // 输出 18 (5+10+3)
// 经典闭包陷阱
function createCounters() {
let counters = [];
for (var i = 0; i < 3; i++) { // 使用var
counters.push(function() {
console.log(i);
});
}
return counters;
}
const counters = createCounters();
counters[0](); // 输出 3，不是0！
counters[1](); // 输出 3
counters[2](); // 输出 3
// 解决方案：使用let或IIFE
function createCountersFixed() {
let counters = [];
for (let i = 0; i < 3; i++) { // let有块级作用域
counters.push(function() {
console.log(i);
});
}
return counters;
}
4.4 递归的深度解析
# 递归经典案例：汉诺塔
def hanoi(n, source, target, auxiliary):
"""
汉诺塔递归解法
n: 盘子数量
source: 起始柱子
target: 目标柱子
auxiliary: 辅助柱子
"""
if n == 1:
print(f"移动盘子1从 {source} 到 {target}")
return
# 将n-1个盘子从source移动到auxiliary
hanoi(n - 1, source, auxiliary, target)
# 移动最大的盘子
print(f"移动盘子{n}从 {source} 到 {target}")
# 将n-1个盘子从auxiliary移动到target
hanoi(n - 1, auxiliary, target, source)
# 测试
hanoi(3, 'A', 'C', 'B')
# 递归优化：斐波那契数列（带备忘录）
def fibonacci_memo(n, memo={}):
if n in memo:
return memo[n]
if n <= 1:
return n
memo[n] = fibonacci_memo(n-1, memo) + fibonacci_memo(n-2, memo)
return memo[n]
# 尾递归（Python不支持尾递归优化，仅供参考）
def factorial_tail(n, accumulator=1):
if n == 0:
return accumulator
return factorial_tail(n-1, n * accumulator)
