DAY26 函数定义与参数

浙大疏锦行-CSDN博客
知识点回顾：
1.函数的定义
2.变量作用域：局部变量和全局变量
3.函数的参数类型：位置参数、默认参数、不定参数
4.传递参数的手段：关键词参数
5.传递参数的顺序：同时出现三种参数类型时

1. 函数的定义：

   • 使用 def 关键字来定义函数。
   • 函数名后面跟着圆括号 ()，可以包含参数。
   • 函数体以冒号 : 开始，并且需要缩进。
   • 可以使用 return 语句从函数中返回值。

2. 变量作用域：局部变量和全局变量：

   • 局部变量 (Local Variables)：在函数内部定义的变量，只能在函数内部访问。
   • 全局变量 (Global Variables)：在函数外部定义的变量，可以在程序的任何地方访问（在函数内部如果需要修改全局变量，需要使用 global 关键字）。

3. 函数的参数类型：

   • 位置参数 (Positional Arguments)：调用函数时，根据参数的位置顺序传递值。
   • 默认参数 (Default Arguments)：定义函数时，可以为参数指定默认值。如果在调用函数时没有为该参数提供值，则使用默认值。
   • 不定参数 (Arbitrary Arguments)：
     • *args：用于接收任意数量的位置参数，这些参数在函数内部会被收集为一个元组 (tuple)。
     • **kwargs：用于接收任意数量的关键字参数，这些参数在函数内部会被收集为一个字典 (dictionary)。

4. 传递参数的手段：关键词参数 (Keyword Arguments)：

   • 调用函数时，可以通过 参数名=值 的形式指定参数的值，这样可以不用考虑参数的顺序。

5. 传递参数的顺序：同时出现三种参数类型时：

   • 当一个函数同时包含位置参数、*args 和 **kwargs 时，它们的顺序通常是：标准位置参数，然后是 *args，最后是 **kwargs。
   • 默认参数应该在普通位置参数之后，*args 之前。

作业：
题目1：计算圆的面积
●任务： 编写一个名为 calculate_circle_area 的函数，该函数接收圆的半径 radius 作为参数，并返回圆的面积。圆的面积 = π * radius² (可以使用 math.pi 作为 π 的值)
●要求：函数接收一个位置参数 radius。计算半径为5、0、-1时候的面积
●注意点：可以采取try-except 使函数变得更加稳健，如果传入的半径为负数，函数应该返回 0 (或者可以考虑引发一个ValueError，但为了简单起见，先返回0)。

import mathdef calculate_circle_area(radius):"""计算圆的面积。参数:radius (float or int): 圆的半径。返回:float: 圆的面积。如果半径为负数或发生其他错误，则返回 0。"""# 这是一个 `try...except` 代码块。它的主要作用是尝试执行一段代码（`try` 部分），# 如果在执行过程中发生了错误（也叫“异常”），那么程序不会直接崩溃，# 而是会跳转到 `except` 部分去处理这个错误。这让我们的程序更加健壮。try:# --- 检查半径是否是数字类型 ---# `isinstance()` 是一个内置函数，用来检查一个对象（这里是 `radius`）是否是指定类型（这里是 `int` 或 `float`）的实例。# `int` 代表整数 (e.g., 5, 0, -1)# `float` 代表浮点数 (e.g., 2.5, 3.14)# `not isinstance(radius, (int, float))` 的意思是：如果 `radius` *不是* 一个整数 *也不是* 一个浮点数，那么...if not isinstance(radius, (int, float)):# `raise TypeError(...)` 这行代码会主动引发一个“类型错误”（TypeError）。# 当我们检测到传入的 `radius` 不是我们期望的数字类型时，# 我们就告诉 Python：“这里发生了一个类型错误，错误信息是'半径必须是一个数字。'”# 这样做的好处是，我们可以明确地指出错误的原因。raise TypeError("半径必须是一个数字。")# --- 检查半径是否为负数 ---# 这是一个简单的 `if` 条件判断语句。# `radius < 0` 的意思是：如果 `radius` 的值小于 0（即为负数），那么...if radius < 0:# `print(f"...")` 这是一种叫做 f-string (格式化字符串字面值) 的打印方式。# 它允许我们在字符串中直接嵌入变量的值。# `f"警告：半径 {radius} 是负数，面积将返回 0。"` 会把 `radius` 变量的实际值替换到 `{radius}` 的位置。# 例如，如果 `radius` 是 -1，它会打印出："警告：半径 -1 是负数，面积将返回 0。"print(f"警告：半径 {radius} 是负数，面积将返回 0。")# `return 0` 语句会立即结束当前函数的执行，并把 0 作为函数的结果返回给调用者。# 根据题目要求，如果半径为负数，函数应该返回 0。return 0# --- 计算面积 ---# 如果代码执行到这里，说明 `radius` 是一个有效的非负数字。# `math.pi` 是 Python `math` 模块中预定义的圆周率 π (约等于 3.14159)。# `radius ** 2` 表示 `radius` 的平方 (radius * radius)。# 所以 `area = math.pi * (radius ** 2)` 就是在执行圆面积的计算公式：π * r²。# 计算结果会被存储在名为 `area` 的变量中。area = math.pi * (radius ** 2)# `return area` 语句会结束函数的执行，并将计算得到的 `area` 值返回给调用者。return area# --- 错误处理部分 ---# 如果在上面的 `try` 代码块中，`raise TypeError(...)` 被执行了，# 或者发生了其他类型的 `TypeError`，程序会跳转到这里。except TypeError as te:# `TypeError as te` 的意思是：捕获“类型错误”，并将这个错误对象赋值给变量 `te`。# 这样我们就可以在 `print` 语句中使用 `te` 来显示具体的错误信息。print(f"类型错误: {te}")# 同样，根据题目要求或为了程序的健壮性，发生错误时返回 0。return 0# `except Exception as e:` 这是一个更通用的错误捕获。# `Exception` 是几乎所有内置错误的基类。# 如果 `try` 代码块中发生了除了 `TypeError` 之外的其他任何类型的错误（比如我们没预料到的错误），# 这个 `except` 块就会被执行。except Exception as e: # 捕获其他可能的意外错误# `Exception as e` 的意思是：捕获任何类型的“异常”，并将这个异常对象赋值给变量 `e`。print(f"计算面积时发生错误: {e}")# 发生未知错误时，也返回 0，确保函数总有一个返回值。return 0# ---- 测试函数 ----# 包含一个无效输入的测试列表
radii_to_test = [5, 0, -1, "hello", 2.5]print("--- 开始测试 calculate_circle_area 函数 ---")
for r_val in radii_to_test:print(f"\n测试半径: {r_val}")calculated_area = calculate_circle_area(r_val)# 打印结果，并保留两位小数print(f"计算得到的面积: {calculated_area:.2f}" if isinstance(calculated_area, (int, float)) else f"计算得到的面积: {calculated_area}")print("-" * 30)# 题目要求的具体测试用例
print("\n--- 题目要求的特定测试用例 ---")radius_case_1 = 5
area_case_1 = calculate_circle_area(radius_case_1)
print(f"半径为 {radius_case_1} 的圆的面积是: {area_case_1:.2f}")radius_case_2 = 0
area_case_2 = calculate_circle_area(radius_case_2)
print(f"半径为 {radius_case_2} 的圆的面积是: {area_case_2:.2f}")radius_case_3 = -1
area_case_3 = calculate_circle_area(radius_case_3)
print(f"半径为 {radius_case_3} 的圆的面积是: {area_case_3:.2f}")

题目2：计算矩形的面积
●任务： 编写一个名为 calculate_rectangle_area 的函数，该函数接收矩形的长度 length 和宽度 width 作为参数，并返回矩形的面积。
●公式： 矩形面积 = length * width
●要求：函数接收两个位置参数 length 和 width。
○函数返回计算得到的面积。
○如果长度或宽度为负数，函数应该返回 0。

# --- 题目2：计算矩形的面积 ---
def calculate_rectangle_area(length, width):"""计算矩形的面积。参数:length (float or int): 矩形的长度。width (float or int): 矩形的宽度。返回:float or int: 矩形的面积。如果长度或宽度为负数，或者输入类型不正确，则返回 0。"""# 首先，检查传入的长度和宽度是否是有效的数字类型 (整数或浮点数)# isinstance() 函数用于判断一个对象是否是一个已知的类型。# 这里我们检查 length 和 width 是否是 int (整数) 或 float (浮点数) 类型。# (int, float) 是一个包含两种类型的元组，isinstance 会检查对象是否是元组中任何一种类型。if not isinstance(length, (int, float)) or not isinstance(width, (int, float)):# 如果 length 不是数字，或者 width 不是数字 (or 表示两者任一条件满足即可)# 'not' 对 isinstance 的结果取反。# 打印错误信息。f-string (f"...") 允许我们在字符串中直接嵌入变量的值。print(f"错误：长度 ({length}) 和宽度 ({width}) 都必须是数字类型。")# 返回 0，表示计算失败或输入无效return 0# 接下来，检查长度或宽度是否为负数# 使用 or 条件，只要其中一个为负数 (length < 0 或者 width < 0)，条件就成立if length < 0 or width < 0:# 如果长度或宽度为负数，打印警告信息print(f"警告：长度 ({length}) 或宽度 ({width}) 为负数。面积将返回 0。")# 根据题目要求，返回 0return 0# 如果代码执行到这里，说明前面的检查都通过了：# 1. length 和 width 都是数字。# 2. length 和 width 都不是负数。# 现在可以安全地计算面积了。# 矩形面积 = 长度 * 宽度area = length * width# 使用 return 语句将计算得到的面积返回给调用函数的地方return area# --- 测试 calculate_rectangle_area 函数 ---
print("\n--- 开始测试 calculate_rectangle_area 函数 ---") # \n 是换行符，让输出更好看# 测试用例1: 正常的长度和宽度
rect_len1 = 10  # 定义一个变量存储长度
rect_wid1 = 5   # 定义一个变量存储宽度
# 调用函数，并将 rect_len1 和 rect_wid1 作为参数传递
area1 = calculate_rectangle_area(rect_len1, rect_wid1) 
# 打印结果
print(f"矩形：长度={rect_len1}, 宽度={rect_wid1}, 面积={area1}") # 预期输出: 50# 测试用例2: 长度为0 (有效的，面积应为0)
rect_len2 = 0
rect_wid2 = 5
area2 = calculate_rectangle_area(rect_len2, rect_wid2)
print(f"矩形：长度={rect_len2}, 宽度={rect_wid2}, 面积={area2}") # 预期输出: 0# 测试用例3: 宽度为负数 (应返回0并打印警告)
rect_len3 = 10
rect_wid3 = -2
area3 = calculate_rectangle_area(rect_len3, rect_wid3)
print(f"矩形：长度={rect_len3}, 宽度={rect_wid3}, 面积={area3}") # 预期输出: 0# 测试用例4: 长度为负数 (应返回0并打印警告)
rect_len4 = -4
rect_wid4 = 5
area4 = calculate_rectangle_area(rect_len4, rect_wid4)
print(f"矩形：长度={rect_len4}, 宽度={rect_wid4}, 面积={area4}") # 预期输出: 0# 测试用例5: 长度和宽度都为负数 (应返回0并打印警告)
rect_len5 = -3
rect_wid5 = -6
area5 = calculate_rectangle_area(rect_len5, rect_wid5)
print(f"矩形：长度={rect_len5}, 宽度={rect_wid5}, 面积={area5}") # 预期输出: 0# 测试用例6: 长度不是数字 (应返回0并打印错误)
rect_len6 = "abc" # 这是一个字符串，不是数字
rect_wid6 = 5
area6 = calculate_rectangle_area(rect_len6, rect_wid6)
print(f"矩形：长度='{rect_len6}', 宽度={rect_wid6}, 面积={area6}") # 注意字符串用引号括起来# 测试用例7: 宽度不是数字 (应返回0并打印错误)
rect_len7 = 10
rect_wid7 = "xyz" # 这是一个字符串
area7 = calculate_rectangle_area(rect_len7, rect_wid7)
print(f"矩形：长度={rect_len7}, 宽度='{rect_wid7}', 面积={area7}")print("--- calculate_rectangle_area 函数测试结束 ---")

try-except,把if的判断模块和执行模块分开了，数字类型的报错就和负数的不一样

*args用法，就直接放在name（）括号中

题目3：计算任意数量数字的平均值
●任务： 编写一个名为 calculate_average 的函数，该函数可以接收任意数量的数字作为参数（引入可变位置参数 (*args)），并返回它们的平均值。
●要求：使用 *args 来接收所有传入的数字。
○如果没有任何数字传入，函数应该返回 0。
○函数返回计算得到的平均值。

# --- 题目3：计算任意数量数字的平均值 ---
def calculate_average(*args):"""计算任意数量数字的平均值。参数:*args: 任意数量的数字参数。这些参数会被收集到一个名为 args 的元组 (tuple) 中。返回:float: 数字的平均值。如果没有提供参数，则返回 0。如果提供的参数中包含非数字类型，则会尝试忽略它们并计算剩余数字的平均值，同时打印警告。如果所有参数都是非数字或没有有效数字，则返回 0。"""# 检查 *args 是否为空。# 当函数被调用时，所有通过位置传递的参数（没有显式名称的参数）# 都会被打包到名为 'args' 的元组 (tuple) 中。# 例如，如果调用 calculate_average(1, 2, 3)，那么 args 的值就是 (1, 2, 3)。# 如果调用 calculate_average()，那么 args 的值就是空元组 ()。if not args:  # 'not args' 检查元组 args 是否为空。空元组在布尔上下文中被视为 False。# 如果没有传入任何数字，打印提示信息并根据题目要求返回 0print("提示：没有提供任何数字来计算平均值，返回 0。")return 0# 初始化用于存储数字总和的变量sum_of_numbers = 0# 初始化用于记录有效数字个数的变量count_of_numbers = 0# 遍历传入到 *args 中的每一个参数# for 循环会依次取出 args 元组中的每个元素，并将其赋值给变量 'number'for number in args:# 检查当前取出的 'number' 是否是数字类型 (整数 int 或浮点数 float)if isinstance(number, (int, float)):# 如果是数字，将其加到总和 sum_of_numbers 中sum_of_numbers += number  # 这行代码等同于: sum_of_numbers = sum_of_numbers + number# 同时，将有效数字的计数器 count_of_numbers 加 1count_of_numbers += 1   # 这行代码等同于: count_of_numbers = count_of_numbers + 1else:# 如果 'number' 不是数字类型，打印一条警告信息# type(number).__name__ 会获取变量 'number' 的具体类型名称 (例如 'str', 'list')print(f"警告：参数 '{number}' (类型: {type(number).__name__}) 不是数字，将被忽略。")# 在尝试进行除法运算（计算平均值）之前，必须确保我们至少有一个有效的数字# 否则，如果 count_of_numbers 是 0，执行 sum_of_numbers / count_of_numbers 会导致 ZeroDivisionErrorif count_of_numbers == 0:# 如果遍历完所有参数后，没有找到任何有效的数字# (例如，所有传入的参数都是字符串，或者虽然传入了参数但都被忽略了)print("提示：没有有效的数字可用于计算平均值，返回 0。")return 0# 计算平均值：总和除以数量average = sum_of_numbers / count_of_numbers# 返回计算得到的平均值return average# --- 测试 calculate_average 函数 ---
print("\n--- 开始测试 calculate_average 函数 ---")# 测试用例1: 传入多个数字
# 调用函数时，10, 20, 30, 40, 50 会被收集到 args 元组中: args = (10, 20, 30, 40, 50)
avg1 = calculate_average(10, 20, 30, 40, 50)
print(f"数字 (10, 20, 30, 40, 50) 的平均值是: {avg1}") # 预期输出: (10+20+30+40+50)/5 = 150/5 = 30.0# 测试用例2: 传入单个数字
# args = (15,)  注意，即使只有一个元素，元组也会有一个逗号
avg2 = calculate_average(15)
print(f"数字 (15) 的平均值是: {avg2}") # 预期输出: 15.0# 测试用例3: 不传入任何数字
# args = () # 空元组
avg3 = calculate_average() 
print(f"没有传入数字时的平均值是: {avg3}") # 预期输出: 0 (并打印提示)# 测试用例4: 传入包含非数字类型的参数
# args = (10, 20, "abc", 30, "xyz", 40.5)
# 函数会忽略 "abc" 和 "xyz"
avg4 = calculate_average(10, 20, "abc", 30, "xyz", 40.5)
# 有效数字是 10, 20, 30, 40.5。 总和 = 100.5, 数量 = 4. 平均值 = 100.5 / 4 = 25.125
print(f"数字 (10, 20, \"abc\", 30, \"xyz\", 40.5) 的有效平均值是: {avg4}") # (并打印警告)# 测试用例5: 所有参数都是非数字
# args = ("hello", "world", [1, 2])
# [1, 2] 是一个列表，也不是 int 或 float
avg5 = calculate_average("hello", "world", [1, 2])
print(f"参数 (\"hello\", \"world\", [1, 2]) 的平均值是: {avg5}") # 预期输出: 0 (并打印警告和提示)# 测试用例6: 传入浮点数
# args = (1.5, 2.5, 3.5)
avg6 = calculate_average(1.5, 2.5, 3.5)
print(f"数字 (1.5, 2.5, 3.5) 的平均值是: {avg6}") # 预期输出: (1.5+2.5+3.5)/3 = 7.5/3 = 2.5print("--- calculate_average 函数测试结束 ---")

— 开始测试 calculate_average 函数 —
数字 (10, 20, 30, 40, 50) 的平均值是: 30.0
数字 (15) 的平均值是: 15.0
提示：没有提供任何数字来计算平均值，返回 0。
没有传入数字时的平均值是: 0
警告：参数 ‘abc’ (类型: str) 不是数字，将被忽略。
警告：参数 ‘xyz’ (类型: str) 不是数字，将被忽略。
数字 (10, 20, “abc”, 30, “xyz”, 40.5) 的有效平均值是: 25.125
警告：参数 ‘hello’ (类型: str) 不是数字，将被忽略。
警告：参数 ‘world’ (类型: str) 不是数字，将被忽略。
警告：参数 ‘[1, 2]’ (类型: list) 不是数字，将被忽略。
提示：没有有效的数字可用于计算平均值，返回 0。
参数 (“hello”, “world”, [1, 2]) 的平均值是: 0
数字 (1.5, 2.5, 3.5) 的平均值是: 2.5
— calculate_average 函数测试结束 —

题目4：打印用户信息
●任务： 编写一个名为 print_user_info 的函数，该函数接收一个必需的参数 user_id，以及任意数量的额外用户信息（作为关键字参数）。
●要求：
○user_id 是一个必需的位置参数。
○使用 **kwargs 来接收额外的用户信息。
○函数打印出用户ID，然后逐行打印所有提供的额外信息（键和值）。
○函数不需要返回值

# --- 题目4：打印用户信息 ---
def print_user_info(user_id, **kwargs):"""打印用户的ID以及提供的其他任意关键字参数信息。参数:user_id (any): 用户的ID，这是一个必需的位置参数。它可以是任何数据类型 (例如整数、字符串等)。**kwargs: 任意数量的关键字参数。这些参数会被收集到一个名为 kwargs 的字典 (dictionary) 中。例如，如果调用 print_user_info(101, name="Alice", age=30)，那么 kwargs 将是 {"name": "Alice", "age": 30}。返回:None: 这个函数不返回任何值 (它只是执行打印操作)。"""# 首先，打印用户的ID。# user_id 是一个必需的位置参数，调用此函数时必须提供。print(f"用户ID: {user_id}")# 检查 **kwargs 是否收集到了任何参数。# 当函数被调用时，所有以 `key=value` 形式传递的额外参数# 都会被打包到名为 'kwargs' 的字典 (dictionary) 中。# 例如，如果调用 print_user_info(1, name="Bob", location="USA")，# 那么 kwargs 的值就是 {"name": "Bob", "location": "USA"}。# 如果只调用 print_user_info(1)，那么 kwargs 就是一个空字典 {}。if not kwargs:  # 'not kwargs' 检查字典 kwargs 是否为空。空字典在布尔上下文中被视为 False。# 如果 kwargs 字典为空 (即没有提供额外的关键字参数)，打印一条提示信息。print("  没有提供额外的用户信息。")else:# 如果 kwargs 字典不为空，说明有额外的用户信息。print("  额外信息:")# 遍历 kwargs 字典中的每一项。# kwargs.items() 方法返回一个包含字典中所有 (键, 值) 对的视图对象。# 在 for 循环中，每个键值对会被解包到变量 'key' 和 'value' 中。for key, value in kwargs.items():# 打印每个额外信息的键 (key) 和对应的值 (value)。# 使用 f-string 进行格式化输出。# "    " (四个空格) 用于缩进，使输出更易读。print(f"    {key}: {value}")# 这个函数的主要目的是打印信息，而不是返回一个计算结果。# 因此，它不需要显式的 `return` 语句来返回值。# 如果一个函数没有显式的 `return` 语句，或者有一个不带任何值的 `return`，# 它会自动返回一个特殊的值 `None`。# --- 测试 print_user_info 函数 ---
print("\n--- 开始测试 print_user_info 函数 ---")# 测试用例1: 提供 user_id 和一些额外的关键字参数
print("测试用例 1:")
# 调用函数时，101 是 user_id。
# name="Alice", age=30, city="New York" 会被收集到 kwargs 中。
# kwargs = {"name": "Alice", "age": 30, "city": "New York"}
print_user_info(101, name="Alice", age=30, city="New York")
# 预期输出:
# 用户ID: 101
#   额外信息:
#     name: Alice
#     age: 30
#     city: New York# 测试用例2: 只提供必需的 user_id，没有额外的关键字参数
print("\n测试用例 2:")
# kwargs 将是一个空字典 {}
print_user_info("user_abc") # user_id 可以是字符串或其他类型
# 预期输出:
# 用户ID: user_abc
#   没有提供额外的用户信息。# 测试用例3: 提供 user_id 和不同类型的额外信息
print("\n测试用例 3:")
# kwargs 将包含 username, email, is_active, hobbies
print_user_info(999, username="johndoe", email="john.doe@example.com", is_active=True,  # 布尔值hobbies=["reading", "hiking"]) # 列表作为值
# 预期输出:
# 用户ID: 999
#   额外信息:
#     username: johndoe
#     email: john.doe@example.com
#     is_active: True
#     hobbies: ['reading', 'hiking']# 测试用例4: user_id 是整数，一个额外的关键字参数
print("\n测试用例 4:")
# kwargs = {"status": "Pending"}
print_user_info(1, status="Pending")
# 预期输出:
# 用户ID: 1
#   额外信息:
#     status: Pendingprint("--- print_user_info 函数测试结束 ---")

key属性名称，value:值
for key, value in kwargs.items():
# 打印每个额外信息的键 (key) 和对应的值 (value)。
# 使用 f-string 进行格式化输出。

题目5：格式化几何图形描述
●任务： 编写一个名为 describe_shape 的函数，该函数接收图形的名称 shape_name (必需)，一个可选的 color (默认 “black”)，以及任意数量的描述该图形尺寸的关键字参数 (例如 radius=5 对于圆，length=10, width=4 对于矩形)。
●要求：shape_name 是必需的位置参数。
○color 是一个可选参数，默认值为 “black”。
○使用 **kwargs 收集描述尺寸的参数。
○函数返回一个描述字符串，格式如下：
○“A [color] [shape_name] with dimensions: [dim1_name]=[dim1_value], [dim2_name]=[dim2_value], …”如果 **kwargs 为空，则尺寸部分为 “with no specific dimensions.”

# --- 题目5：格式化几何图形描述 ---
def describe_shape(shape_name, color="black", **dimensions_kwargs):"""生成一个描述几何图形及其尺寸的字符串。参数:shape_name (str): 图形的名称 (必需的位置参数)。color (str, optional): 图形的颜色。默认为 "black"。'optional' 表示这个参数是可选的。如果调用时不提供，则使用默认值。**dimensions_kwargs: 任意数量的关键字参数，用于描述图形的尺寸。例如: radius=5, length=10, width=4。这些参数会被收集到一个名为 dimensions_kwargs 的字典中。返回:str: 描述图形的字符串。"""# 开始构建描述字符串的第一部分。# 使用 f-string 来嵌入 shape_name 和 color 变量的值。# 例如: 如果 shape_name="circle" 且 color="red"，这里会得到 "A red circle"description = f"A {color} {shape_name}"# 检查是否通过 **dimensions_kwargs 提供了任何尺寸信息。# dimensions_kwargs 是一个字典。如果调用函数时没有提供额外的关键字参数# (除了 shape_name，以及 color 如果被显式指定的话)，# dimensions_kwargs 将会是一个空字典 {}。if not dimensions_kwargs:  # 'not dimensions_kwargs' 检查字典是否为空。# 如果 dimensions_kwargs 为空 (即没有提供尺寸参数)，# 在主描述后追加 " with no specific dimensions."description += " with no specific dimensions."else:# 如果 dimensions_kwargs 不为空，说明提供了尺寸参数。# 首先追加 " with dimensions: " 到主描述。description += " with dimensions: "# 创建一个空列表，用于存储每个维度参数的 "key=value" 字符串形式。dimension_parts = []# 遍历 dimensions_kwargs 字典中的每一项 (键和值)。# .items() 方法返回字典中 (键, 值) 对的集合。# dim_name 将是参数名 (例如 "radius", "length")，# dim_value 将是参数值 (例如 5, 10)。for dim_name, dim_value in dimensions_kwargs.items():# 将每个维度格式化为 "dim_name=dim_value" 的字符串，# 例如 "radius=5" 或 "length=10"。# 然后将这个字符串添加到 dimension_parts 列表中。dimension_parts.append(f"{dim_name}={dim_value}")# 使用 ", " (逗号和空格) 作为分隔符，# 将 dimension_parts 列表中的所有字符串连接成一个单一的字符串。# 例如，如果 dimension_parts 是 ["radius=5", "sides=3"]，# ", ".join(dimension_parts) 会得到 "radius=5, sides=3"。dimensions_string = ", ".join(dimension_parts)# 将连接好的维度字符串追加到主描述字符串的末尾。description += dimensions_string# 返回最终构建完成的描述字符串。return description# --- 测试 describe_shape 函数 ---
print("\n--- 开始测试 describe_shape 函数 ---")# 测试用例1: 圆形，指定颜色和半径
# shape_name="circle", color="red", dimensions_kwargs={"radius": 5}
desc1 = describe_shape("circle", color="red", radius=5)
print(f"测试1: {desc1}")
# 预期输出: A red circle with dimensions: radius=5# 测试用例2: 矩形，使用默认颜色 ("black")，指定长度和宽度
# shape_name="rectangle", color="black" (默认), dimensions_kwargs={"length": 10, "width": 4}
desc2 = describe_shape("rectangle", length=10, width=4)
print(f"测试2: {desc2}")
# 预期输出: A black rectangle with dimensions: length=10, width=4# 测试用例3: 三角形，只提供名称 (颜色使用默认，无尺寸)
# shape_name="triangle", color="black" (默认), dimensions_kwargs={} (空字典)
desc3 = describe_shape("triangle")
print(f"测试3: {desc3}")
# 预期输出: A black triangle with no specific dimensions.# 测试用例4: 正方形，指定颜色，无尺寸
# shape_name="square", color="blue", dimensions_kwargs={}
desc4 = describe_shape("square", color="blue")
print(f"测试4: {desc4}")
# 预期输出: A blue square with no specific dimensions.# 测试用例5: 自定义形状，多个维度参数
# shape_name="polygon", color="green", dimensions_kwargs={"sides": 6, "apothem": 2.5, "side_length": 3}
desc5 = describe_shape("polygon", color="green", sides=6, apothem=2.5, side_length=3)
print(f"测试5: {desc5}")
# 预期输出: A green polygon with dimensions: sides=6, apothem=2.5, side_length=3# 测试用例6: 形状名称包含空格，默认颜色
# shape_name="oval shape", color="black" (默认), dimensions_kwargs={"height": 10, "width": 5}
desc6 = describe_shape("oval shape", height=10, width=5)
print(f"测试6: {desc6}")
# 预期输出: A black oval shape with dimensions: height=10, width=5print("--- describe_shape 函数测试结束 ---")

位置参数即我的def定义时候和我是用的时候必须对应
默认参数，是在定义def是给参数赋值，若使用时不提及则默认使用

*args (任意数量的位置参数)
这里的 *toppings 会把 “珍珠”, “椰果”, “仙草” 这些参数收集到一个叫 toppings 的元组 (tuple) 里，就像一个小料清单。

**kwargs (任意数量的关键字参数)
size=“12寸”, crust=“薄底” 这些带有名字的参数收集到一个叫 details 的字典 (dictionary) 里，就像一个备注列表，每个备注都有标签和内容。

参数定义顺序
普通位置参数最先。
默认参数在普通位置参数之后，因为如果你想跳过默认参数直接给 *args 传值会很麻烦（虽然可以用关键字参数来指定前面的默认参数）。
*args 在默认参数之后，它会“吃掉”所有剩下的、没有名字的位置参数。
**kwargs 必须在最后，它会“吃掉”所有剩下的、有名字的关键字参数。