Question

我正在尝试解决一个听起来像这样的任务：

''写一个函数modi（la，lb），它接受输入2列表la和lb，里面有相同数量的元素。该函数应该修改列出la和lb camparing元素，在两个列表中使用相同的索引并删除更大的一个，如果元素相等，则删除它们。 ''

例如：

la = ['bear'，'tiger'，'wolf'，'whale'，'elephant']
lb = ['swan'，'cat'，'dog'，'duck'，'rabbit']

所以功能区应该返回： [ '承担'， '象'] [ '猫'， '狗'， '鸭']

我已经编写了下一个代码，但它不会修改列表，而是创建新的列表并添加元素。一些想法我怎么能这样做？

def confront(s1, s2):   

    if s1 < s2:   # condition that tells which element to choose later
        return 0
    elif s2 < s1:
        return 1
    else:
        return 2


def modi(la,lb):

    latemp = []

    lbtemp = []

    i = 0

    while i < len(la):


        q = confront(la[i], lb[i])
        if q == 0:
            latemp.append(la[i])

        elif q == 1:
            lbtemp.append(lb[i])


        i +=1  
    la = latemp
    lb = lbtemp
    return la, lb

我尝试过remove（）但是它造成了很大的混乱

Answer 1

您应该使用del删除列表项。此外，您应该从头到尾迭代，因为如果您将从头开始并删除，请说1st元素，3rd位置上的元素现在将在2nd < / p>

应该看起来像

#you need to handle what if len of lists is 0, if lens are not the same and so on...
def compare_and_delete(list1, list2):
    i = len(list1) -1
    while i >= 0:
        if list1[i] > list2[i]:
            del list1[i]
        elif list2[i] > list1[i]:
            del list2[i]
        else:
            del list1[i]
            del list2[i]

        i-=1

        return list1, list2

l1, l2 = compare_and_delete(['bear', 'tiger', 'wolf', 'whale', 'elephant'], ['swan', 'cat', 'dog', 'duck', 'rabbit'])

Answer 2

通常，当您在迭代列表时改变列表时。重复迭代副本是一种很好的做法。下面是你要改变一个列表的例子。

list = []
list_copy = list[:]
for i in list_copy:
    list.remove(i)
return list

这允许您在每次迭代时保持正确的索引。

以下是我尝试解释我的意思并使用for循环来获得预期结果。希望它有所帮助。

def confront(s1, s2):

if s1 < s2:   # condition that tells which element to choose later
    return 0
elif s2 < s1:
    return 1
else:
    return 2


def modi(la,lb):
    la_copy = la[:]
    lb_copy = lb[:]

    for i in range(len(la_copy)):
        q = confront(la_copy[i], lb_copy[i])
        if q == 0:
            lb.remove(lb_copy[i])
        elif q == 1:
            la.remove(la_copy[i])

    return la, lb


la = ['bear', 'tiger', 'wolf', 'whale', 'elephant']
lb = ['swan', 'cat', 'dog', 'duck', 'rabbit']

通过print（）调用它将获得返回的两个列表。

注意：这会返回一个元组。如果你想要单独的列表，请通过以下方式调用它。

list1, list2 = modi(la,lb)
print(list1)
print(list2)
['bear', 'elephant']
['cat', 'dog', 'duck']

Answer 3

这将解决您的问题。我认为它比所有其他解决方案都容易。

def modi(la, lb):
    new_la = []
    new_lb = []
    for a, b in zip(la, lb):
        if a == b:
            continue
        if a > b:
            new_lb.append(b)
        if a < b:
            new_la.append(a)
    return new_la, new_lb

但是，如果您想要更改现有列表，则可以执行以下操作：

def modi(la, lb):
    del_la = []
    del_lb = []
    for i, (a, b) in enumerate(zip(la, lb)):
        if a == b:
            del_la.append(i)
            del_lb.append(i)
        if a > b:
            del_la.append(i)
        if a < b:
            del_lb.append(i)
    for x in del_la[-1::-1]:
        del la[x]
    for x in del_lb[-1::-1]:
        del lb[x]
    return la, lb

Answer 4

在您自己的代码la = latemp和lb = lbtemp中创建引用到函数本地的两个新列表，它们与您传入的列表无关到功能。根据您的规范，您应该改变传递的列表，而不是重新分配或创建新列表。

由于您正在进行元素比较，您可以使用 zip 并根据您的规范从每个列表中删除：

def modi(la, lb):
    for i, j in zip(la, lb):
        # both the same
        if i == j:
            la.remove(i) 
            lb.remove(i)
        # element from la is bigger
        elif i > j:
            la.remove(i)
        # else element from lb must be bigger
        else:
            lb.remove(j)


la = ['bear', 'tiger', 'wolf', 'whale', 'elephant']
lb = ['swan', 'cat', 'dog', 'duck', 'rabbit']

modi(la, lb) # will modify the lists passed in.

print(la, lb)

Answer 5

基本上，您需要跟踪从每个列表中删除的次数，并将索引偏移量。这是一个基本方法：

>>> a
['bear', 'tiger', 'wolf', 'whale', 'elephant']
>>> b
['swan', 'cat', 'dog', 'duck', 'rabbit']
>>> i = j = 0
>>> for k, (str1,str2) in enumerate(zip(a,b)):
...     if len(str1) == len(str2):
...         del a[k-i], b[k-j]
...         i += 1
...         j += 1
...     elif len(str1) > len(str2):
...         del a[k-i]
...         i += 1
...     else:
...         del b[k-j]
...         j += 1
... 
>>> a
[]
>>> b
['cat', 'dog', 'duck', 'rabbit']
>>>

Answer 6

您可以利用分配给切片修改列表的事实：

la[:] = latemp
lb[:] = lbtemp

修改列表删除元素而不会弄乱

6 个答案: