一个橡皮球从 100 米高处落下，每次撞到地面，它会弹回掉落高度的 3/5。自行设计简单的函数实现（具体功能不限），并完成以下实验：（1）默认参数的使用；（2）函数的返回值（包括无返回值、一个及多个返回值）；（3）变量的作用域；（4）在函数内部使用全局变量；（4）在函数内部修改全局变量的值；（5）以可变数据类型（例如列表和字典）作为参数，在函数内部对其进行修改，并检验函数调用前后对应变量的值的变化情况；（6）参考“3.2 有关函数的更多信息.pdf”中的“重新赋值与修改（Reassignment vs Modifying）”部分内容，设计相关实验以检验在函数体内部修改值和重新分配变量名称之间的区别。

以下是一个简单的函数实现：

def ball_drop(height=100):
    """模拟橡皮球从一定高度落下，并弹起 3/5 高度后再落下，重复直到不再弹起"""
    count = 0  # 弹起次数
    while height > 0:
        count += 1
        print(f"第 {count} 次落地后反弹高度为 {height * 3/5:.2f} 米")
        height *= 3/5  # 计算下一次弹起高度
    print(f"共弹起 {count} 次")

接下来，我们分别进行实验：

1. 默认参数的使用

调用函数 `ball_drop()`，默认高度为 100 米，结果如下：

第 1 次落地后反弹高度为 60.00 米
第 2 次落地后反弹高度为 36.00 米
第 3 次落地后反弹高度为 21.60 米
第 4 次落地后反弹高度为 12.96 米
第 5 次落地后反弹高度为 7.78 米
第 6 次落地后反弹高度为 4.67 米
第 7 次落地后反弹高度为 2.80 米
第 8 次落地后反弹高度为 1.68 米
第 9 次落地后反弹高度为 1.01 米
第 10 次落地后反弹高度为 0.61 米
共弹起 10 次

2. 函数的返回值

我们可以将弹起次数和最终落地的高度作为函数的返回值，修改函数如下：

def ball_drop_v2(height=100):
    """模拟橡皮球从一定高度落下，并弹起 3/5 高度后再落下，重复直到不再弹起"""
    count = 0  # 弹起次数
    while height > 0:
        count += 1
        print(f"第 {count} 次落地后反弹高度为 {height * 3/5:.2f} 米")
        height *= 3/5  # 计算下一次弹起高度
    print(f"共弹起 {count} 次")
    final_height = height / (3/5)
    return count, final_height

然后调用函数，获取返回值并打印：

result = ball_drop_v2()
print(f"弹起次数：{result[0]}, 最终落地高度：{result[1]:.2f} 米")

输出结果为：

第 1 次落地后反弹高度为 60.00 米
第 2 次落地后反弹高度为 36.00 米
第 3 次落地后反弹高度为 21.60 米
第 4 次落地后反弹高度为 12.96 米
第 5 次落地后反弹高度为 7.78 米
第 6 次落地后反弹高度为 4.67 米
第 7 次落地后反弹高度为 2.80 米
第 8 次落地后反弹高度为 1.68 米
第 9 次落地后反弹高度为 1.01 米
第 10 次落地后反弹高度为 0.61 米
共弹起 10 次
弹起次数：10, 最终落地高度：0.92 米

3. 变量的作用域

函数内部定义的变量是局部变量，在函数外部无法访问，示例代码如下：

def ball_drop_v3(height=100):
    """模拟橡皮球从一定高度落下，并弹起 3/5 高度后再落下，重复直到不再弹起"""
    count = 0  # 弹起次数
    while height > 0:
        count += 1
        print(f"第 {count} 次落地后反弹高度为 {height * 3/5:.2f} 米")
        height *= 3/5  # 计算下一次弹起高度
    print(f"共弹起 {count} 次")
    final_height = height / (3/5)
    return count, final_height

ball_drop_v3()
print(count)  # 会报错，因为 count 是局部变量

4. 在函数内部使用全局变量

可以使用 `global` 关键字在函数内部声明全局变量，并且可以在函数内部修改全局变量的值，示例代码如下：

count = 0  # 全局变量

def ball_drop_v4(height=100):
    """模拟橡皮球从一定高度落下，并弹起 3/5 高度后再落下，重复直到不再弹起"""
    global count  # 声明 count 是全局变量
    while height > 0:
        count += 1
        print(f"第 {count} 次落地后反弹高度为 {height * 3/5:.2f} 米")
        height *= 3/5  # 计算下一次弹起高度
    print(f"共弹起 {count} 次")
    final_height = height / (3/5)
    return count, final_height

ball_drop_v4()
print(count)  # 输出结果为 10，因为 count 是全局变量并且被修改了

5. 以可变数据类型作为参数，在函数内部对其进行修改

我们可以将一个列表作为参数传递给函数，并在函数内部修改列表的值，示例代码如下：

def ball_drop_v5(height, records):
    """模拟橡皮球从一定高度落下，并弹起 3/5 高度后再落下，重复直到不再弹起"""
    while height > 0:
        records.append(height)  # 记录每次落地前的高度
        height *= 3/5  # 计算下一次弹起高度
    return records

height = 100
records = []
ball_drop_v5(height, records)
print(records)  # 输出结果为 [100, 60.0, 36.0, 21.6, 12.959999999999999, 7.775999999999999, 4.665599999999999, 2.7993599999999995, 1.6796159999999998, 1.0077695999999999, 0.6046617599999999]

可以看到，函数内部修改了列表 `records` 的值。

6. 在函数体内部修改值和重新分配变量名称之间的区别

这个实验可以通过可变数据类型和不可变数据类型的区别来进行演示。不可变数据类型包括数字、字符串和元组，它们的值无法被修改；可变数据类型包括列表、字典和集合，它们的值可以被修改。

首先定义一个全局变量 `height`，然后定义两个函数 `change_height()` 和 `assign_height()`，分别演示在函数内部修改值和重新分配变量名称的区别，示例代码如下：

height = 100  # 全局变量

def change_height(h):
    h *= 2
    return h

def assign_height(h):
    h = 200
    return h

print(change_height(height))  # 输出结果为 200，因为传递给函数的是可变数据类型，函数内部修改了值
print(assign_height(height))  # 输出结果为 200，因为传递给函数的是不可变数据类型，函数内部重新分配了变量名称
print(height)  # 输出结果为 100，因为全局变量没有被修改

可以看到，`change_height()` 函数和 `assign_height()` 函数的行为是不同的。