Python 删除多个列表的最后一个值的更优雅的方法？

我有多个列表，即，

X

，

Y

，

VX

，

VY

，

R

，

T

，

KE

，

PE

，

TE

，对于这些列表，我需要在迭代中断后删除它们的（I+1）个值。目前，我可以这样做的方式是：

del X[i+1:]
del Y[i+1:]
del VX[i+1:]
del VY[i+1:]
del R[i+1:]
del T[i+1:]
del KE[i+1:]
del PE[i+1:]
del TE[i+1:]

我觉得它看起来很难看。在这种情况下，有没有办法尽量减少线路的使用。可能是一个循环，但只在1或2行

编辑： 我不想包括我的代码主体，因为我知道我的很多同事都在做同样的问题，我不希望任何人剽窃。不管怎样，我就是这么做的

def F_1(X):
    return VX

def F_2(X):
    return VY

def F_3(X, Y):
    return -G*EM*X/((X**2 + Y**2)**(3/2))

def F_4(X, Y):
    return -G*EM*Y/((X**2 + Y**2)**(3/2))

def RKutta(F_1, F_2, F_3, F_4, XSTART, YSTART, VXSTART, VYSTART):
    N = 100000
    X, Y = np.zeros([N+1]), np.zeros([N+1])
    VX, VY = np.zeros([N+1]), np.zeros([N+1])
    R, T =  np.zeros([N+1]), np.zeros([N+1])
    KE, PE, TE = np.zeros([N+1]), np.zeros(N+1), np.zeros([N+1])

    X[0], Y[0] = XSTART, YSTART
    VX[0], VY[0] = VXSTART, VYSTART
    T[0] = 0
#    KE[0], PE[0], TE[0] = KE, PE, TE

    for i in range (1,N):

        K_1X = F_1(VX[i-1])
        K_1Y = F_2(VY[i-1])
        K_1VX = F_3(X[i-1], Y[i-1])
        K_1VY = F_4(X[i-1], Y[i-1])

        K_2X = F_1(VX[i-1] + (H*K_1VX/2))
        K_2Y = F_2(VY[i-1] + (H*K_1VY/2))
        K_2VX = F_3(X[i-1] + (H*K_1X/2), Y[i-1] + (H*K_1Y/2))
        K_2VY = F_4(X[i-1] + (H*K_1X/2), Y[i-1] + (H*K_1Y/2))

        K_3X = F_1(VX[i-1] + (H*K_2VX/2))
        K_3Y = F_2(VY[i-1] + (H*K_2VY/2))
        K_3VX = F_3(X[i-1] + (H*K_2X/2), Y[i-1] + (H*K_2Y/2))
        K_3VY = F_4(X[i-1] + (H*K_2X/2), Y[i-1] + (H*K_2Y/2))

        K_4X = F_1(VX[i-1] + H*K_3VX)
        K_4Y = F_2(VY[i-1] + H*K_3VY)
        K_4VX = F_3(X[i-1] + H*K_3X, Y[i-1] + H*K_3Y)
        K_4VY = F_4(X[i-1] + H*K_3X, Y[i-1] + H*K_3Y)

        X[i] = X[i-1] + (H/6)*(K_1X + 2*K_2X + 2*K_3X + K_4X)
        Y[i] = Y[i-1] + (H/6)*(K_2Y + 2*K_2Y + 2*K_3Y + K_4Y)
        VX[i] = VX[i-1] + (H/6)*(K_1VX + 2*K_2VX + 2*K_3VX + 2*K_4VX)
        VY[i] = VY[i-1] + (H/6)*(K_1VY + 2*K_2VY + 2*K_3VY + 2*K_4VY)
        R[i] = ((X[i])**2 + (Y[i])**2)**(0.5)
        T[i] = T[i-1] + H

        KE[i] = ((VX[i]**2 + VY[i]**2)/2)
        PE[i] = (-1*G*EM/R[i])
        TE[i] = KE[i] + PE[i]

        if R[i] < 6.371E6:  #if orbit radius is less than Earth radius
            break

        for sublist in [X, Y, VX, VY, R, T, KE, PE, TE]:
            del sublist[i+1:]

    return X, Y, VX, VY, R, T, KE, PE, TE

X = 3.84E8
Y = 0
X, Y, VX, VY, R, T, KE, PE = RKutta(F_1, F_2, F_3, F_4, X, Y, VX, VY)

plt.plot(X, Y, label = "")
plt.xlabel("X distance (m)")
plt.ylabel("Y distance (m)")
plt.title("X against Y")
plt.legend()
plt.show()

def_1（X）：
返回VX
def F_2（X）：
返回VY
def F_3（X，Y）：
返回-G*EM*X/（（X**2+Y**2）***（3/2））
def F_4（X，Y）：
返回-G*EM*Y/（（X**2+Y**2）***（3/2））
定义RKutta（F_1、F_2、F_3、F_4、XSTART、YSTART、VXSTART、VYSTART）：
N=100000
十、 Y=np.零（[N+1]），np.零（[N+1]））
VX，VY=np.零（[N+1]），np.零（[N+1]））
R、 T=np.零（[N+1]），np.零（[N+1]）
KE，PE，TE=np.zeros（[N+1]），np.zeros（N+1），np.zeros（[N+1]）
X[0]，Y[0]=XSTART，YSTART
VX[0]，VY[0]=VXSTART，VYSTART
T[0]=0
#KE[0]，PE[0]，TE[0]=KE，PE，TE
对于范围（1，N）内的i：
K_1X=F_1（VX[i-1]）
K_1Y=F_2（VY[i-1]）
K_1VX=F_3（X[i-1]，Y[i-1]）
K_1VY=F_4（X[i-1]，Y[i-1]）
K_2X=F_1（VX[i-1]+（H*K_1VX/2））
K_2Y=F_2（VY[i-1]+（H*K_1VY/2））
K_2VX=F_3（X[i-1]+（H*K_1X/2），Y[i-1]+（H*K_1Y/2））
K_2VY=F_4（X[i-1]+（H*K_1X/2），Y[i-1]+（H*K_1Y/2））
K_3X=F_1（VX[i-1]+（H*K_2VX/2））
K_3Y=F_2（VY[i-1]+（H*K_2VY/2））
K_3VX=F_3（X[i-1]+（H*K_2X/2），Y[i-1]+（H*K_2Y/2））
K_3VY=F_4（X[i-1]+（H*K_2X/2），Y[i-1]+（H*K_2Y/2））
K_4X=F_1（VX[i-1]+H*K_3VX）
K_4Y=F_2（VY[i-1]+H*K_3VY）
K_4VX=F_3（X[i-1]+H*K_3X，Y[i-1]+H*K_3Y）
K_4VY=F_4（X[i-1]+H*K_3X，Y[i-1]+H*K_3Y）
X[i]=X[i-1]+（H/6）*（K_1X+2*K_2X+2*K_3X+K_4X）
Y[i]=Y[i-1]+（H/6）*（K_2Y+2*K_2Y+2*K_3Y+K_4Y）
VX[i]=VX[i-1]+（H/6）*（K_1VX+2*K_2VX+2*K_3VX+2*K_4VX）
VY[i]=VY[i-1]+（H/6）*（K_1VY+2*K_2VY+2*K_3VY+2*K_4VY）
R[i]=（（X[i]）**2+（Y[i]）**2）***（0.5）
T[i]=T[i-1]+H
KE[i]=（（VX[i]**2+VY[i]**2）/2）
PE[i]=（-1*G*EM/R[i]）
TE[i]=KE[i]+PE[i]
如果R[i]<6.371E6:#如果轨道半径小于地球半径
打破
对于[X，Y，VX，VY，R，T，KE，PE，TE]中的子列表：
删除子列表[i+1:]
返回X，Y，VX，VY，R，T，KE，PE，TE
X=3.84E8
Y=0
十、 Y，VX，VY，R，T，KE，PE=RKutta（F_1，F_2，F_3，F_4，X，Y，VX，VY）
plt.绘图（X，Y，label=“”）
plt.xlabel（“X距离（m）”）
plt.ylabel（“Y距离（m）”）
项目名称（“X对Y”）
plt.legend（）
plt.show（）

---

我正在尝试用四阶龙格库塔方法来模拟一个绕地球运行的火箭。目标是最终打印出火箭的轨道。我还在想我的代码，所以他们还没开始工作。使用类将如何改进这一点？

将列表的引用保留在另一个数据结构中，然后循环使用该数据结构以立即删除所有内容：

for sublist in [X, Y, VX, VY, R, T, KE, PE, TE]:
    del sublist[i+1:]

编辑： 您希望使用类而不是列表

现在有九个列表，每个列表中的第i个元素对应于关于第i个火箭的属性。因此，您可以创建火箭类：

class Rocket:
    def __init__(self, X, Y, VX, VY, R, T, KE, PE, TE):
        self.X = X
        self.Y = Y
        self.VX = VX
        ...

这将允许您访问每个火箭的属性，如下所示：

Saturn_V = Rocket(1, 2, 3, 4, 5, 6, 7, 8, 9)
Saturn_V.X
>>>1

现在，您可以使用一个火箭列表，而不是九个单独的列表：

rocket_list = [Saturn_V, Sputnik, Atlas-Agena ...]

要删除有关特定火箭的所有信息，只需从列表中删除一个元素：

del rocket_list[0] #removes Saturn_V and all its attributes

---

好的，如果你想删除各种列表的最后一个元素，我将用一种非常简单的方式来解释。您可以将所有这些列表放在一个新列表中，然后应用循环删除最后一个元素。例如：

x=[1,2,3,4,5]
y=[1,2,3,4,5]
z=[1,2,3,4,5]
l=[x,y,z]
for i in range (len(l)):
    del l[i][-1]

---

这将删除所有列表中的最后一个元素。

以下是我在评论中试图解释的内容。虽然我不知道你正在做什么的细节，但希望这足以让你大致了解：

# Define a class to hold each group of values.
class Example:
    def __init__(x, y, vx, vy, r, t, ke, pe, te):
        self.x  = x
        self.y  = y
        self.vx = vx
        self.vy = vy
        self.r  = r
        self.t  = t
        self.ke = ke
        self.pe = pe
        self.te = te

# Somehow create a list of Example instances.
my_data = [Example(x1, y1, vx1, vy1, r1, t1, ke1, pe1, te1),
           Example(x2, y2, vx2, vy2, r2, t2, ke2, pe2, te2),
             ...
           Example(xN, yN, vxN, vyN, rN, tN, keN, peN, teN)]

# Then you could do what you asked about like this:
for i, elem in enumerate(my_data):
    if elem.ke > elem.pe:  # Done?
        break

del my_data[i+1:]  # Delete remaining elements in my_data.

---

是的，将列表存储在列表中。或者是口述什么的。为什么你的清单不相关？您的列表应该以某种方式存在于矩阵或列表列表中。也似乎是

[i+1:][/code>不一定是列表中的最后一个值，它应该是
[-1]
。你到底是什么意思？@user3613025在这种情况下，最好创建一个包含位置、速度、能量。。。每个人。退出Fortran编程风格，只使用绑定所有相关值的索引。我想你的意思是
del sublist[I+1:]
Lovely，这正是我想要的！非常感谢。乐意帮忙：）你的方法假设我会有很多火箭。我基本上有两个任务要做。第一个要求我生成火箭绕物体的轨道（我选择了地球）。第二项任务要求我绘制一张从地球到月球再返回地球的轨道图。我可以用这些属性为地球、月球和火箭创建一个“对象”类吗？对不起，我是Python的新手。如果你想看的话，我已经把所有的东西都贴在上面了？user3613025：在你的编辑中检查代码的时候，我注意到一件事情似乎是错误的，那就是子列表在[X，Y，VX，VY，R，T，KE，PE，TE]中的
位置：
循环，这与你接受的答案类似。问题是它在范围（1，N）内i的外部
循环中：
循环，这意味着它在每次迭代之后都会被执行，除非
break
条件为true。我认为它应该与
return
处于同一级别，因此它只运行一次，就在函数返回之前。user3613025：至于调整代码以执行类似于我的答案中的操作，因为您使用
numpy
，我建议在