Python基础入门掌握（九）
函数的注释
第一部分：介绍
在Python中，注释主要用于解释代码的功能或目的，不会被解释器执行。注释有两种主要形式：
单行注释：使用#符号。
多行注释：虽然Python没有专门的多行注释语法，但可以通过连续的单行注释或包含在三重引号中的字符串（通常用于文档字符串）实现。
文档字符串（docstring）是特殊的注释，通常用三重双引号"""..."""包围，位于函数定义的第一行。它们不仅提供函数的描述，还可以包括参数、返回值等详细信息。
基本语法如下：
def function_name(parameters):
"""
文档字符串
参数:
parameter1 (type): 描述
parameter2 (type): 描述
返回:
type: 描述
"""
# 函数体
return result
第二部分：使用场景与示例
示例 1: 基本函数注释
def add_numbers(a, b):
"""
计算两个数字的和
参数:
a (int or float): 第一个数字
b (int or float): 第二个数字
返回:
int or float: 两数之和
"""
return a + b
print("两数之和:", add_numbers(3, 5))
使用场景: 提供函数的基本功能说明，帮助其他开发者快速了解函数用途。
示例 2: 单行注释
def calculate_area(radius):
# 计算圆的面积
import math
return math.pi * radius ** 2
print("圆的面积:", calculate_area(4))
使用场景: 对代码片段进行简短说明，适用于简单操作或逻辑。
示例 3: 多行注释
def process_data(data):
"""
处理数据集
步骤:
1. 清洗数据
2. 分析数据
3. 输出结果
"""
cleaned_data = [x for x in data if x is not None] # 清洗数据
analysis_result = sum(cleaned_data) / len(cleaned_data) # 分析数据
print("分析结果:", analysis_result) # 输出结果
process_data([10, 20, None, 30])
使用场景: 对复杂函数的步骤或流程进行详细说明，帮助理解整体逻辑。
示例 4: 参数和返回值说明
def find_max(numbers):
"""
找出列表中的最大值
参数:
numbers (list of int or float): 数字列表
返回:
int or float: 列表中的最大值
"""
return max(numbers)
print("最大值:", find_max([1, 3, 5, 7]))
使用场景: 明确函数接受的参数类型和返回值类型，提高代码的健壮性。
示例 5: 使用条件语句的注释
def check_even_or_odd(number):
"""
检查数字是偶数还是奇数
参数:
number (int): 待检查的数字
返回:
str: '偶数' 或 '奇数'
"""
if number % 2 == 0:
return "偶数" # 如果数字能被2整除，则为偶数
else:
return "奇数" # 否则为奇数
print("检查结果:", check_even_or_odd(8))
使用场景: 解释条件判断逻辑，帮助理解分支处理过程。
示例 6: 使用循环的注释
def sum_of_squares(n):
"""
计算前n个自然数的平方和
参数:
n (int): 自然数的数量
返回:
int: 平方和
"""
total = 0
for i in range(1, n + 1):
total += i ** 2 # 累加每个数字的平方
return total
print("平方和:", sum_of_squares(5))
使用场景: 解释循环内部的操作，便于理解计算过程。
示例 7: 使用异常处理的注释
def divide_numbers(a, b):
"""
安全地除以两个数
参数:
a (int or float): 被除数
b (int or float): 除数
返回:
float: 商
抛出:
ValueError: 当除数为零时
"""
try:
return a / b # 尝试进行除法运算
except ZeroDivisionError:
raise ValueError("除数不能为零") # 捕获并抛出异常
try:
print("商:", divide_numbers(10, 2))
except ValueError as e:
print(e)
使用场景: 解释异常处理逻辑，确保代码的健壮性。
示例 8: 使用默认参数的注释
def greet_user(name="访客"):
"""
欢迎用户
参数:
name (str): 用户名，默认为'访客'
"""
print(f"欢迎你, {name}!")
greet_user()
greet_user("张三")
使用场景: 解释默认参数的作用，方便调用者了解函数的行为。
示例 9: 使用*args和**kwargs的注释
def concatenate_strings(*args, separator=", "):
"""
连接多个字符串
参数:
*args (str): 需要连接的字符串
separator (str): 字符串之间的分隔符，默认为', '
返回:
str: 连接后的字符串
"""
return separator.join(args)
print("连接后的字符串:", concatenate_strings("苹果", "香蕉", "橙子"))
使用场景: 解释变长参数的使用方法，增强函数的灵活性。
示例 10: 使用文档字符串查看帮助
def calculate_factorial(n):
"""
计算阶乘
参数:
n (int): 非负整数
返回:
int: n的阶乘
"""
if n == 0:
return 1
else:
return n * calculate_factorial(n - 1)
help(calculate_factorial)
print("阶乘:", calculate_factorial(5))
使用场景: 通过help()函数查看文档字符串，帮助理解函数的功能和使用方法。
探索函数嵌套的奥秘
文章目录
函数嵌套的基本概念
函数嵌套的适用场景
代码示例与解析
函数嵌套的注意事项
总结
1. 函数嵌套的基本概念
函数嵌套是指在一个函数的内部定义另一个函数。被嵌套的函数通常被称为内部函数，而包含它的函数被称为外部函数。内部函数可以访问外部函数的变量，但外部函数无法访问内部函数的变量。这种特性使得函数嵌套在封装和隐藏实现细节方面非常有用。
def outer_function():print("这是外部函数")def inner_function():print("这是内部函数")inner_function()outer_function()
输出：
这是外部函数
这是内部函数
2. 函数嵌套的适用场景
函数嵌套在以下几种场景中特别有用：
封装隐藏实现细节：将一些复杂的逻辑封装在内部函数中，外部函数只暴露必要的接口。
减少代码重复：在多个地方需要执行相似逻辑时，可以将逻辑封装在内部函数中。
实现装饰器：装饰器本质上是函数嵌套的一种高级应用，用于在不修改原函数的情况下扩展功能。
3. 代码示例与解析
示例1：封装隐藏实现细节
假设我们需要一个函数来计算一个数的平方和立方，但不希望暴露平方和立方的具体实现。
def calculate_operations(num):def square(x):return x ** 2def cube(x):return x ** 3return square(num), cube(num)result = calculate_operations(3)print(f"平方: {result[0]}, 立方: {result[1]}")
输出：
平方: 9, 立方: 27
解析：
通过将square和cube定义为内部函数，我们隐藏了它们的实现细节，只通过calculate_operations函数暴露接口。
示例2：减少代码重复
假设我们需要在多个地方打印一个格式化的消息，但不想重复写代码。
def print_message():def format_message():return "欢迎学习Python函数嵌套！"print(format_message())print_message()print_message()
输出：
欢迎学习Python函数嵌套！
欢迎学习Python函数嵌套！
解析：
format_message作为内部函数，避免了重复编写格式化逻辑。
示例3：实现装饰器
装饰器是函数嵌套的高级应用，用于在不修改原函数的情况下扩展功能。
def my_decorator(func):def wrapper():print("在函数执行前添加一些逻辑")func()print("在函数执行后添加一些逻辑")return wrapper@my_decoratordef say_hello():print("Hello!")say_hello()
输出：
在函数执行前添加一些逻辑
Hello!
在函数执行后添加一些逻辑
解析：
my_decorator是一个装饰器，wrapper是内部函数，用于在原函数say_hello的基础上添加额外逻辑。
示例4：内部函数访问外部变量
内部函数可以访问外部函数的变量，但不能修改不可变类型变量。
def outer():x = 10def inner():print(f"内部函数访问外部变量 x = {x}")inner()outer()
输出：
内部函数访问外部变量 x = 10
解析：
内部函数inner可以访问外部函数outer的变量x。
示例5：修改外部变量（可变类型）
如果外部变量是可变类型（如列表），内部函数可以修改它。
def outer():data = [1, 2, 3]def inner():data.append(4)print(f"内部函数修改后，data = {data}")inner()print(f"外部函数中，data = {data}")outer()
输出：
内部函数修改后，data = [1, 2, 3, 4]
外部函数中，data = [1, 2, 3, 4]
解析：
内部函数inner修改了外部函数outer的列表变量data。
示例6：闭包的应用
闭包是指内部函数引用了外部函数的变量，并返回内部函数。
def outer(x):def inner():print(f"闭包中引用的外部变量 x = {x}")return innerclosure = outer(5)closure()
输出：
闭包中引用的外部变量 x = 5
解析：
闭包closure引用了外部函数outer的变量x，即使outer已经执行完毕。
示例7：嵌套函数的递归调用
嵌套函数也可以实现递归调用。
def outer(n):def inner(n):if n == 0:return 1else:return n * inner(n - 1)return inner(n)result = outer(5)print(f"5的阶乘是: {result}")
输出：
5的阶乘是: 120
解析：
内部函数inner实现了阶乘的递归计算。
示例8：嵌套函数的参数传递
嵌套函数可以接受外部函数传递的参数。
def outer(a, b):def inner(x):return a * x + breturn innerlinear_function = outer(2, 3)print(f"当 x = 4 时，线性函数的值为: {linear_function(4)}")
输出：
当 x = 4 时，线性函数的值为: 11
解析：
内部函数inner接收外部函数outer的参数a和b，并返回一个线性函数。
示例9：嵌套函数的嵌套调用
嵌套函数可以进一步嵌套调用。
def outer():def middle():def inner():print("这是最内层的函数")inner()middle()outer()
输出：
这是最内层的函数
解析：
outer调用middle，middle调用inner，展示了嵌套函数的嵌套调用。
示例10：嵌套函数的动态生成
嵌套函数可以根据外部函数的参数动态生成不同的行为。
def outer(operation):def inner(x, y):if operation == "add":return x + yelif operation == "subtract":return x - yreturn inneradd_function = outer("add")subtract_function = outer("subtract")print(f"加法结果: {add_function(10, 5)}")print(f"减法结果: {subtract_function(10, 5)}")
输出：
加法结果: 15
减法结果: 5
解析：
外部函数outer根据参数operation动态生成不同的内部函数行为。
4. 函数嵌套的注意事项
变量作用域：内部函数可以访问外部函数的变量，但不能直接修改不可变类型变量。
闭包特性：闭包会捕获外部函数的变量，但要注意变量的生命周期。
嵌套深度：过多的嵌套会增加代码复杂性，应适度使用。