Python教程29：函数与模块总结

“温故而知新，可以为师矣。”

经过前面13课的学习（第17-28课），我们系统学习了Python的函数、模块、异常处理等核心概念。今天我们回顾总结，梳理知识体系，巩固所学内容。

1. 函数基础回顾

核心概念

函数的作用：

  • 代码复用：写一次，用多次
  • 模块化：分解复杂问题
  • 抽象：隐藏实现细节
  • 可读性：函数名即文档

关键知识点

 1# 基本结构
 2def function_name(parameters):
 3    """文档字符串"""
 4    # 函数体
 5    return result
 6
 7# 参数类型
 8def func(a, b=默认值, *args, **kwargs):
 9    """
10    a: 位置参数
11    b: 默认参数
12    *args: 可变位置参数（元组）
13    **kwargs: 可变关键字参数（字典）
14    """
15    pass
16
17# 返回值
18def multi_return():
19    return value1, value2  # 实际返回元组
20
21# 函数是一等公民
22def outer(func):
23    return func  # 可以作为参数和返回值

回顾第17课：函数基础（定义、参数、返回值、作用域）

2. Lambda与高阶函数

Lambda表达式

1# 匿名函数
2square = lambda x: x ** 2
3
4# 适用场景：简单、临时、作为参数
5sorted(students, key=lambda x: x["score"])

高阶函数

1# map - 映射
2squares = map(lambda x: x**2, numbers)
3
4# filter - 过滤
5evens = filter(lambda x: x % 2 == 0, numbers)
6
7# reduce - 累积（需要从functools导入）
8from functools import reduce
9total = reduce(lambda x, y: x + y, numbers)

何时用Lambda vs普通函数：

  • Lambda：简单逻辑、一次性使用
  • 普通函数：复杂逻辑、需要复用、需要文档

回顾第18课：Lambda函数与高阶函数

3. 装饰器

核心概念

装饰器是修改函数行为的函数：

1# 装饰器本质
2@decorator
3def func():
4    pass
5
6# 等价于
7func = decorator(func)

装饰器模式

 1# 1. 简单装饰器
 2def log(func):
 3    def wrapper(*args, **kwargs):
 4        print(f"调用{func.__name__}")
 5        return func(*args, **kwargs)
 6    return wrapper
 7
 8# 2. 带参数的装饰器
 9def repeat(times):
10    def decorator(func):
11        def wrapper(*args, **kwargs):
12            for _ in range(times):
13                result = func(*args, **kwargs)
14            return result
15        return wrapper
16    return decorator
17
18# 3. 类装饰器
19class CountCalls:
20    def __init__(self, func):
21        self.func = func
22        self.count = 0
23    
24    def __call__(self, *args, **kwargs):
25        self.count += 1
26        return self.func(*args, **kwargs)
27
28# 4. functools.wraps保持元信息
29from functools import wraps
30
31def decorator(func):
32    @wraps(func)  # 保留原函数信息
33    def wrapper(*args, **kwargs):
34        return func(*args, **kwargs)
35    return wrapper

回顾第19课：装饰器入门（闭包、装饰器、实用示例）

4. 模块系统

模块基础

 1# 导入方式
 2import module
 3from module import function
 4import module as alias
 5from module import *  # 不推荐
 6
 7# __name__变量
 8if __name__ == "__main__":
 9    # 作为脚本运行时执行
10    main()

模块搜索路径

 1import sys
 2
 3# 搜索顺序
 4# 1. 当前目录
 5# 2. PYTHONPATH
 6# 3. 标准库
 7# 4. site-packages
 8
 9# 查看路径
10print(sys.path)
11
12#添加路径
13sys.path.append("/custom/path")

回顾第20课：模块基础（导入、搜索路径、标准库）

5. 包管理

包的概念

mypackage/
├── __init__.py  # 标识包
├── module1.py
├── module2.py
└── subpackage/
    ├── __init__.py
    └── module3.py

init.py的作用

 1# __init__.py
 2"""
 3包初始化文件的作用：
 41. 标识目录为包
 52. 执行包初始化代码
 63. 定义__all__
 74. 重新导出成员（简化导入）
 8"""
 9
10# 重新导出
11from .module1 import func1
12from .module2 import func2
13
14__all__ = ['func1', 'func2']

相对导入

1# 包内模块间导入
2from . import sibling_module      # 同级
3from .. import parent_module      # 上级
4from ..sibling import function    # 上级的兄弟包

回顾第21课：包（Package）（包结构、init.py、分发）

6. 生成器和迭代器

生成器

 1# 生成器函数
 2def countdown(n):
 3    while n > 0:
 4        yield n
 5        n -= 1
 6
 7# 生成器表达式
 8squares = (x**2 for x in range(10))
 9
10# 优势：惰性求值，内存高效

迭代器协议

 1class MyIterator:
 2    def __iter__(self):
 3        return self
 4    
 5    def __next__(self):
 6        # 返回下一个元素
 7        # 或抛出StopIteration
 8        pass
 9
10# for循环的实际工作原理
11iterator = iter(iterable)
12while True:
13    try:
14        item = next(iterator)
15        # 处理item
16    except StopIteration:
17        break

回顾第22课：生成器（yield、生成器表达式、管道）
回顾第23课：迭代器（协议、自定义迭代器）

7. 内置函数

常用内置函数分类

类型转换：

1int(), float(), str(), bool()
2list(), tuple(), dict(), set()

数学运算：

1abs(), round(), pow(), sum()
2min(), max(), divmod()

序列操作：

1len(), sorted(), reversed()
2zip(), enumerate()
3all(), any()
4map(), filter()

对象操作：

1type(), isinstance(), hasattr()
2getattr(), setattr(), delattr()
3id(), dir()

回顾第24课：内置函数深入

8. 文件操作

文件操作流程

 1# 基本流程
 2with open("file.txt", "r", encoding="utf-8") as f:
 3    content = f.read()
 4# 自动关闭
 5
 6# 文件模式
 7# 'r' - 读
 8# 'w' - 写（覆盖）
 9# 'a' - 追加
10# 'rb' - 二进制读

路径操作

 1# os模块
 2import os
 3os.path.exists("file.txt")
 4os.path.getsize("file.txt")
 5os.remove("file.txt")
 6
 7# pathlib(现代、推荐）
 8from pathlib import Path
 9path = Path("file.txt")
10if path.exists():
11    content = path.read_text(encoding="utf-8")

回顾第25课：文件操作基础（open、读写、编码、os/pathlib）

9. 异常处理

异常处理结构

 1try:
 2    # 可能出错的代码
 3    risky_operation()
 4except SpecificError as e:
 5    # 处理特定异常
 6    handle_error(e)
 7except (Error1, Error2):
 8    # 处理多种异常
 9    pass
10else:
11    # 没有异常时执行
12    success_handler()
13finally:
14    # 总是执行（清理）
15    cleanup()

自定义异常

1class CustomError(Exception):
2    """自定义异常类"""
3    def __init__(self, message, code=None):
4        super().__init__(message)
5        self.code = code

回顾第26课：异常处理（try-except-finally、异常类型、自定义异常）

10. 上下文管理器

with语句

 1# 上下文管理器协议
 2class Resource:
 3    def __enter__(self):
 4        # 获取资源
 5        return self
 6    
 7    def __exit__(self, exc_type, exc_value, traceback):
 8        # 释放资源
 9        cleanup()
10        return False  # 不抑制异常

@contextmanager装饰器

 1from contextlib import contextmanager
 2
 3@contextmanager
 4def managed_resource():
 5    # __enter__
 6    resource = acquire()
 7    try:
 8        yield resource
 9    finally:
10        # __exit__
11        release(resource)

回顾第27课：上下文管理器（with、contextlib、资源管理）

11. 单元测试

unittest框架

 1import unittest
 2
 3class TestMyCode(unittest.TestCase):
 4    def setUp(self):
 5        """测试前准备"""
 6        self.data = setup_data()
 7    
 8    def tearDown(self):
 9        """测试后清理"""
10        cleanup()
11    
12    def test_feature(self):
13        """测试用例"""
14        result = my_function()
15        self.assertEqual(result, expected)
16        self.assertTrue(condition)
17        
18        with self.assertRaises(ValueError):
19            error_function()
20
21if __name__ == "__main__":
22    unittest.main()

回顾第28课：单元测试基础（unittest、断言、Mock）

12. 知识体系脑图

函数与模块
│
├── 函数基础
│   ├── 定义与调用
│   ├── 参数（位置、默认、*args、**kwargs）
│   ├── 返回值
│   └── 作用域（LEGB）
│
├── 高级函数
│   ├── Lambda表达式
│   ├── 高阶函数（map、filter、reduce）
│   ├── 装饰器（函数装饰器、类装饰器）
│   └── 闭包
│
├── 模块与包
│   ├── 模块导入
│   ├── 包结构
│   ├── __init__.py
│   └── 相对/绝对导入
│
├── 迭代与生成
│   ├── 迭代器协议
│   ├── 生成器函数
│   ├── 生成器表达式
│   └── itertools
│
├── 内置功能
│   ├── 内置函数
│   ├  ── 类型转换
│   ├── 数学运算
│   └── 序列操作
│
├── 文件与I/O
│   ├── 文件操作
│   ├── 二进制文件
│   ├── 路径处理
│   └── 特殊格式（CSV、JSON）
│
├── 异常与资源
│   ├── 异常处理
│   ├── 自定义异常
│   ├── 上下文管理器
│   └── with语句
│
└── 测试
    ├── 单元测试
    ├── 断言方法
    ├── Mock
    └── 测试覆盖率

13. 最佳实践总结

  1. 函数设计

    • 单一职责
    • 参数不要太多（≤5个）
    • 使用类型提示（Type Hints）
    • 编写文档字符串

  2. 模块组织

    • 一个文件一个清晰的职责
    • init.py保持简洁
    • 使用相对导入（包内）

  3. 异常处理

    • 捕获具体异常
    • 不要忽略异常
    • 使用with管理资源

  4. 代码质量

    • 编写测试
    • 使用装饰器简化代码
    • 遵循PEP 8规范

14. 小结

第三部分我们学习了：

  • 函数：从基础到装饰器
  • 模块：代码组织和复用
  • 迭代：生成器和迭代器
  • 内置功能：强大的内置函数
  • 文件I/O：数据持久化
  • 异常：错误处理和资源管理
  • 测试：保证代码质量

这些是Python编程的核心技能，为后续学习面向对象编程打下坚实基础。

复习建议：

  1. 重新浏览第17-28课的代码示例
  2. 完成每课的练习题
  3. 尝试第30课的综合项目
  4. 阅读优秀开源项目的代码

本文代码示例：

关注公众号：极客老墨

更多 AI 应用开发、工程实践和效率工具分享，欢迎扫码关注。

极客老墨微信公众号二维码

相关阅读