Python函数编程：从基础到高阶的实战练习

1. 函数练习题的价值与意义

函数作为编程中的基本构建块，其重要性不言而喻。我见过太多初学者在函数这个坎上栽跟头——要么是参数传递搞不清楚，要么是返回值处理不当，甚至有人连基本的函数定义语法都记不住。函数练习题正是为了解决这些问题而存在的。

在实际开发中，函数就像乐高积木的单个模块。一个复杂的程序往往由数十甚至上百个函数组成。我常跟团队里的新人说："如果你连单个积木都搭不好，怎么可能搭建出宏伟的建筑？"函数练习题就是从最基础的积木开始训练，逐步提升到复杂组合的过程。

2. 函数基础练习题解析

2.1 基本函数定义与调用

让我们从一个最简单的例子开始：

python复制def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))  # 输出: Hello, Alice!

这个例子虽然简单，但包含了几个关键点：

1. def关键字定义函数
2. 函数名greet和参数name
3. return语句返回结果
4. 函数调用方式greet("Alice")

注意：Python中函数定义必须在使用前，这点和JavaScript的hoisting不同。我曾经在一个项目中因为忽略这个细节导致过报错。

2.2 参数传递的常见陷阱

参数传递是函数练习中的重点难点。看这个例子：

python复制def update_list(lst):
    lst.append(4)
    return lst

my_list = [1, 2, 3]
print(update_list(my_list))  # 输出: [1, 2, 3, 4]
print(my_list)  # 输出: [1, 2, 3, 4] 原列表被修改了！

这里演示了Python中可变对象作为参数时的特性——函数内对参数的修改会影响原始对象。这是很多初学者容易踩的坑。

2.3 返回值处理练习

返回值处理同样重要。看这个综合练习：

python复制def calculate_stats(numbers):
    if not numbers:
        return None
    return {
        'sum': sum(numbers),
        'avg': sum(numbers)/len(numbers),
        'max': max(numbers),
        'min': min(numbers)
    }

stats = calculate_stats([10, 20, 30, 40])
print(f"Sum: {stats['sum']}, Avg: {stats['avg']}")

这个练习涵盖了：

1. 空列表处理
2. 多值返回（使用字典包装）
3. 内置函数sum/max/min的使用
4. 返回值的解包和使用

3. 中级函数练习题

3.1 递归函数实现

递归是函数练习中的高阶内容。以经典的斐波那契数列为例：

python复制def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 打印前10项
for i in range(10):
    print(fibonacci(i), end=' ')
# 输出: 0 1 1 2 3 5 8 13 21 34 

警告：这种递归实现效率极低（O(2^n)时间复杂度），实际项目中应该使用记忆化或迭代方法。我曾经在生产环境因为忽略这点导致服务崩溃。

3.2 高阶函数练习

Python中函数是一等公民，可以作为参数传递。看这个map/reduce练习：

python复制from functools import reduce

def square(x):
    return x * x

def is_odd(x):
    return x % 2 != 0

numbers = [1, 2, 3, 4, 5]

# 使用map对每个元素平方
squared = list(map(square, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# 使用filter筛选奇数
odds = list(filter(is_odd, numbers))
print(odds)  # [1, 3, 5]

# 使用reduce求和
total = reduce(lambda x, y: x + y, numbers)
print(total)  # 15

这个例子展示了Python函数式编程的三个核心操作，也是面试常考点。

3.3 闭包的实际应用

闭包是函数的高级特性，看这个计数器例子：

python复制def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

counter = make_counter()
print(counter())  # 1
print(counter())  # 2
print(counter())  # 3

闭包在实际项目中常用于状态保持、装饰器等场景。理解闭包对掌握Python高级特性至关重要。

4. 函数练习题进阶

4.1 装饰器实战

装饰器是Python的特色功能，看这个计时装饰器：

python复制import time

def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} executed in {end-start:.4f}s")
        return result
    return wrapper

@timer
def long_running_function(n):
    time.sleep(n)
    return "Done"

print(long_running_function(2))
# 输出:
# long_running_function executed in 2.0050s
# Done

装饰器在Web框架（如Flask的路由）、日志记录等场景广泛应用。掌握装饰器能大幅提升代码复用性。

4.2 生成器函数

生成器是Python的独特特性，看这个无限序列生成器：

python复制def infinite_sequence():
    num = 0
    while True:
        yield num
        num += 1

gen = infinite_sequence()
print(next(gen))  # 0
print(next(gen))  # 1
print(next(gen))  # 2
# 可以无限继续...

生成器在处理大数据流时非常有用，因为它不会一次性加载所有数据到内存。我在处理GB级日志文件时就经常使用生成器。

4.3 类型提示与函数注解

Python 3.5+引入了类型提示，看这个带类型注解的函数：

python复制from typing import List, Dict, Optional

def process_data(
    data: List[int],
    config: Optional[Dict[str, str]] = None
) -> float:
    """处理数据并返回平均值"""
    if config:
        print(f"Using config: {config}")
    return sum(data) / len(data)

result = process_data([1, 2, 3], {"mode": "strict"})
print(result)  # 2.0

类型提示虽然不影响运行时，但能大大提高代码可读性和IDE支持。现代Python项目基本都会使用类型提示。

5. 函数练习题常见问题与解决

5.1 变量作用域混淆

python复制x = 10

def func():
    print(x)  # 这里会报错
    x = 20

func()

这个例子会报UnboundLocalError，因为函数内对x赋值导致Python将其视为局部变量。解决方法是在函数内使用global x声明（或避免这种写法）。

5.2 默认参数的可变陷阱

python复制def add_item(item, lst=[]):
    lst.append(item)
    return lst

print(add_item(1))  # [1]
print(add_item(2))  # [1, 2] 不是预期的[2]！

默认参数在函数定义时求值，因此可变默认参数会被所有调用共享。正确做法是：

python复制def add_item(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

5.3 递归深度限制

Python默认递归深度限制约为1000层。对于深度递归算法，应该考虑改为迭代实现或使用尾递归优化（虽然Python不直接支持尾递归优化）。

6. 函数练习题实战项目

6.1 实现一个简单的缓存系统

python复制def make_cache():
    cache = {}

    def cached_func(func):
        def wrapper(*args):
            if args in cache:
                print("Returning cached result")
                return cache[args]
            result = func(*args)
            cache[args] = result
            return result
        return wrapper
    
    return cached_func

cache_decorator = make_cache()

@cache_decorator
def expensive_computation(n):
    print(f"Computing {n}...")
    return n * n

print(expensive_computation(4))  # Computing 4... 16
print(expensive_computation(4))  # Returning cached result 16

这个缓存系统在实际项目中很有用，特别是对于计算密集型函数。

6.2 实现一个简单的路由系统

python复制class Router:
    def __init__(self):
        self.routes = {}

    def route(self, path):
        def decorator(func):
            self.routes[path] = func
            return func
        return decorator

    def serve(self, path, *args, **kwargs):
        if path in self.routes:
            return self.routes[path](*args, **kwargs)
        raise ValueError(f"No route for {path}")

router = Router()

@router.route("/home")
def home():
    return "Welcome home!"

@router.route("/about")
def about():
    return "About us"

print(router.serve("/home"))  # Welcome home!

这个简易路由系统展示了如何用函数构建Web框架的核心机制。

6.3 实现一个简单的测试框架

python复制class TestFramework:
    def __init__(self):
        self.tests = []

    def test(self, func):
        self.tests.append(func)
        return func

    def run_tests(self):
        for test in self.tests:
            try:
                test()
                print(f"{test.__name__}: PASS")
            except AssertionError as e:
                print(f"{test.__name__}: FAIL - {e}")

tf = TestFramework()

@tf.test
def test_addition():
    assert 1 + 1 == 2, "1+1 should be 2"

@tf.test
def test_subtraction():
    assert 5 - 3 == 1, "5-3 should be 2"  # 这个会失败

tf.run_tests()
# 输出:
# test_addition: PASS
# test_subtraction: FAIL - 5-3 should be 2

这个测试框架展示了如何用函数构建测试基础设施，是理解Python测试框架（如pytest）工作原理的好例子。