Python中的For循环：在for循环外继续迭代

Question

我有一个包含 for 循环的函数。 a_laps 是 400 米一圈所需的时间（以秒为单位）。到目前为止我定义的函数是这样的：

LAP_DISTANCE = 400 

def log_track_run(a_laps, a_last_lap_distance):
    r_output = ""
    total_time = 0
    total_distance = 0
    n_laps = len(a_laps)
    i_lap = None
    average_lap_time = None

    for i_lap in range(n_laps):
        lap_time = a_laps[i_lap]
        total_time = total_time + lap_time
        total_distance = total_distance + LAP_DISTANCE
        average_lap_time = (total_time) / (i_lap + 1)
        r_output += f"lap #{i_lap + 1} time = {a_laps[i_lap]}s, average lap time ={round(average_lap_time)}s, {total_distance}m in {total_time}s\n"

如果 a_last_lap_distance = 400 且 a_laps = [68, 70, 74, 68]，我得到以下输出，这是正确的输出：

lap #1 time = 68s, average lap time = 68s, 400m in 68s
lap #2 time = 70s, average lap time = 69s, 800m in 138s
lap #3 time = 74sdef log_track_run(a_laps, a_last_lap_distance):

如果a_last_lap_distance小于400，这意味着最后一圈没有完成，你不能只给i_lap加1，因为这一圈还没有完成。您必须添加 (a_last_lap_distance)/LAP_DISTANCE 才能获得与 400 的比率的单圈长度。我想仅更改 a_laps 范围内最后一项的迭代计算 - 在本例中，对于最后一圈所花费的时间68秒。

我尝试过以下功能：

def log_track_run(a_laps, a_last_lap_distance):
    r_output = ""
    total_time = 0
    total_distance = 0
    n_laps = len(a_laps)
    i_lap = None
    average_lap_time = None

    for i_lap in range(n_laps - 1 ):
        lap_time = a_laps[i_lap]
        total_time = total_time + lap_time
        total_distance = total_distance + LAP_DISTANCE
        average_lap_time = (total_time) / (i_lap + 1)
        r_output += f"lap #{i_lap + 1} time = {a_laps[i_lap]}s, average lap time = {round(average_lap_time)}s, {total_distance}m in {total_time}s\n"
    for i_lap in range(n_laps[-1]):
        lap_time = a_laps[i_lap]
        total_time = total_time + lap_time
        total_distance = total_distance + a_last_lap_distance
        average_lap_time = (total_time) / (i_lap + (a_last_lap_distance)/LAP_DISTANCE)
        r_output += f"lap #{i_lap + 1} time = {a_laps[i_lap]}s, average lap time {round(average_lap_time)}s, {total_distance}m in {total_time}s\n"

这会产生语法错误。如何修改该函数，以便第二个循环仅针对范围中的最后一项，同时基于前一个 for 循环中的前一个迭代？

我尝试编写第二个 for 循环，它基于前一个 for 循环，但仅适用于这一圈中的最后一个项目。

Answer 1

一个选项是填充一个列表

distances

，其中包含

len(a_laps)-1

和

last_distance/LAP_DIST

作为最后一个元素。然后，

zip

计算距离和时间，并计算运行平均值：

def log_track_run(a_laps, a_last_lap_distance):
    distances = [1] * (len(a_laps) - 1) + [a_last_lap_distance / LAP_DISTANCE]

    total_time = 0
    total_dist = 0

    for n, (dist, time) in enumerate(zip(distances, a_laps), 1):
        total_dist += dist
        total_time += time
        print(f'lap {n}: avg={total_time / total_dist}')

Answer 2

我首先会建立一个时间和距离列表，其中我将使用参数

last_lap_distance_actual

和

last_lap_distance_expected

来弄清楚如何将最后一圈“标准化”为预期距离。

为了完整性，我将在这里设置一堆变量，以说明我们如何完成每一圈。可能有些你不需要。

def log_track_run(laps_times, last_lap_distance_actual=400, last_lap_distance_expected=400):
    total_time_actual = 0.0
    total_time_normalized = 0.0
    total_distance_actual = 0.0
    total_distance_normalized = 0.0
    total_laps_actual = 0.0
    total_laps_normalized = 0.0

    ## ---------------
    ## pre generate a list of times and distances
    ## ---------------
    lap_times_and_distances = [[lap_time, last_lap_distance_expected] for lap_time in laps_times]
    lap_times_and_distances[-1][1] = last_lap_distance_actual
    ## ---------------

    print("--------------------------")
    for lap_time_actual, lap_distance_actual in lap_times_and_distances:
        lap_count_actual = lap_distance_actual / last_lap_distance_expected

        lap_count_normalized = 1
        lap_time_normalized = lap_time_actual * last_lap_distance_expected / lap_distance_actual
        lap_distance_normalized = last_lap_distance_expected

        total_time_actual += lap_time_actual
        total_time_normalized += lap_time_normalized
        total_distance_actual += lap_distance_actual
        total_distance_normalized += lap_distance_normalized
        total_laps_actual += lap_count_actual
        total_laps_normalized += lap_count_normalized

        avg_lap_time_actual = total_time_actual / total_laps_actual
        avg_lap_time_normalized = total_time_normalized / total_laps_normalized

        print(f"Lap: {total_laps_actual:.2f} average lap time = {avg_lap_time_actual:.4f}s {int(total_distance_actual)}m in {total_time_actual:.4f}s")
        if last_lap_distance_expected != lap_distance_actual:
            print(f"\tThis lap was less than {last_lap_distance_expected}m. Projecting results.")
            print(f"\tLap: {total_laps_normalized:.2f} average lap time = {avg_lap_time_normalized:.4f}s {int(total_distance_normalized)}m in {total_time_normalized:.4f}s")
    print("--------------------------")

## a 1500m race outdoors
log_track_run([68, 70, 74, 68], 300)

## a 200m race indoors
log_track_run([26], 200, 200)

这应该给你：

--------------------------
Lap: 1.00 average lap time = 68.0000s 400m in 68.0000s
Lap: 2.00 average lap time = 69.0000s 800m in 138.0000s
Lap: 3.00 average lap time = 70.6667s 1200m in 212.0000s
Lap: 3.75 average lap time = 74.6667s 1500m in 280.0000s
        This lap was less than 400m. Projecting results.
        Lap: 4.00 average lap time = 75.6667s 1600m in 302.6667s
--------------------------

--------------------------
Lap: 1.00 average lap time = 26.0000s 200m in 26.0000s
--------------------------

如果需要，您可能会看到如何调整打印报表。