如何让此函数接受可以是浮点、数组或列表的值？

Question

您好，我的函数代码有问题，我正在根据以前的代码进行调整，我手动输入数据：

我将代码更新为：

import numpy as np
import pandas as pd 

def pitch(X0,Y0,Z0,V0MPH,RPM,GyroAngle,TiltAngle,Phi,Theta,WS,WD,Temp,RH,Pressure):
    for x0 in X0:
        for y0 in Y0:
            for z0 in Z0:
                for V0 in V0MPH:
                    for R in RPM:
                        for a in GyroAngle:
                            for b in TiltAngle:
                                for phi in Phi:
                                    for theta in Theta:
                                        for spd in WS:
                                            for dire in WD:
                                                for Tf in Temp:
                                                    for H in RH:
                                                        for P in Pressure:
                                                            uwindfts=spd*np.sin(dire) #U Wind in ft/s
                                                            vwindfts=spd*np.cos(dire) #V Wind in ft/s
                                                            timestep=0 #time step for calculating
                                                            dt=0.001 #D-time
                                                            circ=9.125 #Circumference of ball
                                                            phi=phi*np.pi/180
                                                            theta=theta*np.pi/180
                                                            if phi>0: #Angle pitch is released wrt HP-2B line
                                                                a=1
                                                            else:
                                                                a=-1
                                                            Tc=(Tf-32.0)*(5/9) #F to C
                                                            Tk=Tc+273.15 #C to K
                                                            dryrho=P*100/(287*Tk) #Density
                                                            ep=RH*0.01*6.11*np.exp(17.625*Tc/(243.05+Tc))
                                                            wetrho=ep*100/(461*Tk)
                                                            rho=dryrho-wetrho
                                                            # print(rho)
                                                            gyrospin=R*np.sin(a*np.pi/180)
                                                            sidespin=a*(R-gyrospin)*np.sin(b*np.pi/180)
                                                            backspin=-1*(R-gyrospin)*np.cos(b*np.pi/180)
                                                            v=V0*1.467 
                                                            c0=(0.07182*rho*0.06261)
                                                            vx=v*np.cos(theta*np.pi/180)*np.sin(phi*np.pi/180)
                                                            vy=v*np.cos(theta*np.pi/180)*np.cos(phi*np.pi/180)
                                                            vz=v*np.sin(theta*np.pi/180)
                                                            vwow=np.sqrt((vx-uwindfts)**2+(vy-vwindfts)**2+(vz)**2)
                                                            # print (womg)
                                                            # print (vz)
                                                            # print (vz+wvv)
                                                            # print (vz-wvv)
                                                            constk=np.pi/30.0
                                                            x=x0
                                                            y=y0
                                                            z=z0
                                                            while y >=(17/12):
                                                                visco=2.791*(10.0**-7)*(Tk**0.7355)
                                                                vre=v*(0.44704/1.4617)
                                                                Re=rho*(vre)*(circ*0.254/(np.pi))/visco
                                                                upper=74.1*1.467*210000.0/Re
                                                                lower=14.3*1.467*210000.0/Re
                                                                cd=0.5-(0.227/(1.0+np.exp(-1.0*(v-upper)/lower)))
                                                                dragx=-cd*c0*vwow*(vx-uwindfts)
                                                                dragy=-cd*c0*vwow*(vy-vwindfts)
                                                                dragz=-cd*c0*vwow*(vz)
                                                                omgx=constk*(backspin*np.cos(phi)-(sidespin*np.sin(theta)*np.sin(phi))+gyrospin*vx/vwow)
                                                                omgy=constk*(-1*backspin*np.sin(phi)-(sidespin*np.sin(theta)*np.sin(phi))+gyrospin*vy/vwow)
                                                                omgz=constk*(sidespin*np.cos(theta)+gyrospin*(vz/vwow))
                                                                omg=np.sqrt(omgx**2.0+omgy**2.0+omgz**2.0)
                                                                romg=omg*(circ/(2.0*np.pi))/12.0
                                                                S=np.exp((timestep*dt)/1000.0)*(romg/vwow)
                                                                cl=1.0/(2.32+(0.4/S))
                                                                magnusx=c0*(cl/omg)*vwow*(omgy*(vz)-omgz*(vy-vwindfts))
                                                                magnusy=c0*(cl/omg)*vwow*(omgz*(vx-uwindfts)-omgx*(vz))
                                                                magnusz=c0*(cl/omg)*vwow*(omgx*(vy-vwindfts)-omgy*(vx-uwindfts))
                                                                ax=magnusx+dragx
                                                                ay=magnusy+dragy
                                                                az=magnusz+dragz-32.174
                                                                vx=vx+ax*dt
                                                                vy=vy-ay*dt
                                                                vz=vz+az*dt
                                                                v=np.sqrt((vx)**2+(vy)**2+vz**2)
                                                                vwow=np.sqrt((vx-uwindfts)**2+(vy-vwindfts)**2+(vz)**2)
                                                                x=x+vx*dt+ax*(dt**2)
                                                                y=y+vy*dt+ay*(dt**2)
                                                                z=z+vz*dt+az*(dt**2)
                                                                vmph=v/1.467
                                                                timestep+=1
                                                                xfinal=x
                                                                zfinal=z
                                                                print (xfinal,zfinal) 
                                                                return xfinal,zfinal

pitch(-2.5,55,6,95,2450,5,183,176.5,-2,5,0,72,55,1013.25)

以读取数组，但新代码不希望读取浮点。 [1] ：https://i.stack.imgur.com/QffcA.png [2] ：https://i.stack.imgur.com/5K6wt.png

Answer 1

下面是数组RMP如何传播到yy以单个数字开始，但一旦迭代完成，它就是一个与RMP形状相同的数组（如果我正确阅读了代码的话）

def pitchtrack(x,y,z,RPM,v0mph,gyro,tiltangle,phi,theta,wu,wv,wvv,Tf,RH,Pmb):
    ....
    backspin=-1*(RPM-gyrospin)*np.cos(a*tiltangle*np.pi/180)
    ...
    while y>=(17/12):
       ...
       omgx=np.pi*(backspin*np.cos(phi*np.pi/180.0)
       ...
       magnusy=c0*(cl/omg)*vwow*(omgz*(vx-wu)-omgx*(vz))
       ...
       ay=magnusy+dragy
       ...
       vy=vy-ay*dt
       ...
       y=y+vy*dt
       ...

y>=(7/12)将是一个具有多个值的布尔数组。这就是错误所在。这样的数组不能在需要一个布尔值的Python上下文中使用。示例包括if、or和这里的while

错误消息建议使用any或all将该数组减少为一个值。但是你必须决定哪一个是正确的。有时可能会使用其他方法，例如sum或max/min，或将多个值减少为一个值的其他方法

您确定这段代码的作者打算将RMP作为数组吗？也许它是用一个标量值编写的——并用这样的值进行了测试