Python 使用while循环从列表中删除负数

rmNegative（L）

从

列表L

中删除负数，假设负数只包含数字元素。（修改L；不创建新列表。）

当使用while循环时，我将如何进行此操作？我试过一遍又一遍地编码，我得到的只是一个永无止境的循环

def rmNegatives(L):
    pos=len(L)-1
    while pos>-1:
        pos=pos
        if pos<len(L)-1:
            pos=pos
            if L[pos]>0:
                L[:]=L[:]
                pos=len(L)-2
            elif L[pos]<0:
                L[:]=[L[pos]]+L[0:]
                L[:]=L[1:]
                pos=len(L)-1

        elif pos==len(L)-1:
            pos=pos
            if L[pos]<0:
                L[0:]=L[0:pos]
                pos=len(L)-1
            elif L[pos]>0:
                L[:]=L[:]
                pos=len(L)-2

rmNegatives([-25,31,-10,23,45,-2])

def rmNegatives（L）：
位置=透镜（L）-1
而pos>-1：
pos=pos
如果pos0：
L[：]=L[：]
位置=透镜（L）-2
elif L[pos]嗯，现在不分配新列表

>>> list_l = [1, -1, 2, -8]

>>> length = len(list_l)
>>> while i < length:
...     if list_l[i] < 0:
...             del list_l[i]
...             length -= 1
...     else:
...             i = i + 1
... 
>>> list_l
[1, 2]

列表[1，-1,2，-8]
>>>长度=长度（列表）
>>>而我<长度：
...     如果列表\u l[i]<0：
...             删除列表[i]
...             长度-=1
...     其他：
...             i=i+1
... 
>>>列表
[1, 2]

以下是我对

rmNegative（L）

的实现

def rmNegative（L）：
m=最小（L）
当m<0时：
L.移除（m）
m=最小（L）

---

这会修改列表，而不会创建新列表。

这里是一个带有while循环的实现。我从末尾开始，因为随着循环的迭代，列表越来越短，而早期的索引也随之移动

def rmNegative(L):
    index = len(L) - 1
    while index >= 0:
        if L[index] < 0:
            del L[index]
        index = index - 1

def rmNegative（L）：
指数=len（L）-1
当索引>=0时：
如果L[索引]<0：
德尔L[索引]
索引=索引-1

如果您绝对无法创建新列表，并且必须在循环时使用

：

l = [1,2,3,-1,-2,-3,4,5]
x = 0
while x < len(l):
  if l[x] < 0:
    l.remove(l[x])
    continue
  x += 1

l = [1,2,3,-1,-2,-3,4,5]
for x in xrange(len(l)):
  if x < len(l) and l[x] < 0:
    l.remove(l[x])

如果您有能力创建新列表：

l = [1,2,3,-1,-2,-3,4,5]
l = [num for num in l if num >= 0]

您首先需要知道的是，
dell[i]
删除了
i
th元素。（不要使用
L.remove（L[i]）
；它查找
i
th元素，然后搜索整个列表，直到找到一个相等的值，然后删除该值。）

但是请注意，如果您删除
L[3]
，然后转到
L[4]
，您已经跳过了一个值，原来的
L[4]
现在是
L[3]
，您仍然需要检查它。因此，在找到要保留的值之前，必须确保不要增加
i

但是如果你只是在所有的索引上循环，并且在过程中删除了一些索引，那么你就要结束了。因此，每次删除时都需要减小长度。或者，您也可以继续再次调用
len（L）
，每次都检查新的长度

同时解决这两个问题的一个聪明方法是倒数，如在中。但这会使fencepost容易出错。所以，我会用另一种方式

def rmNegative(L):
    length = len(L)
    i = 0
    while i < length:
        if L[i] < 0:
            del L[i]
            length -= 1
        else:
            i += 1

def rmNegative（L）：
长度=长度（L）
i=0
而我<长度：
如果L[i]<0：
德尔L[i]
长度-=1
其他：
i+=1

就这样


如果您想知道为什么现有代码是一个无限循环，那么让我们逐步了解一下它的作用

我们从
pos=len（L）-1开始，然后进入大
elif
pos=pos
不执行任何操作。如果是负数，则删除它并转到新的
len（L）-1
；如果它是一个正数，请保留它，然后转到
len（L）-2
。如果它是0，我们两个都不做，这意味着仍然是
pos=len（L）-1
，我们将永远重复地看这个0

这是获得无限循环的一种方法。但我们假设它不是以0结尾的

如果我们刚刚删除了一个负数，我们返回到
elif
，我们知道这是可以的，除非0

但是如果我们留下了一个正数，那么我们现在有了
pos=len（L）-2
，所以我们转到
if
。同样，
pos=pos
什么也不做。如果它是一个正数，我们将列表复制到它自己，它不做任何事情，然后设置
pos=len（L）-2
。这和现在的情况是一样的。所以，如果倒数第二个数字是正数，我们将永远关注这个数字。这是获得无限循环的另一种方法

如果是阴性呢？然后，
L[：]=[L[pos]]+L[0:
将要删除的值预先添加到整个列表中（其中仍然包括该值的原始副本），
L[：]=L[1::
删除刚才添加的值，因此，您在开始时的
L
中得到相同的值。然后设置
pos=len（L）-1
，返回列表末尾。我们知道这会成功，然后再次回到下一个到最后一个插槽，这仍然是相同的值，因此我们将永远来回穿梭。这就足够得到一个无限循环了

如果是0呢？然后我们什么也不做，所以
pos
和
L
永远不会改变，所以这是获得无限循环的另一种方法

因此，一旦我们在列表的末尾得到一个正元素，下一个到最后一个元素的所有三种可能性都是无限循环

退一步说，您的代码唯一设置的
pos
是
len（L）-1
和
len（L）-2
。所以，即使你把其他所有的事情都做对了，这怎么可能在一个包含2个以上非负数的列表中完成呢？
代码：

def rmNegatives(L):
    i = 0
    while i < len(L):
        if L[i] < 0:
            L.pop(i)
        else:
            i += 1
    return L

def rmNegatives（L）：
i=0
而我
您的列表不适合我，没有显示代码。你可以把你的代码放在你的帖子里。当然，我编辑了它等待批准。看起来第一块是评论？我在第一次编辑时错过了
'
。也许最好只显示将要运行的代码？是否希望我们调试现有代码？我真的不知道它的大部分试图做什么，所以很难说它哪里出了问题。例如，您希望
pos=pos
或
L[：]=L[：]
做什么？为什么
pos=len（L）-2
？这将创建一个新列表并覆盖旧引用。使用循环可能是课程的一部分。现在请告诉我，我遇到了什么问题
def rmNegative(L):
    length = len(L)
    i = 0
    while i < length:
        if L[i] < 0:
            del L[i]
            length -= 1
        else:
            i += 1

def rmNegatives(L):
    i = 0
    while i < len(L):
        if L[i] < 0:
            L.pop(i)
        else:
            i += 1
    return L