Menghapus banyak elemen dari daftar

Apakah mungkin menghapus beberapa elemen sekaligus dari daftar? Jika saya ingin menghapus elemen pada indeks 0 dan 2, dan mencoba sesuatu seperti del somelist[0], diikuti oleh del somelist[2], pernyataan kedua sebenarnya akan dihapus somelist[3].

Saya kira saya selalu bisa menghapus elemen bernomor lebih tinggi terlebih dahulu, tetapi saya berharap ada cara yang lebih baik.

Anda dapat menggunakan enumeratedan menghapus nilai yang indeksnya cocok dengan indeks yang ingin Anda hapus:

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

Untuk beberapa alasan saya tidak suka jawaban di sini. Ya, mereka bekerja, tetapi sebenarnya sebagian besar dari mereka tidak menghapus elemen dalam daftar, bukan? (Tetapi membuat salinan dan kemudian mengganti yang asli dengan salinan yang diedit).

Kenapa tidak hapus saja indeks yang lebih tinggi dulu?

Apakah ada alasan untuk ini? Saya hanya akan melakukan:

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

Jika Anda benar-benar tidak ingin menghapus item mundur, maka saya kira Anda hanya harus deincrement nilai indeks yang lebih besar dari indeks yang dihapus terakhir (tidak dapat benar-benar menggunakan indeks yang sama karena Anda memiliki daftar yang berbeda) atau menggunakan salinan daftar (yang tidak akan 'dihapus' tetapi mengganti yang asli dengan salinan yang diedit).

Apakah saya kehilangan sesuatu di sini, ada alasan untuk TIDAK menghapus dalam urutan terbalik?

Jika Anda menghapus beberapa item yang tidak berdekatan, maka apa yang Anda gambarkan adalah cara terbaik (dan ya, pastikan untuk memulai dari indeks tertinggi).

Jika item Anda berdekatan, Anda dapat menggunakan sintaks penugasan slice:

a[2:10] = []

Anda dapat menggunakan numpy.deletesebagai berikut:

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

Jika Anda tidak keberatan berakhir dengan numpyarray di bagian akhir, Anda dapat meninggalkan .tolist(). Anda juga harus melihat peningkatan kecepatan yang cukup besar, menjadikan ini solusi yang lebih skalabel. Saya belum membandingkannya, tetapi numpyoperasi dikompilasi kode yang ditulis dalam C atau Fortran.

Sebagai spesialisasi jawaban Greg, Anda bahkan dapat menggunakan sintaks irisan yang diperluas. misalnya. Jika Anda ingin menghapus item 0 dan 2:

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

Tentu saja, ini tidak mencakup pemilihan yang sewenang-wenang, tetapi tentu saja dapat menghapus semua item.

Sebagai fungsi:

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

Berjalan dalam waktu n log (n) , yang seharusnya menjadikannya solusi tercepat tercepat.

Jadi, Anda pada dasarnya ingin menghapus beberapa elemen sekaligus? Dalam hal ini, posisi elemen berikutnya yang akan dihapus akan diimbangi dengan banyaknya yang dihapus sebelumnya.

Tujuan kami adalah menghapus semua vokal, yang diperhitungkan sebagai indeks 1, 4, dan 7. Perhatikan bahwa yang penting adalah indeks to_delete dalam urutan menaik, jika tidak maka tidak akan berfungsi.

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

Akan lebih rumit jika Anda ingin menghapus elemen dalam urutan apa pun. IMO, menyortir to_deletemungkin lebih mudah daripada mencari tahu kapan Anda harus atau tidak harus mengurangi index.

Saya seorang pemula total dalam Python, dan pemrograman saya saat ini adalah kasar dan kotor untuk sedikitnya, tetapi solusi saya adalah dengan menggunakan kombinasi dari perintah dasar yang saya pelajari di tutorial awal:

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

Jelas, karena harus memilih karakter "mark-for-deletion", ini memiliki keterbatasan.

Adapun kinerja sebagai ukuran daftar skala, saya yakin solusi saya tidak optimal. Namun, ini mudah, yang saya harap menarik bagi pemula lain, dan akan bekerja dalam kasus-kasus sederhana di mana some_listadalah format yang terkenal, misalnya, selalu numerik ...

Berikut ini adalah alternatif, yang tidak menggunakan enumerate () untuk membuat tupel (seperti dalam jawaban asli SilentGhost).

Ini sepertinya lebih mudah dibaca oleh saya. (Mungkin saya akan merasa berbeda jika saya terbiasa menggunakan penghitungan.) CAVEAT: Saya belum menguji kinerja dari dua pendekatan.

# 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 ]

CATATAN: Sintaks Python 2.7. Untuk Python 3, xrange=> range.

Pemakaian:

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

somelist:

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

--- BONUS ---

Hapus beberapa nilai dari daftar. Artinya, kami memiliki nilai yang ingin kami hapus:

# 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 ]

Pemakaian:

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

somelist:

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

Ini adalah jawaban yang sama seperti sebelumnya, tetapi kali ini kami menyediakan NILAI yang akan dihapus [0, 44, 55].

Metode pemahaman daftar alternatif yang menggunakan nilai indeks daftar:

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]

Ini mengembalikan:

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

di sini adalah metode lain yang menghilangkan elemen di tempatnya. juga jika daftar Anda sangat panjang, lebih cepat.

>>> 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

Ini telah disebutkan, tetapi entah bagaimana tidak ada yang berhasil melakukannya dengan benar.

Pada O(n)solusi akan menjadi:

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

Ini sangat dekat dengan versi SilentGhost , tetapi menambahkan dua kawat gigi.

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])

Ini pada dasarnya sama dengan jawaban terpilih, hanya cara penulisan yang berbeda. Perhatikan bahwa menggunakan l.index () bukan ide yang baik, karena ia tidak dapat menangani elemen yang digandakan dalam daftar.

Metode penghapusan akan menyebabkan banyak pergeseran elemen daftar. Saya pikir lebih baik membuat salinan:

...
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
...

secara teknis, jawabannya TIDAK, tidak mungkin menghapus dua objek PADA SAAT YANG SAMA. Namun, itu mungkin untuk menghapus dua objek dalam satu baris python yang indah.

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

akan secara berulang menghapus foo['bar'], kemudianfoo['baz']

kita dapat melakukan ini dengan menggunakan perulangan for iterating di atas indeks setelah mengurutkan daftar indeks dalam urutan menurun

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

Untuk indeks 0 dan 2 dari listA:

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

Untuk beberapa indeks acak untuk dihapus dari listA:

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

Saya ingin cara untuk membandingkan berbagai solusi yang membuatnya mudah untuk memutar kenop.

Pertama saya menghasilkan data saya:

import random

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

Lalu saya mendefinisikan fungsi saya:

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)

Kemudian saya timeitmembandingkan solusi:

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)

Keluaran

set =   1.711
del =   3.450
pop =   3.618

Jadi generator dengan indeks dalam setadalah pemenangnya. Dan delsedikit lebih cepat pop.

Anda dapat menggunakan logika ini:

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

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

print c

Implementasi lain dari gagasan menghapus dari indeks tertinggi.

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

Saya benar-benar dapat memikirkan dua cara untuk melakukannya:

1. iris daftar seperti (ini menghapus elemen 1, 3 dan 8)

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

2. lakukan itu di tempat, tetapi satu per satu:

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

Anda dapat melakukannya dengan cara dict, bukan pada daftar. Dalam daftar, elemen-elemen berada dalam urutan. Dict mereka hanya bergantung pada indeks.

Kode sederhana hanya untuk menjelaskannya dengan melakukan :

>>> 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'

Cara untuk "mengonversi" daftar dalam suatu dikt adalah:

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

Kebalikannya adalah:

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

Pokoknya saya pikir lebih baik untuk mulai menghapus dari indeks yang lebih tinggi seperti yang Anda katakan.

Untuk menggeneralisasi komentar dari @sth . Penghapusan item dalam kelas apa pun, yang mengimplementasikan abc.MutableSequence , dan listkhususnya, dilakukan melalui __delitem__metode ajaib. Metode ini bekerja mirip dengan __getitem__, artinya dapat menerima integer atau slice. Berikut ini sebuah contoh:

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)

Ini akan menampilkan

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

Mengimpornya hanya karena alasan ini mungkin berlebihan, tetapi jika Anda pandastetap menggunakannya , maka solusinya sederhana dan langsung:

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)])

Menghindari biaya penyortiran dan harus menyalin daftar secara eksplisit.

Bagaimana dengan salah satu dari ini (saya sangat baru di Python, tetapi tampaknya ok):

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)

['Atlantik', 'Pasifik', 'India']

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)

['Atlantik', 'Pasifik', 'India']

Tidak ada jawaban yang ditawarkan sejauh ini melakukan penghapusan di tempat pada O (n) pada panjang daftar untuk sejumlah indeks sewenang-wenang untuk dihapus, jadi inilah versi saya:

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]

Anda dapat menggunakan hapus juga.

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)

Saya menggabungkan semuanya menjadi list_difffungsi yang hanya mengambil dua daftar sebagai input dan mengembalikan perbedaannya, sambil mempertahankan urutan asli dari daftar pertama.

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)

Penggunaan sampel:

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']