Xóa nhiều yếu tố khỏi danh sách

Có thể xóa nhiều yếu tố từ một danh sách cùng một lúc? Nếu tôi muốn xóa các phần tử ở chỉ số 0 và 2, và thử một cái gì đó như del somelist[0], theo sau del somelist[2], câu lệnh thứ hai sẽ thực sự xóa somelist[3].

Tôi cho rằng tôi luôn có thể xóa các yếu tố được đánh số cao hơn trước nhưng tôi hy vọng có một cách tốt hơn.

Có lẽ không phải là giải pháp tốt nhất cho vấn đề này:

indices = 0, 2
somelist = [i for j, i in enumerate(somelist) if j not in indices]

Vì một số lý do tôi không thích bất kỳ câu trả lời nào ở đây. Vâng, họ làm việc, nhưng nói đúng ra hầu hết trong số họ không xóa các yếu tố trong danh sách, phải không? (Nhưng tạo một bản sao và sau đó thay thế bản gốc bằng bản sao đã chỉnh sửa).

Tại sao không xóa chỉ số cao hơn trước?

Có một lý do cho điều này? Tôi sẽ chỉ làm:

for i in sorted(indices, reverse=True):
    del somelist[i]

Nếu bạn thực sự không muốn xóa các mục ngược lại, thì tôi đoán bạn chỉ nên hủy bỏ các giá trị chỉ số lớn hơn chỉ mục đã xóa cuối cùng (không thực sự sử dụng cùng một chỉ mục vì bạn có một danh sách khác) hoặc sử dụng một bản sao của danh sách (sẽ không 'xóa' mà thay thế bản gốc bằng một bản sao đã chỉnh sửa).

Tôi có thiếu một cái gì đó ở đây không, lý do nào để KHÔNG xóa theo thứ tự ngược lại?

Nếu bạn đang xóa nhiều mục không liền kề, thì những gì bạn mô tả là cách tốt nhất (và có, hãy chắc chắn bắt đầu từ chỉ mục cao nhất).

Nếu các mục của bạn liền kề, bạn có thể sử dụng cú pháp gán lát:

a[2:10] = []

Bạn có thể sử dụng numpy.deletenhư sau:

import numpy as np
a = ['a', 'l', 3.14, 42, 'u']
I = [0, 2]
np.delete(a, I).tolist()
# Returns: ['l', '42', 'u']

Nếu bạn không phiền khi kết thúc với một numpymảng ở cuối, bạn có thể bỏ qua .tolist(). Bạn cũng sẽ thấy một số cải tiến tốc độ khá lớn, làm cho điều này trở thành một giải pháp mở rộng hơn. Tôi đã không điểm chuẩn nó, nhưng các numpyhoạt động được biên dịch mã được viết bằng C hoặc Fortran.

Là một chuyên ngành của câu trả lời của Greg, bạn thậm chí có thể sử dụng cú pháp lát mở rộng. ví dụ. Nếu bạn muốn xóa các mục 0 và 2:

>>> a= [0, 1, 2, 3, 4]
>>> del a[0:3:2]
>>> a
[1, 3, 4]

Tất nhiên, điều này không bao gồm bất kỳ lựa chọn tùy ý nào, nhưng chắc chắn nó có thể hoạt động để xóa bất kỳ hai mục nào.

Là một chức năng:

def multi_delete(list_, *args):
    indexes = sorted(list(args), reverse=True)
    for index in indexes:
        del list_[index]
    return list_

Chạy trong n log (n) time, điều này sẽ làm cho nó trở thành giải pháp chính xác nhanh nhất.

Vì vậy, về cơ bản bạn muốn xóa nhiều yếu tố trong một lần? Trong trường hợp đó, vị trí của phần tử tiếp theo cần xóa sẽ được bù lại tuy nhiên nhiều phần đã bị xóa trước đó.

Mục tiêu của chúng tôi là xóa tất cả các nguyên âm, được tính toán trước thành các chỉ số 1, 4 và 7. Lưu ý rằng các chỉ số to_delete quan trọng của nó là theo thứ tự tăng dần, nếu không nó sẽ không hoạt động.

to_delete = [1, 4, 7]
target = list("hello world")
for offset, index in enumerate(to_delete):
  index -= offset
  del target[index]

Sẽ phức tạp hơn nếu bạn muốn xóa các thành phần theo bất kỳ thứ tự nào. IMO, sắp xếp to_deletecó thể dễ dàng hơn là tìm ra khi nào bạn nên hoặc không nên trừ đi index.

Tôi là người mới bắt đầu hoàn toàn với Python và lập trình của tôi lúc này rất thô sơ và bẩn thỉu, nhưng giải pháp của tôi là sử dụng kết hợp các lệnh cơ bản mà tôi đã học được trong các hướng dẫn ban đầu:

some_list = [1,2,3,4,5,6,7,8,10]
rem = [0,5,7]

for i in rem:
    some_list[i] = '!' # mark for deletion

for i in range(0, some_list.count('!')):
    some_list.remove('!') # remove
print some_list

Rõ ràng, vì phải chọn một nhân vật "đánh dấu để xóa", điều này có những hạn chế.

Đối với hiệu suất như kích thước của thang đo danh sách, tôi chắc chắn rằng giải pháp của tôi là tối ưu phụ. Tuy nhiên, điều đó đơn giản, mà tôi hy vọng sẽ hấp dẫn những người mới bắt đầu khác, và sẽ hoạt động trong những trường hợp đơn giản có some_listđịnh dạng nổi tiếng, ví dụ: luôn luôn là số ...

Đây là một cách thay thế, không sử dụng enum Cả () để tạo các bộ dữ liệu (như trong câu trả lời ban đầu của SilentGhost).

Điều này có vẻ dễ đọc hơn đối với tôi. (Có lẽ tôi sẽ cảm thấy khác đi nếu tôi có thói quen sử dụng liệt kê.) CAVEAT: Tôi chưa thử nghiệm hiệu suất của hai phương pháp.

# Returns a new list. "lst" is not modified.
def delete_by_indices(lst, indices):
    indices_as_set = set(indices)
    return [ lst[i] for i in xrange(len(lst)) if i not in indices_as_set ]

LƯU Ý: Cú pháp Python 2.7. Đối với Python 3, xrange=> range.

Sử dụng:

lst = [ 11*x for x in xrange(10) ]
somelist = delete_by_indices( lst, [0, 4, 5])

nhà thờ

[11, 22, 33, 66, 77, 88, 99]

--- TẶNG KEM ---

Xóa nhiều giá trị khỏi danh sách. Đó là, chúng tôi có các giá trị chúng tôi muốn xóa:

# Returns a new list. "lst" is not modified.
def delete__by_values(lst, values):
    values_as_set = set(values)
    return [ x for x in lst if x not in values_as_set ]

Sử dụng:

somelist = delete__by_values( lst, [0, 44, 55] )

nhà thờ

[11, 22, 33, 66, 77, 88, 99]

Đây là câu trả lời giống như trước đây, nhưng lần này chúng tôi đã cung cấp các GIÁ TRỊ sẽ bị xóa [0, 44, 55].

Một phương pháp hiểu danh sách thay thế sử dụng các giá trị chỉ mục danh sách:

stuff = ['a', 'b', 'c', 'd', 'e', 'f', 'woof']
index = [0, 3, 6]
new = [i for i in stuff if stuff.index(i) not in index]

Điều này trả về:

['b', 'c', 'e', 'f']

đây là một phương pháp khác loại bỏ các yếu tố tại chỗ. Ngoài ra nếu danh sách của bạn thực sự dài, nó sẽ nhanh hơn.

>>> a = range(10)
>>> remove = [0,4,5]
>>> from collections import deque
>>> deque((list.pop(a, i) for i in sorted(remove, reverse=True)), maxlen=0)

>>> timeit.timeit('[i for j, i in enumerate(a) if j not in remove]', setup='import random;remove=[random.randrange(100000) for i in range(100)]; a = range(100000)', number=1)
0.1704120635986328

>>> timeit.timeit('deque((list.pop(a, i) for i in sorted(remove, reverse=True)), maxlen=0)', setup='from collections import deque;import random;remove=[random.randrange(100000) for i in range(100)]; a = range(100000)', number=1)
0.004853963851928711

Điều này đã được đề cập, nhưng bằng cách nào đó không ai quản lý để thực sự làm cho nó đúng.

Về O(n)giải pháp sẽ là:

indices = {0, 2}
somelist = [i for j, i in enumerate(somelist) if j not in indices]

Điều này thực sự gần với phiên bản của SilentGhost , nhưng thêm hai dấu ngoặc nhọn.

l = ['a','b','a','c','a','d']
to_remove = [1, 3]
[l[i] for i in range(0, len(l)) if i not in to_remove])

Về cơ bản nó giống như câu trả lời được bình chọn hàng đầu, chỉ là một cách viết khác. Lưu ý rằng sử dụng l.index () không phải là ý hay, vì nó không thể xử lý các phần tử trùng lặp trong danh sách.

Phương thức loại bỏ sẽ gây ra rất nhiều sự thay đổi của các yếu tố danh sách. Tôi nghĩ là tốt hơn để tạo một bản sao:

...
new_list = []
for el in obj.my_list:
   if condition_is_true(el):
      new_list.append(el)
del obj.my_list
obj.my_list = new_list
...

về mặt kỹ thuật, câu trả lời là KHÔNG, không thể xóa hai đối tượng TẠI THỜI GIAN. Tuy nhiên, có thể xóa hai đối tượng trong một dòng trăn đẹp.

del (foo['bar'],foo['baz'])

sẽ xóa một cách rõ ràng foo['bar'], sau đófoo['baz']

chúng ta có thể làm điều này bằng cách sử dụng vòng lặp for lặp qua các chỉ mục sau khi sắp xếp danh sách chỉ mục theo thứ tự giảm dần

mylist=[66.25, 333, 1, 4, 6, 7, 8, 56, 8769, 65]
indexes = 4,6
indexes = sorted(indexes, reverse=True)
for i in index:
    mylist.pop(i)
print mylist

Đối với các chỉ số 0 và 2 từ listA:

for x in (2,0): listA.pop(x)

Đối với một số chỉ số ngẫu nhiên để xóa khỏi listA:

indices=(5,3,2,7,0) 
for x in sorted(indices)[::-1]: listA.pop(x)

Tôi muốn một cách để so sánh các giải pháp khác nhau giúp dễ dàng xoay núm.

Đầu tiên tôi tạo dữ liệu của mình:

import random

N = 16 * 1024
x = range(N)
random.shuffle(x)
y = random.sample(range(N), N / 10)

Sau đó, tôi xác định chức năng của mình:

def list_set(value_list, index_list):
    index_list = set(index_list)
    result = [value for index, value in enumerate(value_list) if index not in index_list]
    return result

def list_del(value_list, index_list):
    for index in sorted(index_list, reverse=True):
        del(value_list[index])

def list_pop(value_list, index_list):
    for index in sorted(index_list, reverse=True):
        value_list.pop(index)

Sau đó, tôi sử dụng timeitđể so sánh các giải pháp:

import timeit
from collections import OrderedDict

M = 1000
setup = 'from __main__ import x, y, list_set, list_del, list_pop'
statement_dict = OrderedDict([
    ('overhead',  'a = x[:]'),
    ('set', 'a = x[:]; list_set(a, y)'),
    ('del', 'a = x[:]; list_del(a, y)'),
    ('pop', 'a = x[:]; list_pop(a, y)'),
])

overhead = None
result_dict = OrderedDict()
for name, statement in statement_dict.iteritems():
    result = timeit.timeit(statement, number=M, setup=setup)
    if overhead is None:
        overhead = result
    else:
        result = result - overhead
        result_dict[name] = result

for name, result in result_dict.iteritems():
    print "%s = %7.3f" % (name, result)

Đầu ra

set =   1.711
del =   3.450
pop =   3.618

Vì vậy, máy phát điện với các chỉ số trong a setlà người chiến thắng. Và delnhanh hơn một chút rồi pop.

Bạn có thể sử dụng logic này:

my_list = ['word','yes','no','nice']

c=[b for i,b in enumerate(my_list) if not i in (0,2,3)]

print c

Một thực hiện khác của ý tưởng loại bỏ từ chỉ số cao nhất.

for i in range(len(yourlist)-1, -1, -1):
    del yourlist(i)

Tôi thực sự có thể nghĩ ra hai cách để làm điều đó:

1. cắt danh sách như thế nào (phần này sẽ xóa các phần tử thứ 1, 3 và 8)

   somelist = somelist [1: 2] + somelist [3: 7] + somelist [8:]

2. làm điều đó tại chỗ, nhưng mỗi lần một:

   somelist.pop (2) somelist.pop (0)

Bạn có thể làm theo cách đó trên một dict, không phải trong danh sách. Trong một danh sách các yếu tố được theo thứ tự. Trong một dict họ chỉ phụ thuộc vào chỉ số.

Mã đơn giản chỉ để giải thích nó bằng cách làm :

>>> lst = ['a','b','c']
>>> dct = {0: 'a', 1: 'b', 2:'c'}
>>> lst[0]
'a'
>>> dct[0]
'a'
>>> del lst[0]
>>> del dct[0]
>>> lst[0]
'b'
>>> dct[0]
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    dct[0]
KeyError: 0
>>> dct[1]
'b'
>>> lst[1]
'c'

Một cách để "chuyển đổi" danh sách trong một dict là:

>>> dct = {}
>>> for i in xrange(0,len(lst)): dct[i] = lst[i]

Nghịch đảo là:

lst = [dct[i] for i in sorted(dct.keys())] 

Dù sao, tôi nghĩ tốt hơn là bắt đầu xóa từ chỉ số cao hơn như bạn đã nói.

Để khái quát nhận xét từ @sth . Việc xóa vật phẩm trong bất kỳ lớp nào, thực hiện abc.MutableSequence , và listđặc biệt, được thực hiện thông qua __delitem__phương thức ma thuật. Phương thức này hoạt động tương tự __getitem__, có nghĩa là nó có thể chấp nhận một số nguyên hoặc một lát. Đây là một ví dụ:

class MyList(list):
    def __delitem__(self, item):
        if isinstance(item, slice):
            for i in range(*item.indices(len(self))):
                self[i] = 'null'
        else:
            self[item] = 'null'


l = MyList(range(10))
print(l)
del l[5:8]
print(l)

Điều này sẽ xuất

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 'null', 'null', 'null', 8, 9]

Chỉ nhập nó vì lý do này có thể là quá mức cần thiết, nhưng nếu bạn vẫn đang sử dụng pandas, thì giải pháp rất đơn giản và dễ hiểu:

import pandas as pd
stuff = pd.Series(['a','b','a','c','a','d'])
less_stuff = stuff[stuff != 'a']  # define any condition here
# results ['b','c','d']

some_list.remove(some_list[max(i, j)])

Tránh chi phí sắp xếp và phải sao chép rõ ràng danh sách.

Còn một trong số này (tôi rất mới với Python, nhưng chúng có vẻ ổn):

ocean_basin = ['a', 'Atlantic', 'Pacific', 'Indian', 'a', 'a', 'a']
for i in range(1, (ocean_basin.count('a') + 1)):
    ocean_basin.remove('a')
print(ocean_basin)

['Đại Tây Dương', 'Thái Bình Dương', 'Ấn Độ']

ob = ['a', 'b', 4, 5,'Atlantic', 'Pacific', 'Indian', 'a', 'a', 4, 'a']
remove = ('a', 'b', 4, 5)
ob = [i for i in ob if i not in (remove)]
print(ob)

['Đại Tây Dương', 'Thái Bình Dương', 'Ấn Độ']

Không có câu trả lời nào được cung cấp cho đến nay thực hiện việc xóa tại chỗ trong O (n) trên độ dài của danh sách cho một số chỉ số tùy ý để xóa, vì vậy đây là phiên bản của tôi:

def multi_delete(the_list, indices):
    assert type(indices) in {set, frozenset}, "indices must be a set or frozenset"
    offset = 0
    for i in range(len(the_list)):
        if i in indices:
            offset += 1
        elif offset:
            the_list[i - offset] = the_list[i]
    if offset:
        del the_list[-offset:]

# Example:
a = [0, 1, 2, 3, 4, 5, 6, 7]
multi_delete(a, {1, 2, 4, 6, 7})
print(a)  # prints [0, 3, 5]

Bạn có thể sử dụng loại bỏ, quá.

delete_from_somelist = []
for i in [int(0), int(2)]:
     delete_from_somelist.append(somelist[i])
for j in delete_from_somelist:
     newlist = somelist.remove(j)

Tôi kết hợp tất cả lại với nhau thành một list_diffhàm chỉ đơn giản lấy hai danh sách làm đầu vào và trả về sự khác biệt của chúng, trong khi vẫn giữ nguyên thứ tự ban đầu của danh sách đầu tiên.

def list_diff(list_a, list_b, verbose=False):

    # returns a difference of list_a and list_b,
    # preserving the original order, unlike set-based solutions

    # get indices of elements to be excluded from list_a
    excl_ind = [i for i, x in enumerate(list_a) if x in list_b]
    if verbose:
        print(excl_ind)

    # filter out the excluded indices, producing a new list 
    new_list = [i for i in list_a if list_a.index(i) not in excl_ind]
    if verbose:
        print(new_list)

    return(new_list)

Sử dụng mẫu:

my_list = ['a', 'b', 'c', 'd', 'e', 'f', 'woof']
# index = [0, 3, 6]

# define excluded names list
excl_names_list = ['woof', 'c']

list_diff(my_list, excl_names_list)
>> ['a', 'b', 'd', 'e', 'f']