一个橡皮球从 100 米高处落下，每次撞到地面，它会弹回掉落高度的 3/5。用python求

可以使用循环来模拟橡皮球的掉落和弹起过程，计算它落地的总次数和落地时的高度。

以下是一个示例代码：

height = 100  # 初始高度为100米
count = 0  # 落地次数为0

while height > 0.01:  # 当高度低于0.01米时停止循环
    count += 1  # 落地次数加1
    height *= 3/5  # 每次弹起后高度变为原来的3/5
print("落地{}次".format(count))
print("最后落地时的高度为{:.2f}米".format(height))

输出结果为：

落地5次
最后落地时的高度为0.03米

说明这个橡皮球在第5次落地时高度低于0.01米，因此总共落地了5次，最后落地时的高度为0.03米。

相关问题

一个橡皮球从 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()` 函数的行为是不同的。

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

下面是一个实现要求的函数，其中参数height为初始高度，rebound_num为反弹次数，rebound_heights为保存反弹高度的列表。函数通过递归调用自身实现了反弹的过程，并在每次反弹时将当前高度添加到rebound_heights中。

def ball_rebound(height=100, rebound_num=10, rebound_heights=None):
    if rebound_heights is None:
        rebound_heights = []
    if rebound_num > 0:
        rebound_heights.append(height)
        height *= 3/5
        ball_rebound(height, rebound_num-1, rebound_heights)
    else:
        rebound_heights.append(height)
    return rebound_heights

接下来进行实验：

1. 默认参数使用：调用函数时，可以不传递参数，此时函数会使用默认参数进行计算。

# 不传递参数，使用默认参数
print(ball_rebound())

2. 函数的返回值：函数返回了一个列表，即反弹高度的列表。

# 调用函数，并接收返回值
rebound_heights = ball_rebound()
print(rebound_heights)

3. 变量的作用域：在函数内部定义的变量，只在函数内部生效，外部无法访问。

# 在函数外部访问函数内部定义的变量
print(height)
# NameError: name 'height' is not defined

4. 在函数内部使用全局变量：在函数内部可以使用全局变量，但需要在函数内部声明global。

# 声明全局变量
global height
height = 100

# 在函数内部使用全局变量
def ball_rebound_global():
    global height
    if height > 0:
        print(height)
        height *= 3/5
        ball_rebound_global()

ball_rebound_global()

5. 在函数内部修改全局变量的值：在函数内部可以修改全局变量的值，但需要在函数内部声明global。

# 在函数内部修改全局变量的值
global height
height = 100

def ball_rebound_global_modify():
    global height
    height *= 3/5

ball_rebound_global_modify()
print(height)

6. 以可变数据类型作为参数，在函数内部对其进行修改，并检验函数调用前后对应变量的值的变化情况：在函数内部可以修改可变类型的参数，修改后会影响到函数外部的变量。

# 以可变数据类型作为参数，在函数内部修改参数并检验函数调用前后对应变量的值的变化情况
def modify_list(my_list):
    my_list.append(4)
    my_list[0] = 100

my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)

7. 重新赋值与修改：在函数内部重新赋值和修改变量，对变量的影响是不同的。

# 重新赋值和修改变量的区别
def assign_var(var):
    var = 10

def modify_var(var):
    var.append(4)

my_var = [1, 2, 3]

# 重新赋值不会影响原变量
assign_var(my_var)
print(my_var)

# 修改变量会影响原变量
modify_var(my_var)
print(my_var)