Question

我创建了一个长代码，由for循环内的多个列表组成。计算没有任何问题，它确实获得了预期的结果。列表的代码和构造工作正常。问题是当它运行时，我已定义了满足特定条件时的中断。但是它不会在第一次运行时中断，而是继续运行并运行第一次循环范围功能内的所有值。我想实现在条件匹配时返回一个真值，并停止并且不会根据第一个循环中的范围值继续增长。

我将解释代码的工作原理！

代码： 第一部分是一致的，是输入

import math
import numpy as np


Ned = -500
fcd = 20
fyd = 435
E = 2e5
h = 200
cb = 35
ct = 35
ca = 35
b= 150
y = 12
d = h - cb
ds = ct
a = 25
yb = 8
ecu = 0.0035
rebarnumber = math.floor((b-(2*cb+2*yb+y))/a)
PI_Y2_4 = int(math.pi/4*(y)**2)
disc = []
dis = []
Asi = []
Asci = []
Esc = []
Esci = []
Sc = []
Sci =[]
#############################
# Calculation starts here
#############################

for n in range(0,10):         # <------- First for-loop
    cbb = cb + yb + y/2
    ctt = ct + yb + y/2

    if  0 < n <= rebarnumber:
        Asi.append(PI_Y2_4)
        dis.append( h - cbb)
        Asci.append(PI_Y2_4)
        disc.append( ctt )
    if  rebarnumber < n <= (2 * rebarnumber):
        Asi.append(PI_Y2_4)
        dis.append( h - cbb - ca)
        Asci.append(PI_Y2_4)
        disc.append(cbb + ca)
    if (2*rebarnumber) < n <= (3 * rebarnumber):
        Asi.append(PI_Y2_4)
        dis.append( h - cbb - 2*ca)
        Asci.append(PI_Y2_4)
        disc.append(cbb + 2*ca)
    if (3*rebarnumber) < n <= (4 * rebarnumber):
        Asi.append(PI_Y2_4)
        dis.append( h - cbb - 3*ca)
        Asci.append(PI_Y2_4)
        disc.append(cbb + 3*ca) 
    if (4*rebarnumber) < n <= (5 * rebarnumber):
        Asi.append(PI_Y2_4)
        dis.append( h - cbb - 4*ca)
        Asci.append(PI_Y2_4)
        disc.append(cbb + 4*ca)  
    if (5*rebarnumber) < n <= (6 * rebarnumber):
        Asi.append(PI_Y2_4)
        dis.append( h - cbb - 5*ca)
        Asci.append(PI_Y2_4)
        disc.append(cbb + 5*ca)
    if (6*rebarnumber) < n <= (7 * rebarnumber):
        Asi.append(PI_Y2_4)
        dis.append( h - cbb - 6*ca)
        Asci.append(PI_Y2_4)
        disc.append(cbb + 6*ca)
    if (7*rebarnumber) < n <= (8 * rebarnumber):
        Asi.append(PI_Y2_4)
        dis.append( h - cbb - 7*ca)
        Asci.append(PI_Y2_4)
        disc.append(cbb + 7*ca)

    for i in range(0,len(dis)):
        Esc.insert(i, dis[i])
        Esci.insert(i, disc[i])
        Sc.insert(i, dis[i])
        Sci.insert(i, disc[i])

        for x in np.linspace(1,h,10000):    # <-------- Second for-loop
            for k, _ in enumerate(Esc):
                try:    
                    if x < dis[k]:
                        Esc[k]=( ecu/x*(dis[k]-x) )
                    else:
                        Esc[k]=(- ecu/x*(x-dis[k] ) )

                    if x < disc[k]:
                        Esci[k]=( -ecu/x*(x-disc[k]) )
                    else:
                        Esci[k]=(- ecu/x*(x-disc[k]) )
                except (ZeroDivisionError, RuntimeWarning):
                    Esc[k]=( 0 )
                    Esci[k]=( 0 )       

            for k, _ in enumerate(Sc):       # <-------- Third for-loop
                ss = Esc[k]*E
                if ss <= -fyd:
                    Sc[k]= -fyd
                elif ss >= -fyd and ss < 0:
                    Sc[k]=ss
                else:
                    Sc[k]=min(ss,fyd)

            for k, _ in enumerate(Sci):
                sci = Esci[k]*E
                if sci <= -fyd:
                    Sci[k]= -fyd
                elif sci >= -fyd and sci < 0:
                    Sci[k]=sci
                else:
                    Sci[k]=min(sci,fyd)

            FS = 0
            FSC = 0
            for a, _ in enumerate(Sc):
                FS += Sc[a]*Asi[a]
                FSC+=Sci[a]*Asci[a]

            MS = 0        
            MSC = 0
            for m, _ in enumerate(Sc):
                MS += Sc[a]*Asi[a]*(dis[m]-h/2)
                MSC+= Sci[a]*Asci[a]*(h/2-disc[m])

            Nrd = 0
            Mrd = 0
            Nrd = int((-0.8*x*b*fcd+FSC+FS)/1000)
            Mrd = (0.8*x*b*fcd*(h/2-0.4*x)+MS-MSC)/1000000

            if 0 <= (float(Nrd) - Ned) <= 1:
                print(Nrd, x, Asi)
                break
        break

它如何工作？

第一个for循环创建一个索引为0的列表，即[value1]，第二个for循环创建一个x值递增（范围），第三个for循环创建依赖于第一个创建的列表[value1]的列表。然后Nrd值将基于x值的增量来确定。如果满足条件0 <= (float(Nrd) - Ned) <= 1:，则计算将停止并返回Nrd值。如果不匹配，则返回并从第一个for循环获取索引1，创建[value1, value2]，如果满足条件，则再次到达Nrd，否则将中断，直到匹配为止。

我的问题是代码运行时，我得到了这些输出。

 Nrd       x             Asi
---------------------------------------------------
-499 181.84938493849384 [113]
-499 162.36533653365336 [113, 113]
-499 147.3990399039904 [113, 113, 113]
-499 137.48784878487848 [113, 113, 113, 113]
-499 130.72117211721172 [113, 113, 113, 113, 113]
-499 126.10391039103911 [113, 113, 113, 113, 113, 113]
-499 122.7006700670067 [113, 113, 113, 113, 113, 113, 113]
-499 120.01390139013901 [113, 113, 113, 113, 113, 113, 113, 113]
-499 119.71537153715371 [113, 113, 113, 113, 113, 113, 113, 113, 113]

以上输出均为真正的多解。但是我想在第一个比赛之前停止（休息），而不是给出所有解决方案。

我使用过return True，但是当它抱怨功能失效时，它在这里并没有真正的作用。

这里的第二个问题是第二个for循环for x in np.linspace(1,h,10000):，我真的想用很多小数来运行它以获得最佳结果，但是它会变慢并且需要很长时间来计算。有没有办法加快速度？

也许将上述代码行定义为函数会更有效。

Answer 1

最简单，最直接的解决方案是将所有代码移入一个函数中

 def calculate_results(...args...): # Bad name, use a more suitable one
     ...
     for n in range(0, 10): # <------- First for-loop
         ...
         for x in np.linspace(1,h,10000):    # <-------- Second for-loop
         ...
         if 0 <= (float(Nrd) - Ned) <= 1:
            return Nrd, x, Asi

然后调用该函数

Nrd, x, Asi = calculate_results(...)
print(Nrd, x, Asi)

使用一个真正描述该功能本质的功能名称，并且仅在该功能内执行单个操作。然后return语句清楚地表明此任务已完成。

使用条件语句在多个for循环内中断并返回

1 个答案: