Python函数编程基础：从定义到高级应用全解析

1. Python函数基础：从零开始的编程思维革命

在Python编程的世界里，函数就像厨房里的多功能料理机——你把食材（参数）放进去，选择功能（函数体），它就能帮你完成切碎、搅拌、加热等各种操作，最后输出成品（返回值）。我刚开始学Python时，总觉得函数是个抽象概念，直到有次需要重复计算不同半径的圆面积，才真正体会到"写一次，用无数次"的函数魅力。

Python函数本质上是一段可重用的代码块，通过def关键字定义，可以接受输入（参数），处理数据（函数体），然后返回结果。与数学中的函数概念类似，f(x)=x²在Python中可以写成：

python复制def square(x):
    return x ** 2

这个简单的例子包含了函数三大要素：定义（def）、参数（x）和返回值（return）。实际开发中，函数的价值远不止于此——它能将复杂问题分解为小模块，提高代码可读性；避免重复代码，便于维护；还能隔离作用域，防止变量污染。

新手常见误区：很多初学者喜欢把所有代码都写在全局作用域，导致后期调试困难。我的经验是，当某段代码需要重复两次以上，就该考虑封装成函数了。

2. 函数定义详解：不只是def那么简单

2.1 定义语法解剖

一个完整的函数定义包含以下部分：

python复制def 函数名(参数列表):
    """文档字符串（可选）"""
    函数体
    [return 返回值]

文档字符串（docstring）是函数的使用说明书，虽然可选但强烈建议添加。用三个引号包裹，可以通过函数名.__doc__查看。我习惯用Google风格：

python复制def calculate_circle_area(radius):
    """计算圆的面积
    
    Args:
        radius (float): 圆的半径，单位米
        
    Returns:
        float: 圆的面积，单位平方米
    """
    return 3.14159 * radius ** 2

2.2 命名规范与作用域

函数命名应遵循PEP8规范：

• 全小写，下划线分隔（snake_case）
• 动词开头，如get_user、calculate_score
• 避免使用Python内置函数名，如list、str

作用域规则是另一个关键点：

• 函数内部定义的变量是局部变量
• 使用global关键字可修改全局变量（但应尽量避免）
• nonlocal关键字用于闭包场景

python复制count = 0  # 全局变量

def increment():
    global count  # 声明使用全局变量
    count += 1

经验之谈：我曾在一个项目里滥用global变量，导致调试噩梦。后来遵循"函数应尽量减少副作用"原则，显式通过参数和返回值传递数据，代码质量大幅提升。

3. 函数调用：让代码动起来的艺术

3.1 基础调用方式

定义函数只是准备菜谱，调用才是真正下厨。基本调用格式：

python复制result = 函数名(参数)

Python支持四种调用方式：

1. 位置参数：按定义顺序传参

   python复制def greet(name, message):
       print(f"{name}, {message}")
   
   greet("Alice", "早上好")  # 位置参数
   

2. 关键字参数：按参数名指定

   python复制greet(message="你好", name="Bob")  # 关键字参数
   

3. 默认参数：定义时指定默认值

   python复制def greet(name, message="欢迎"):
       print(f"{name}, {message}")
   
   greet("Charlie")  # 使用默认message
   

4. 可变参数：处理不确定数量的参数

   python复制def sum_numbers(*args):  # 接收任意数量位置参数
       return sum(args)
   
   print(sum_numbers(1, 2, 3))  # 输出6
   

3.2 调用栈与递归

每次函数调用都会在内存中创建栈帧（stack frame），存储局部变量和返回地址。理解这点对调试递归函数特别重要：

python复制def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n-1)  # 递归调用

递归虽然优雅，但Python默认递归深度限制在1000层左右（可通过sys.setrecursionlimit()调整）。对于深度递归问题，我通常改用循环实现，避免栈溢出。

调试技巧：在VSCode中设置断点调试时，调用栈窗口能清晰展示函数调用层次，配合局部变量监视，是理解程序执行流程的利器。

4. 参数传递机制：值传递还是引用传递？

4.1 Python的参数传递本质

Python的参数传递既不是纯值传递，也不是纯引用传递，而是"对象引用传递"。简单说：

• 不可变对象（数字、字符串、元组）：函数内修改会创建新对象
• 可变对象（列表、字典、集合）：函数内修改会影响原对象

python复制def modify_data(a, b):
    a = 2  # 创建新int对象
    b.append(3)  # 修改原列表

x = 1  # 不可变
y = [1, 2]  # 可变
modify_data(x, y)
print(x, y)  # 输出1 [1, 2, 3]

4.2 参数类型详解

Python支持丰富的参数类型，合理组合能让函数更灵活：

1. 位置参数：最基本的参数形式
2. 默认参数：定义时指定默认值

   python复制def connect(host, port=3306, timeout=10):
       pass
   

3. 可变位置参数：*args收集多余位置参数
4. 可变关键字参数：**kwargs收集多余关键字参数
5. 仅关键字参数：在*后定义的参数必须用关键字传递

   python复制def draw_point(x, y, *, color='red'):
       pass
   
   draw_point(1, 2, color='blue')  # 正确
   draw_point(1, 2, 'blue')  # 报错
   

6. 仅位置参数：Python3.8新增，在/前定义的参数必须用位置传递

   python复制def divmod(x, y, /):
       pass
   
   divmod(10, 2)  # 正确
   divmod(x=10, y=2)  # 报错
   

参数设计原则：我通常按"必选参数 -> 默认参数 -> *args -> **kwargs"顺序定义，保持接口清晰。过于复杂的参数列表可能意味着函数需要拆分。

5. 返回值：不只是return那么简单

5.1 多返回值与序列解包

Python函数可以返回多个值（实际上是返回元组）：

python复制def analyze_data(data):
    avg = sum(data)/len(data)
    max_val = max(data)
    min_val = min(data)
    return avg, max_val, min_val  # 实际返回一个元组

result = analyze_data([1, 2, 3, 4, 5])
average, maximum, minimum = result  # 序列解包

5.2 返回函数与闭包

函数可以作为返回值，这种技术常用于闭包和装饰器：

python复制def make_multiplier(factor):
    def multiplier(x):
        return x * factor
    return multiplier

double = make_multiplier(2)
print(double(5))  # 输出10

闭包可以记住定义时的环境变量（如factor），这种特性在回调函数和装饰器中非常有用。

5.3 None返回值与类型提示

没有return语句或只有return的函数返回None。Python3.5+支持类型提示：

python复制from typing import Tuple, Optional

def parse_email(email: str) -> Optional[Tuple[str, str]]:
    """解析邮箱地址，返回(username, domain)或None"""
    if '@' in email:
        return tuple(email.split('@'))
    return None

类型提示不会影响运行时行为，但能让IDE提供更好的代码补全和静态检查。

性能提示：返回大列表时，考虑改为生成器（yield）可以节省内存。我曾用生成器重构一个返回百万级记录的函数，内存占用从2GB降到几MB。

6. 实战技巧与常见陷阱

6.1 lambda表达式：匿名函数的妙用

lambda用于创建小型匿名函数，通常作为参数传递：

python复制numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, numbers))  # [1, 4, 9, 16]

但复杂的逻辑还是应该用def定义，lambda不应超过一行。

6.2 函数属性与注解

函数也是对象，可以动态添加属性：

python复制def foo():
    pass

foo.author = "John"
print(foo.author)  # 输出John

Python3支持函数注解（annotations），可以声明参数和返回值的类型：

python复制def greet(name: str, times: int = 1) -> str:
    return " ".join([f"Hello {name}"] * times)

6.3 常见错误排查

1. 参数顺序错误：特别是位置参数和关键字参数混用时
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
   

3. 忽略返回值：特别是修改可变参数又返回新对象时
4. 递归深度过大：导致栈溢出

6.4 性能优化建议

1. 局部变量访问比全局变量快
2. 避免在循环内部定义函数
3. 使用functools.lru_cache缓存计算结果

   python复制from functools import lru_cache
   
   @lru_cache(maxsize=128)
   def fibonacci(n):
       if n < 2:
           return n
       return fibonacci(n-1) + fibonacci(n-2)
   

4. 用生成器替代返回大列表

7. 函数进阶：装饰器与函数式编程

7.1 装饰器原理与应用

装饰器本质上是一个接受函数作为参数的高阶函数：

python复制def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__}执行耗时：{end-start:.4f}秒")
        return result
    return wrapper

@timer
def long_running_func():
    time.sleep(1)

long_running_func()  # 自动打印执行时间

Python内置了@property、@classmethod、@staticmethod等装饰器，第三方库如Flask也大量使用装饰器路由。

7.2 函数式编程工具

Python虽然不是纯函数式语言，但提供了一些函数式编程工具：

1. map：对可迭代对象应用函数

   python复制list(map(str.upper, ['a', 'b', 'c']))  # ['A', 'B', 'C']
   

2. filter：过滤元素

   python复制list(filter(lambda x: x%2==0, range(10)))  # [0, 2, 4, 6, 8]
   

3. reduce：累积计算（需从functools导入）

   python复制from functools import reduce
   reduce(lambda x,y: x*y, [1,2,3,4])  # 24
   

4. 列表推导式：通常比map+filter更易读

   python复制[x**2 for x in range(10) if x%2==0]  # [0, 4, 16, 36, 64]
   

7.3 偏函数与柯里化

functools.partial可以固定部分参数，创建新函数：

python复制from functools import partial

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

square = partial(power, exponent=2)
cube = partial(power, exponent=3)

print(square(5))  # 25
print(cube(5))    # 125

柯里化（Currying）是把多参数函数转换为一系列单参数函数的技术：

python复制def curry_power(base):
    def inner(exponent):
        return base ** exponent
    return inner

power_of_two = curry_power(2)
print(power_of_two(3))  # 8

8. 工程实践：如何设计好函数？

8.1 单一职责原则

一个函数应该只做一件事，并且做好。我常用这个标准判断函数是否需要拆分：

• 函数名是否需要"和"或"或"来描述功能？
• 函数体是否超过一屏（约50行）？
• 是否有多个嵌套层级？

8.2 合理的参数设计

参数数量最好不超过7个（心理学研究表明这是人类短期记忆的极限）。过多的参数可以考虑：

1. 使用对象封装相关参数
2. 拆分为多个函数
3. 使用**kwargs接收配置项

8.3 错误处理策略

函数应该明确处理哪些错误，抛出哪些异常：

python复制def divide(a, b):
    if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
        raise TypeError("参数必须是数字")
    if b == 0:
        raise ValueError("除数不能为零")
    return a / b

8.4 文档与测试

良好的文档应包括：

• 函数目的
• 参数说明
• 返回值说明
• 可能抛出的异常
• 使用示例

为关键函数编写单元测试：

python复制import unittest

class TestMathFunctions(unittest.TestCase):
    def test_divide(self):
        self.assertEqual(divide(4, 2), 2)
        with self.assertRaises(ValueError):
            divide(1, 0)

if __name__ == '__main__':
    unittest.main()

9. 与其他语言函数的对比

9.1 与C语言函数对比

1. Python不需要声明返回类型
2. Python支持多返回值
3. Python参数传递方式不同（对象引用 vs 值传递/指针）
4. Python支持默认参数、关键字参数等高级特性
5. Python函数是一等公民，可以作为参数和返回值

9.2 与JavaScript函数对比

1. Python有明确的def语法，JavaScript有function和箭头函数
2. Python参数传递更严格，JavaScript会静默处理参数不匹配
3. Python有更丰富的参数类型（如仅位置参数）
4. Python的闭包变量需要nonlocal声明才能修改，JavaScript可以直接修改

9.3 与Java方法对比

1. Python函数可以独立存在，Java方法必须属于某个类
2. Python支持动态参数和关键字参数
3. Python函数可以嵌套定义
4. Python没有重载（overload），但可以通过参数默认值和类型检查模拟

10. 现代Python函数特性

10.1 类型提示与静态检查

Python3.5+支持类型提示，配合mypy等工具可以进行静态类型检查：

python复制from typing import List, Dict, Optional

def process_data(
    items: List[str],
    config: Dict[str, int],
    verbose: bool = False
) -> Optional[float]:
    """处理数据并返回结果或None"""
    if not items:
        return None
    # 处理逻辑...
    return 3.14

10.2 异步函数

Python3.5引入async/await语法支持协程：

python复制import asyncio

async def fetch_data(url):
    print(f"开始获取 {url}")
    await asyncio.sleep(2)  # 模拟IO操作
    print(f"完成获取 {url}")
    return {"data": "example"}

async def main():
    task1 = fetch_data("https://api.example.com/1")
    task2 = fetch_data("https://api.example.com/2")
    results = await asyncio.gather(task1, task2)
    print(results)

asyncio.run(main())

10.3 数据类与函数结合

Python3.7+的dataclasses可以简化数据封装：

python复制from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

def distance(p1: Point, p2: Point) -> float:
    return ((p1.x - p2.x)**2 + (p1.y - p2.y)**2)**0.5

11. 函数调试技巧

11.1 打印调试信息

使用print是最简单的调试方法，但更好的做法是使用logging模块：

python复制import logging

logging.basicConfig(level=logging.DEBUG)

def complex_calculation(x):
    logging.debug(f"开始计算，x={x}")
    try:
        result = x ** 0.5
        logging.debug(f"计算结果：{result}")
        return result
    except Exception as e:
        logging.error(f"计算错误：{e}")
        raise

11.2 使用pdb调试

Python内置pdb调试器：

python复制import pdb

def problematic_function(data):
    pdb.set_trace()  # 设置断点
    # 复杂逻辑...
    return result

常用命令：

• n(ext)：执行下一行
• c(ontinue)：继续执行直到下一个断点
• l(ist)：显示当前代码
• p(rint)：打印变量值
• q(uit)：退出调试

11.3 IDE调试技巧

现代IDE如VSCode、PyCharm提供图形化调试界面：

1. 设置断点
2. 单步执行
3. 查看调用栈
4. 监视变量
5. 条件断点

在VSCode中调试配置示例（launch.json）：

json复制{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Current File",
            "type": "python",
            "request": "launch",
            "program": "${file}",
            "console": "integratedTerminal",
            "justMyCode": true
        }
    ]
}

12. 函数性能优化

12.1 时间复杂度和空间复杂度

理解算法复杂度是优化基础：

• O(1)：常数时间，如字典查找
• O(n)：线性时间，如列表遍历
• O(n²)：平方时间，如嵌套循环
• O(log n)：对数时间，如二分查找

12.2 性能分析工具

1. timeit模块测量小段代码执行时间：

   python复制import timeit
   
   timeit.timeit('"-".join(str(n) for n in range(100))', number=10000)
   

2. cProfile进行完整性能分析：

   python复制import cProfile
   
   def slow_function():
       # 慢速代码...
   
   cProfile.run('slow_function()')
   

3. memory_profiler分析内存使用：

   python复制from memory_profiler import profile
   
   @profile
   def memory_intensive_func():
       # 内存密集型操作...
   

12.3 优化策略

1. 避免不必要的计算，使用缓存
2. 使用生成器替代列表
3. 利用内置函数和库（通常是C实现的）
4. 减少全局变量访问
5. 对于性能关键代码，考虑用Cython或Numba加速

python复制# 使用生成器节省内存
def large_dataset_processing():
    for i in range(1000000):
        yield i * 2  # 每次只生成一个值，不占用大量内存

# 使用内置函数加速
numbers = list(range(1000000))
sum_numbers = sum(numbers)  # 比手写循环快

13. 函数设计模式

13.1 策略模式

用函数实现策略模式，动态选择算法：

python复制def strategy_add(a, b):
    return a + b

def strategy_multiply(a, b):
    return a * b

class Calculator:
    def __init__(self, strategy=strategy_add):
        self.strategy = strategy
    
    def calculate(self, a, b):
        return self.strategy(a, b)

calc = Calculator(strategy_multiply)
print(calc.calculate(3, 4))  # 12

13.2 工厂模式

用函数作为工厂创建对象：

python复制def create_animal(animal_type):
    if animal_type == "dog":
        return Dog()
    elif animal_type == "cat":
        return Cat()
    else:
        raise ValueError(f"未知动物类型: {animal_type}")

class Dog: pass
class Cat: pass

pet = create_animal("dog")

13.3 观察者模式

用函数实现事件回调：

python复制class Button:
    def __init__(self):
        self.click_handlers = []
    
    def on_click(self, handler):
        self.click_handlers.append(handler)
    
    def click(self):
        for handler in self.click_handlers:
            handler(self)

def log_click(button):
    print(f"按钮被点击了: {button}")

btn = Button()
btn.on_click(log_click)
btn.click()

14. 函数与面向对象编程

14.1 方法与函数的区别

方法是定义在类中的函数，第一个参数通常是self（实例方法）或cls（类方法）：

python复制class MyClass:
    def instance_method(self):  # 实例方法
        return f"实例方法被调用，实例: {self}"
    
    @classmethod
    def class_method(cls):  # 类方法
        return f"类方法被调用，类: {cls}"
    
    @staticmethod
    def static_method():  # 静态方法
        return "静态方法被调用"

14.2 魔法方法

Python用特殊命名的方法实现运算符重载等功能：

python复制class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):  # 重载+运算符
        return Vector(self.x + other.x, self.y + other.y)
    
    def __str__(self):  # 定义打印格式
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)  # Vector(4, 6)

14.3 函数与类的选择

何时用函数，何时用类？我的经验法则是：

• 如果只需要一个操作：用函数
• 如果需要维护状态：用类
• 如果有一组相关操作：考虑类
• 如果需要继承和多态：用类

15. 函数式编程实践

15.1 纯函数与副作用

纯函数是指：

1. 相同输入总是产生相同输出
2. 没有副作用（不修改外部状态）

python复制# 纯函数
def pure_add(a, b):
    return a + b

# 非纯函数
total = 0
def impure_add(a):
    global total
    total += a
    return total

15.2 高阶函数应用

高阶函数是指接受或返回函数的函数：

python复制def apply_operation(func, a, b):
    return func(a, b)

result = apply_operation(lambda x, y: x * y, 3, 4)  # 12

15.3 不可变数据流

函数式编程倾向于使用不可变数据结构：

python复制from functools import reduce

def process_data(data):
    return reduce(
        lambda acc, x: acc + [x * 2] if x % 2 == 0 else acc,
        data,
        []
    )

data = (1, 2, 3, 4, 5)  # 使用元组而非列表
result = process_data(data)  # [4, 8]

16. 函数测试与文档

16.1 doctest：文档中的测试

Python可以在文档字符串中嵌入测试用例：

python复制def factorial(n):
    """计算阶乘
    
    >>> factorial(5)
    120
    >>> factorial(0)
    1
    >>> factorial(-1)
    Traceback (most recent call last):
        ...
    ValueError: n必须是非负整数
    """
    if n < 0:
        raise ValueError("n必须是非负整数")
    return 1 if n == 0 else n * factorial(n-1)

if __name__ == "__main__":
    import doctest
    doctest.testmod()

16.2 unittest框架

Python标准库中的单元测试框架：

python复制import unittest

class TestMathFunctions(unittest.TestCase):
    def test_factorial(self):
        self.assertEqual(factorial(5), 120)
        self.assertEqual(factorial(0), 1)
        with self.assertRaises(ValueError):
            factorial(-1)

if __name__ == '__main__':
    unittest.main()

16.3 pytest进阶测试

第三方pytest框架更简洁强大：

python复制# test_math.py
import pytest

from math_functions import factorial

def test_factorial_normal_cases():
    assert factorial(5) == 120
    assert factorial(0) == 1

def test_factorial_error_case():
    with pytest.raises(ValueError):
        factorial(-1)

运行测试：

bash复制pytest test_math.py -v

17. 函数与模块化设计

17.1 模块化原则

好的函数设计应该：

1. 高内聚：函数内部元素紧密相关
2. 低耦合：函数之间依赖尽可能少
3. 单一职责：一个函数只做一件事
4. 明确接口：参数和返回值定义清晰

17.2 包与模块组织

Python项目典型结构：

code复制my_project/
├── __init__.py
├── main.py
├── utils/
│   ├── __init__.py
│   ├── math_utils.py  # 包含各种数学函数
│   └── file_utils.py  # 文件操作函数
└── tests/
    ├── test_math.py
    └── test_file.py

17.3 循环导入问题

当模块A导入模块B，同时模块B又导入模块A时，会产生循环导入。解决方案：

1. 重构代码，消除循环依赖
2. 将导入语句移到函数内部
3. 使用第三方模块作为中介

18. 函数与并发编程

18.1 多线程中的函数

threading模块创建线程：

python复制import threading

def worker(num):
    print(f"Worker {num} 开始执行")
    # 执行任务...
    print(f"Worker {num} 执行结束")

threads = []
for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

18.2 多进程中的函数

multiprocessing模块创建进程：

python复制from multiprocessing import Process

def cpu_intensive_task(data):
    result = sum(x*x for x in data)
    print(f"计算结果: {result}")

if __name__ == '__main__':
    data = list(range(1000000))
    processes = []
    
    # 分成4个进程计算
    chunk_size = len(data) // 4
    for i in range(4):
        chunk = data[i*chunk_size : (i+1)*chunk_size]
        p = Process(target=cpu_intensive_task, args=(chunk,))
        processes.append(p)
        p.start()
    
    for p in processes:
        p.join()

18.3 协程中的函数

asyncio实现协程并发：

python复制import asyncio

async def fetch_data(url):
    print(f"开始获取 {url}")
    await asyncio.sleep(2)  # 模拟IO等待
    print(f"完成获取 {url}")
    return f"{url} 的数据"

async def main():
    tasks = [
        fetch_data("url1"),
        fetch_data("url2"),
        fetch_data("url3")
    ]
    results = await asyncio.gather(*tasks)
    print(results)

asyncio.run(main())

19. 函数与元编程

19.1 动态创建函数

使用types.FunctionType动态创建函数：

python复制import types

def create_function(name, arg_names, code):
    # 编译代码
    bytecode = compile(code, "<string>", "exec")
    
    # 创建函数对象
    globals_dict = {}
    exec(bytecode, globals_dict)
    func = globals_dict[name]
    
    # 设置参数
    func.__code__ = func.__code__.replace(
        co_varnames=arg_names,
        co_argcount=len(arg_names)
    )
    
    return func

# 动态创建add函数
add = create_function(
    name="add",
    arg_names=("a", "b"),
    code="def add(a, b): return a + b"
)

print(add(2, 3))  # 5

19.2 装饰器工厂

返回装饰器的函数：

python复制def repeat(num_times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(num_times=3)
def greet(name):
    print(f"Hello {name}")

greet("Alice")
# 输出:
# Hello Alice
# Hello Alice
# Hello Alice

19.3 函数自省

运行时获取函数信息：

python复制def example(a: int, b: float = 1.0) -> str:
    """示例函数"""
    return f"{a} {b}"

# 获取函数属性
print(example.__name__)  # example
print(example.__annotations__)  # {'a': <class 'int'>, 'b': <class 'float'>, 'return': <class 'str'>}
print(example.__doc__)  # 示例函数

# 获取参数信息
import inspect
sig = inspect.signature(example)
print(sig)  # (a: int, b: float = 1.0) -> str

20. 函数最佳实践总结

经过多年Python开发，我总结了这些函数设计黄金法则：

1. 短小精悍：理想函数长度在5-15行，最多不超过一屏
2. 单一职责：每个函数只做一件事，并且做好
3. 明确命名：函数名应准确描述功能，动词开头
4. 最少参数：参数数量尽量少，超过5个考虑重构
5. 无副作用：尽量避免修改外部状态，纯函数更易测试
6. 良好文档：为公共函数编写清晰的docstring
7. 全面测试：为关键函数编写单元测试
8. 合理抽象：适当抽象重复逻辑，但避免过度设计
9. 性能考量：对热点函数进行优化，非热点保持可读性
10. 风格一致：遵循PEP8和团队编码规范

最后分享一个真实案例：我曾接手一个包含2000行函数的遗留系统，调试极其困难。通过将其拆分为30多个小函数，每个函数专注单一任务，代码可读性和可维护性大幅提升，后续功能扩展速度提高了3倍。这让我深刻体会到良好函数设计的重要性。