学习笔记《编程不难》（5）——10月 Python 函数：一些应用
一、 Python 函数
1、几种函数类型
| 函数类型 | 表达式描述 | 函数作用 | 表达式 |
|---|---|---|---|
| 内置函数 | 函数名(参数) |
执行 Python 提供的基础操作（如 len(), max() 等） |
len([1, 2, 3]), max([1, 2, 3]) |
| 自定义函数 | def 函数名(参数): 函数体 |
用户自定义的函数，封装特定逻辑，便于复用 | def my_function(arg1, arg2): return arg1 + arg2 |
| 匿名函数（lambda） | lambda 参数: 表达式 |
定义简短的匿名函数，通常用于一次性或简单操作 | lambda x, y: x * y |
| 递归函数 | def 函数名(参数): return 函数名(参数 - 1) |
在函数内部调用自己，适合解决递归问题（如计算阶乘、斐波那契数列等） | def factorial(n): return n * factorial(n - 1) |
| 生成器函数 | def 函数名(参数): yield 值 |
使用 yield 返回一个生成器对象，按需生成值，节省内存 |
def count_up_to(max_value): yield count |
| 高阶函数 | def 函数名(函数参数, 其他参数): 函数体 |
接收函数作为参数或返回函数，用于实现函数式编程（如 map(), filter() 等） |
def apply_function(func, value): return func(value) |
| 装饰器函数 | @装饰器函数名 def 函数名(参数): 函数体 |
修改或增强其他函数的功能，常用于日志记录、权限控制、性能测量等 | @decorator def say_hello(): print("Hello!") |
| 静态方法和类方法 | @staticmethod 或 @classmethod def 方法名(参数): 方法体 |
@staticmethod 不依赖实例或类；@classmethod 操作类变量或构造类 |
@staticmethod def static_method():, @classmethod def class_method(cls): |
| 列表生成式 | [表达式 for 元素 in 可迭代对象] |
用简洁的方式生成列表，包含 for 循环和条件语句，适合对列表进行快速操作 |
[x**2 for x in range(5)] |
| 生成器表达式 | (表达式 for 元素 in 可迭代对象) |
类似列表生成式，但生成的是生成器对象，按需生成元素，节省内存 | (x**2 for x in range(5)) |
#1. 内置函数（Built-in Functions）
#这些是 Python 提供的现成的函数，直接使用即可。
#表达式：
print("Hello, World!") # 输出内置函数
len([1, 2, 3]) # 求长度
max([1, 2, 3]) # 求最大值
#2. 自定义函数（User-defined Functions）
#由用户使用 def 关键字定义的函数。
#表达式：
def my_function(arg1, arg2):
return arg1 + arg2
# 调用函数
result = my_function(5, 10)
#3. 匿名函数（Lambda Functions）
#使用 lambda 关键字定义的简短函数，适合用于简单的表达式。
#表达式：
# 定义一个 lambda 函数
multiply = lambda x, y: x * y
# 调用 lambda 函数
result = multiply(3, 4)
#4. 递归函数（Recursive Functions）
#在函数内部调用自己的函数，适用于分解问题的场景。
#表达式：
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1)
# 调用递归函数
result = factorial(5)
#5. 生成器函数（Generator Functions）
#使用 yield 关键字，按需生成元素的函数，通常用于节省内存。
#表达式：
def count_up_to(max_value):
count = 1
while count <= max_value:
yield count
count += 1
# 调用生成器函数
gen = count_up_to(5)
for value in gen:
print(value)
#6. 高阶函数（Higher-order Functions）
#可以接受其他函数作为参数，或返回一个函数的函数。
#表达式：
def apply_function(func, value):
return func(value)
# 使用 lambda 作为参数
result = apply_function(lambda x: x**2, 10)
#7. 装饰器函数（Decorator Functions）
#使用装饰器模式增强函数的功能，常用于权限验证、日志记录等场景。
#表达式：
def decorator(func):
def wrapper():
print("在函数调用前执行")
func()
print("在函数调用后执行")
return wrapper
@decorator
def say_hello():
print("Hello!")
# 调用装饰器函数
say_hello()
#8. 静态方法和类方法
#类方法使用 @classmethod，静态方法使用 @staticmethod。类方法操作类变量，静态方法不依赖类或实例。
#表达式：
class MyClass:
@staticmethod
def static_method():
print("This is a static method")
@classmethod
def class_method(cls):
print(f"Class method, class variable")
# 调用静态方法和类方法
MyClass.static_method()
MyClass.class_method()
#9. 生成器表达式和列表生成式
#简洁表达式用于生成列表或生成器。
#列表生成式表达式：
# 列表生成式
squares = [x**2 for x in range(5)]
#生成器表达式表达式：
# 生成器表达式
squares_gen = (x**2 for x in range(5))
```2、为什么需要自定义函数
| 优点 | 解释 | 示例代码 |
|---|---|---|
| 避免代码重复，提高代码复用性 | 自定义函数封装了可重用的逻辑，避免重复代码 | def greet(name): print(f"Hello, {name}!") |
| 提高代码的可读性和结构化 | 将复杂代码分解为小的函数，使代码更加直观、易读 | def calculate_mean(data): return sum(data) / len(data) |
| 减少错误，提高代码可靠性 | 函数封装复杂逻辑，确保调用时不易出错，且逻辑一致 | def apply_discount(price, discount=0.1): return price * (1-discount) |
| 便于测试和调试 | 可以对每个函数单独测试，确保其独立性和正确性 | assert add(2, 3) == 5 |
| 提高代码的可维护性 | 修改函数内部实现，不影响调用代码，便于维护和更新 | def calculate_area_of_rectangle(length, width): return length * width |
| 实现代码的抽象和解耦 | 将实现细节隐藏在函数内部，调用者只需关注如何使用函数 | def send_email(to, subject, message): print(f"Email sent to {to}") |
| 便于代码重构 | 通过封装函数，代码可以安全重构，改变函数实现逻辑不会影响调用处 | def process_data(data): return [x * 2 for x in data] |
3、包、模块、函数（Here）
| 概念 | 描述 | 作用 | 示例代码 |
|---|---|---|---|
| 包 | 一个包含多个模块的目录，通常带有 __init__.py 文件来标识它是一个包 |
用于组织和管理多个模块，适合大型项目的代码管理 |
|
| 模块 | 一个 Python 文件，包含函数、类和变量 | 封装特定的代码逻辑，使其可在不同项目中复用 | |
| 函数 | 一个可复用的代码块，接收输入并返回输出 | 将重复的代码封装起来，便于调用，提高代码的可复用性和清晰度 | |
1. 函数（Function）
函数是最基本的代码组织单元，用于封装可重用的代码片段。函数可以有输入参数，并返回结果。通过使用函数，可以避免重复代码，使程序更模块化、易读和可维护。
函数的特点：
• 接收参数（输入）
• 执行特定逻辑
• 返回结果（输出，非必须）
作用：
• 将重复的代码封装为一个单位，便于代码复用和维护。
• 可以通过传入不同的参数，执行不同的操作。
# 定义一个简单的函数
def add(a, b):
return a + b
# 调用函数
result = add(3, 5)
print(result) # 输出: 82. 模块（Module）
模块是一个包含多个函数、类、变量的 Python 文件，它可以被其他程序导入并使用。Python 模块的目的是将相关的代码逻辑组织在一起，方便管理和使用。
模块的特点：
• 每个 Python 文件（以 .py 结尾）都可以看作一个模块。
• 可以通过 import 语句将模块导入到其他程序中使用。
作用：
• 模块是组织代码的基本单位，用于将相关函数和变量组合在一起，形成一个功能单元。
• 可以帮助避免代码重复，方便代码的复用和管理。
示例：
假设有一个文件 math_utils.py，它是一个模块，包含以下代码：
# math_utils.py 模块
def add(a, b):
return a + b
def subtract(a, b):
return a - b在其他程序中，我们可以通过 import 语句导入并使用这个模块：
import math_utils
result_add = math_utils.add(3, 5)
result_subtract = math_utils.subtract(10, 4)
print(result_add) # 输出: 8
print(result_subtract) # 输出: 63. 包（Package）
包是一个包含多个模块的目录。它是模块的进一步组织形式，提供了一种层次结构来管理大型项目中的模块。
包本质上是一个目录，其中包含多个 Python 模块，以及一个 __init__.py 文件（这个文件可以为空，但它表明该目录是一个包）。
包的特点：
• 包是一个包含多个模块的目录，通常用于组织复杂的项目。
• 包目录中通常包含一个 __init__.py 文件，它可以为空，也可以初始化包中的代码。
• 可以通过 import 导入包中的模块或子模块。
作用：
• 包提供了一个组织大型项目的方式，可以将功能相近的模块组合在一起。
• 包允许使用模块层次结构，便于代码维护和扩展。
示例：
假设有一个包 my_package，其目录结构如下：
my_package/
__init__.py
math_utils.py
string_utils.py• __init__.py 文件可以为空。
• math_utils.py 模块包含数学运算函数。
• string_utils.py 模块包含字符串处理函数。
可以在程序中导入并使用包中的模块：
from my_package import math_utils
from my_package import string_utils
result_add = math_utils.add(3, 5)
result_upper = string_utils.to_upper("hello")
print(result_add) # 输出: 8
print(result_upper) # 输出: HELLO4、调包
（1）主程序的位置(主程序、模块)
同一目录
如果你的 main.py 和 math_utils.py 文件在同一个目录中，导入模块时无需额外设置路径，直接使用 import math_utils 即可。
目录结构示例：
project_directory/
├── math_utils.py # 你的模块文件
└── main.py # 你的主程序文件
在这种情况下，你的 main.py 可以直接导入 math_utils.py 中的函数，如下所示：
main.py 示例：
# main.py
# 导入 math_utils 模块
import math_utils
# 调用 add 函数
result = math_utils.add(3, 5)
print(f"加法结果: {result}") # 输出: 加法结果: 8
math_utils.py 示例：
# math_utils.py
def add(a, b):
return a + b
运行：
你可以在终端或命令行中，进入 project_directory/，然后执行 main.py：
python main.py
主程序--子目录，模块--父目录
如果你的主程序（main.py）位于一个子目录中，而模块（math_utils.py）位于上一级目录，你需要使用相对路径导入模块。
目录结构示例：
project_directory/
├── math_utils.py # 你的模块文件
└── sub_directory/
└── main.py # 你的主程序文件
在这种情况下，你可以使用相对导入来导入 math_utils 模块。
main.py 示例：
# main.py
# 从上一级目录导入 math_utils 模块
import sys
sys.path.append('..') # 将上一级目录添加到系统路径
import math_utils
result = math_utils.add(10, 20)
print(f"加法结果: {result}") # 输出: 加法结果: 30
运行：
在终端或命令行中，进入 sub_directory/，然后运行 main.py：
python main.py
主程序和模块分别--不同的目录
如果你的 main.py 和 math_utils.py 在完全不同的目录中，你可以通过修改 PYTHONPATH 环境变量来告诉 Python 如何找到模块，或者使用绝对路径导入。
目录结构示例：
project_directory/
├── utils/
│ └── math_utils.py # 你的模块文件
└── main_program/
└── main.py # 你的主程序文件
在这种情况下，你需要将 utils/ 目录添加到 Python 的模块搜索路径中：
main.py 示例：
# main.py
# 添加 utils 目录到系统路径
import sys
sys.path.append('../utils') # 添加 utils 文件夹路径
import math_utils
result = math_utils.add(15, 25)
print(f"加法结果: {result}") # 输出: 加法结果: 40
运行：
在终端中，进入 main_program/ 目录，然后执行：
python main.py
总结：
1. 主程序位置：main.py 可以与模块 math_utils.py 位于同一目录，或在子目录中，或者完全在不同目录。具体位置会影响模块的导入方式。
2. 导入模块：根据主程序与模块的相对位置，可以直接导入、使用相对路径或修改系统路径导入模块。
3. 运行：确保在正确的目录下运行主程序，使用 python main.py 执行程序。
（2）主程序怎么调用包和模块
假设结构：
project_directory/
├── math_utils.py # 这是一个模块
└── main.py # 这是主程序math_utils.py（模块）：
# math_utils.py
def add(a, b):
return a + b
def subtract(a, b):
return a - bmain.py（主程序）：
# main.py
import math_utils # 导入 math_utils 模块
result_add = math_utils.add(5, 3)
result_subtract = math_utils.subtract(10, 7)
print(f"加法结果: {result_add}") # 输出: 加法结果: 8
print(f"减法结果: {result_subtract}") # 输出: 减法结果: 3如何运行：
1. 确保 main.py 和 math_utils.py 在同一个目录下。
在终端或命令提示符中，导航到包含 main.py 和 math_utils.py 文件的目录。例如：
cd path/to/project_directory2. 在终端中进入 project_directory/，然后执行：
python main.py将在控制台看到的结果：
加法结果: 8
减法结果: 3主程序如何判断你调用的是 math_utils.add(5, 3)？
你可以通过以下几种方式知道你调用的是 math_utils.add() 中的 add 函数。我们主要从代码结构、命名规范、函数定义和调试工具的角度来判断你调用的是 add 函数。
1. 通过代码结构判断
首先，在 math_utils.py 文件中，你定义了一个函数 add，它的代码结构是这样的：
# math_utils.py
def add(a, b):
return a + b这个定义明确了 add 是一个函数，它接收两个参数 a 和 b，并返回它们的和。你在 main.py 文件中通过以下代码调用了这个函数：
# main.py
import math_utils
result_add = math_utils.add(5, 3)根据这一行代码，math_utils.add(5, 3) 由 math_utils 模块和 add 函数组成。
模块名 math_utils 和函数名 add 让你清楚地知道调用的是 math_utils 模块中的 add 函数。
2. 通过命名规范判断
• 模块名 math_utils：通过 import math_utils 导入的模块，告诉你所有的函数和变量都来自这个模块。
• 函数名 add：你在 math_utils.py 中定义了 add() 函数，因此在主程序 main.py 中调用 math_utils.add() 时，add 代表你定义的函数。
所以，可以根据模块名和函数名组合，直接判断 add 函数是由你自己定义的，并且是在 math_utils 模块中。
3. 通过函数定义判断
可以查看模块 math_utils.py 中是否有一个叫做 add 的函数：
# math_utils.py
def add(a, b):
return a + b这段代码清楚地定义了 add 函数。
如果在 main.py 中调用了 math_utils.add()，那么你可以通过查看 math_utils.py 文件的定义，确认你调用的函数名为 add。
4. 通过调试或打印语句
如果不确定自己调用的是哪个函数，可以通过添加调试或打印语句来确认。
可以在 add() 函数中添加一个 print 语句，以确认该函数在运行时被调用了。
在 math_utils.py 中修改 add 函数：
def add(a, b):
print(f"add() 被调用了，参数是 {a} 和 {b}")
return a + b运行 main.py：
import math_utils
result_add = math_utils.add(5, 3)
print(f"加法结果: {result_add}")当你运行 main.py 时，输出结果将会是：
add() 被调用了，参数是 5 和 3
加法结果: 8通过这样的打印输出，可以确认你调用的是 math_utils.py 中的 add 函数。
5. 使用调试工具
还可以使用 Python 的调试工具（如 pdb 调试器）来逐步执行代码，查看你调用的函数是否是 add() 函数。
在 main.py 中添加调试：
import pdb; pdb.set_trace() # 在这里插入调试断点
import math_utils
result_add = math_utils.add(5, 3)
print(f"加法结果: {result_add}")
运行 main.py 时，程序会进入调试模式。
可以逐步执行代码并查看当前函数调用的情况，确保 math_utils.add() 是调用的函数。
6. 查看错误提示
如果你调用了不存在的函数或者拼写错误，Python 会给出相应的错误提示。例如，如果你试图调用一个不存在的 add 函数，你会得到类似这样的错误提示：
AttributeError: module 'math_utils' has no attribute 'add'这表示 math_utils 模块中没有 add 函数，帮助你确认是否正确调用了函数。
7. 通过 IDE 的自动补全功能
现代的编程编辑器或集成开发环境（IDE）通常具有自动补全功能。
当在编辑器中输入 math_utils. 时，编辑器会自动显示该模块中的可用函数列表。
如果看到 add 出现在列表中，说明可以调用这个函数。
总结
1. 查看代码结构：math_utils.add(5, 3) 中，math_utils 是模块名，add 是函数名。
2. 查看函数定义：在 math_utils.py 中定义了 add 函数，你可以确认它存在。
3. 使用调试或打印语句：通过在函数中添加打印语句，确认调用的确实是 add 函数。
4. 使用调试工具：通过 Python 调试器 pdb，可以逐步执行代码，确认函数调用。
5. IDE 的自动补全功能：许多 IDE 提供自动补全，可以帮助你确认是否有 add 函数可调用。
4、数学函数和单射、满射
5、一元、二元、三元、多元
6、数学函数 vs 编程函数
二、自定义函数（“Just knowing the definition is enough.”）
无输入、无返回
多个输入、单一返回
部分输入有默认值
全局变量 vs 局部变量
将矩阵乘法打包成一个函数
使用 raise 语句：中断流程，引发异常
使用 assert 语句：插入断言，检查条件
帮助文档：三个单引号（'''）或三个双引号（"""）来表示 docstring，
import numpy as np # 导入 NumPy，用于矩阵运算
# 二、自定义函数（“Just knowing the definition is enough.”）
# 1. 无输入、无返回
def simple_message():
"""打印简单的消息。"""
print("Just knowing the definition is enough.") # 打印消息
# 调用函数
simple_message()
# 输出结果:
# Just knowing the definition is enough.
# 2. 多个输入、单一返回
def matrix_multiply(A, B):
"""执行矩阵乘法。"""
if len(A[0]) != len(B): # 检查矩阵是否可以相乘（A的列数应等于B的行数）
raise ValueError("矩阵维度不匹配，无法相乘")
result = np.dot(A, B) # 使用 NumPy 进行矩阵乘法
return result # 返回结果矩阵
# 示例矩阵
A = [[1, 2], [3, 4]] # 2x2 矩阵
B = [[2, 0], [1, 3]] # 2x2 矩阵
# 调用矩阵乘法函数
C = matrix_multiply(A, B)
print("矩阵乘法结果:", C)
# 输出结果:
# 矩阵乘法结果: [[4, 6], [10, 12]]
# 3. 部分输入有默认值
def add_numbers(a, b=5):
"""将两个数字相加，第二个数字有默认值为5。"""
return a + b # 返回相加的结果
# 调用时指定两个参数
print(add_numbers(10, 20)) # 输出 30
# 只指定一个参数，b 默认为 5
print(add_numbers(10)) # 输出 15
# 4. 全局变量 vs 局部变量
x = 10 # 定义一个全局变量 x
def modify_variable():
"""演示局部变量与全局变量的区别。"""
global x # 使用 global 声明全局变量
x = 20 # 修改全局变量的值
y = 30 # 局部变量 y
return y # 返回局部变量 y
# 调用函数并查看修改后的全局变量和局部变量
y_value = modify_variable()
print("局部变量 y:", y_value) # 输出 30
print("修改后的全局变量 x:", x) # 输出 20
# 5. 将矩阵乘法打包成一个函数
def matrix_multiplication(A, B):
"""执行矩阵乘法并返回结果。"""
try:
result = np.dot(A, B) # 尝试执行矩阵乘法
return result
except Exception as e:
raise ValueError(f"矩阵乘法失败: {e}") # 如果出错，抛出异常
# 使用相同的矩阵 A 和 B 进行乘法
result = matrix_multiplication(A, B)
print("打包矩阵乘法的结果:", result)
# 输出结果:
# 打包矩阵乘法的结果: [[4 6], [10 12]]
# 6. 使用 raise 语句：中断流程，引发异常
def divide(a, b):
"""简单的除法函数，如果除数为零则抛出异常。"""
if b == 0:
raise ZeroDivisionError("除数不能为0") # 当除数为 0 时，抛出异常
return a / b # 返回相除的结果
# 正常除法调用
print("10 / 2 =", divide(10, 2)) # 输出 5.0
# 调用导致异常
# divide(10, 0) # 将会抛出 ZeroDivisionError: 除数不能为0
# 7. 使用 assert 语句：插入断言，检查条件
def check_positive(x):
"""检查一个数是否为正数，如果不是则中断程序。"""
assert x > 0, "输入必须为正数" # 如果条件为假，抛出 AssertionError
return True
# 检查正数
print(check_positive(5)) # 输出 True
# check_positive(-3) # 这会导致 AssertionError: 输入必须为正数
# 帮助文档
def help_function():
"""这是一个帮助文档的示例，解释函数功能。"""
return "帮助文档可以通过 __doc__ 属性访问。"
# 访问帮助文档
print(help_function.__doc__)
# 输出:
# 这是一个帮助文档的示例，解释函数功能。三、更多自定义线性代数函数 （“Just knowing the definition is enough.”）
1. 计算方阵的迹：通过一层 for 循环遍历对角线元素，计算它们的和。
2.一层for循环
（1） 产生全 0 矩阵：通过列表生成式生成全 0 的矩阵。
（2）产生单位矩阵：通过列表生成式生成一个对角线为 1 的矩阵。
（3）产生对角方阵：通过列表生成式生成一个对角元素为指定值的矩阵。
（4）提取对角线元素：通过遍历矩阵的对角线位置提取元素。
3. 判断矩阵是否对称：使用两层 for 循环比较矩阵的对称元素。
4. 矩阵行列式：使用 numpy 提供的函数计算行列式。
5. 矩阵逆：使用 numpy 计算矩阵的逆，如果行列式为 0，矩阵不可逆。
# 三、更多自定义线性代数函数（“Just knowing the definition is enough.”）
# 1. 一层 for 循环产生全 0 矩阵、单位矩阵、对角方阵、提取对角线元素
def zero_matrix(n):
"""生成 n x n 的全零矩阵。"""
return [[0 for _ in range(n)] for _ in range(n)] # 生成 n x n 的全 0 矩阵
print("3x3 零矩阵:")
print(zero_matrix(3))
# 输出:
# [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
def identity_matrix(n):
"""生成 n x n 的单位矩阵。"""
return [[1 if i == j else 0 for j in range(n)] for i in range(n)] # 生成 n x n 单位矩阵
print("3x3 单位矩阵:")
print(identity_matrix(3))
# 输出:
# [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
def diagonal_matrix(diag_elements):
"""生成对角矩阵。"""
n = len(diag_elements)
return [[diag_elements[i] if i == j else 0 for j in range(n)] for i in range(n)] # 生成对角矩阵
diag = [1, 2, 3]
print("对角矩阵:")
print(diagonal_matrix(diag))
# 输出:
# [[1, 0, 0], [0, 2, 0], [0, 0, 3]]
def extract_diagonal(matrix):
"""提取矩阵的对角线元素。"""
return [matrix[i][i] for i in range(len(matrix))] # 提取对角线元素
matrix_example = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print("对角线元素:", extract_diagonal(matrix_example))
# 输出:
# 对角线元素: [1, 5, 9]
# 2. 计算方阵迹
def trace(matrix):
"""计算方阵的迹。"""
return sum(matrix[i][i] for i in range(len(matrix))) # 计算矩阵对角线元素的和
print("矩阵迹:", trace(matrix_example))
# 输出:
# 矩阵迹: 15
# 3. 判断矩阵是否对称
def is_symmetric(matrix):
"""判断矩阵是否对称。"""
n = len(matrix)
for i in range(n):
for j in range(n):
if matrix[i][j] != matrix[j][i]: # 检查元素 matrix[i][j] 是否等于 matrix[j][i]
return False
return True
symmetric_matrix = [[1, 2, 3], [2, 4, 5], [3, 5, 6]]
print("对称矩阵检查:", is_symmetric(symmetric_matrix))
# 输出:
# 对称矩阵检查: True
# 4. 计算行列式
def determinant(matrix):
"""计算矩阵的行列式。"""
return np.linalg.det(matrix) # 使用 NumPy 计算行列式
print("行列式:", determinant(symmetric_matrix))
# 输出: 行列式: 0.0
# 5. 计算矩阵的逆
def inverse(matrix):
"""计算矩阵的逆。"""
return np.linalg.inv(matrix) # 使用 NumPy 计算逆矩阵
invertible_matrix = [[4, 7], [2, 6]]
print("矩阵的逆:")
print(inverse(invertible_matrix))
# 输出:
# [[ 0.6 -0.7]
# [-0.2 0.4]]四、函数参数
1. 递归函数：函数反复调用自己，必须有终止条件。
2. 位置参数、关键字参数：位置参数按顺序传递，关键字参数通过 key=value 形式传递。
3. *args 和 **kwargs：用于传递不定数量的参数，分别处理位置参数和关键字参数。
4. 匿名函数：用 lambda 定义简短的、无名函数，常用于高阶函数中。
5. 构造模块和库：通过创建 .py 文件构建模块，组织和管理函数与类。库是模块的集合。
6. 模仿学习：通过分析和模仿他人代码，学习编程技巧并逐步改进。
#函数参数
# 1、递归函数：自己反复调用自己
def factorial(n):
"""递归计算阶乘。"""
if n == 0:
return 1
else:
return n * factorial(n - 1) # 递归调用自己
print("5 的阶乘:", factorial(5))
# 输出: 5 的阶乘: 120
# 2、位置参数、关键字参数
def greet(name, msg="Hello"):
"""演示位置参数和关键字参数的使用。"""
return f"{msg}, {name}!"
print(greet("Alice")) # 使用默认的 msg 参数，输出: Hello, Alice!
print(greet("Bob", "Hi")) # 使用自定义的 msg 参数，输出: Hi, Bob!
# 3、使用 *args 和 **kwargs
def sum_all(*args):
"""使用 *args 传递任意数量的参数。"""
return sum(args) # 对所有传递的参数进行求和
print("求和:", sum_all(1, 2, 3, 4))
# 输出: 求和: 10
def print_key_values(**kwargs):
"""使用 **kwargs 传递任意数量的键值对。"""
for key, value in kwargs.items(): # 遍历键值对
print(f"{key}: {value}")
print_key_values(name="Alice", age=25, city="New York")
# 输出:
# name: Alice
# age: 25
# city: New York
# 4、匿名函数（Lambda）
multiply = lambda x, y: x * y # 使用 lambda 函数定义乘法操作
print("Lambda 乘法结果:", multiply(3, 4))
# 输出: Lambda 乘法结果: 12
# 5、构造模块、库
# 在 Python 中，你可以将这些自定义函数存放在一个 .py 文件中，形成一个模块，然后在其他文件中导入这个模块并使用这些函数。