是否可以循环到某个值并使用该值进行进一步计算？

Question

我在这里是新来的，在编程方面也是新来的，所以如果这个问题表述得不够清楚，请原谅。 对于uni任务，我的labpartner和我正在编程一个捕食者-食饵系统。 在这个捕食者-食饵系统中，存在一个特定的负载因子“W0”。 我们希望找到一个负载因子W0，精确到5个有效数字，适用于永远不会有少于250个捕食者（在我们的代码中是wnum[1]）。我们想找到W0的这个值，我们需要代码用这个找到的W0值进行进一步的计算。以下是我们到目前为止尝试过的内容，但python似乎没有给出任何响应：

# Import important stuff and settings
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

print ('Results of Group 4')
def W0():
    W0 = 2.0
    while any(wnum[1])<250:
        W0 = W0-0.0001
        return W0

def W(t):
    if 0 <= t < 3/12:
        Wt = 0

    elif 3/12 <= t <= 8/12:
        Wt = W0

    elif 8/12 < t < 1:
        Wt = 0

    else: 
        Wt = W(t - 1)
    return Wt

# Define the right-hand-side function
def rhsf(t,y):
    y1 = y[0]
    y2 = y[1]

    f1 = (2-2*10**-3*y2)*y1-W(t)*y1
    f2 = (-3.92+7*10**-3*y1)*y2

    return np.array([f1,f2])

# Define one step of the RK4 method
def RK4Step(tn,wn,Dt,f):
    # tn = current time
    # wn = known approximation at time tn
    # Dt = the time step to use
    # f = the right-hand-side function to use
    # wnplus1 = the new approximation at time tn+Dt

    k1 = Dt*f(tn,wn)
    k2 = Dt*f(tn+0.5*Dt,wn+0.5*k1)
    k3 = Dt*f(tn+0.5*Dt,wn+0.5*k2)
    k4 = Dt*f(tn+Dt,wn+k3)

    wnplus1 = wn + 1/6*(k1 +2*k2 +2*k3 +k4)


    return wnplus1

# Define the complete RK4 method
def RK4Method(t0,tend,Dt,f,y0):
    # t0 = initial time of simulation
    # tend = final time of simulation
    # Dt = the time step to use
    # f = the right-hand-side function to use
    # y0 = the initial values

    # calculate the number of time steps to take
    N = int(np.round((tend-t0)/Dt))
    # make the list of times t which we want the solution
    time = np.linspace(t0,tend,num=N+1)
    # make sure Dt matches with the number of time steps
    Dt = (tend-t0)/N

    # Allocate memory for the approximations
    # row i represents all values of variable i at all times
    # column j represents all values of all variables at time t_j
    w = np.zeros((y0.size,N+1))
    # store the (given) initial value
    w[:,0] = y0

    # Perform all time steps
    for n,tn in enumerate(time[:-1]):
        w[:,n+1] = RK4Step(tn,w[:,n],Dt,f)

    return time, w

# Set all known values and settings
t0 = 0.0
tend = 10.0
y0 = np.array([600.0,1000.0])
Dt = 0.5/(2**7)

# Execute the method
tnum, wnum = RK4Method(t0,tend,Dt,rhsf,y0)

# Make a nice table
alldata = np.concatenate(([tnum],wnum),axis=0).transpose()
table = pd.DataFrame(alldata,columns=['t','y1(t)','y2(t)'])
print('\nA nice table of the simulation:\n')
print(table)

# Make a nice picture
plt.close('all')
plt.figure()
plt.plot(tnum,wnum[0,:],label='$y_1$',marker='o',linestyle='-')
plt.plot(tnum,wnum[1,:],label='$y_2$',marker='o',linestyle='-')
plt.xlabel('$t$')
plt.ylabel('$y(t)$')
plt.title('Simulation')
plt.legend()

# Do an error computation
# Execute the method again with a doubled time step
tnum2, wnum2 = RK4Method(t0,tend,2.0*Dt,rhsf,y0)
# Calculate the global truncation errors at the last simulated time
errors = (wnum[:,-1] - wnum2[:,-1])/(2**4-1)
print('\nThe errors are ',errors[0],' for y1 and ',errors[1],' for y2 at time t=',tnum[-1])