Listeden bir öğeyi dizine göre kaldırma

Python'daki bir listeden bir öğeyi nasıl kaldırabilirim?

list.removeYöntemi buldum , ancak son öğeyi kaldırmak istediğimi söyleyin, bunu nasıl yaparım? Varsayılan kaldırma listeyi arar gibi görünüyor, ancak herhangi bir arama yapılmasını istemiyorum.

delSilmek istediğiniz öğenin dizinini kullanın ve belirtin:

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del a[-1]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8]

Dilimleri de destekler:

>>> del a[2:4]
>>> a
[0, 1, 4, 5, 6, 7, 8, 9]

İşte öğreticinin bölümü.

Muhtemelen siz istersiniz pop:

a = ['a', 'b', 'c', 'd']
a.pop(1)

# now a is ['a', 'c', 'd']

Varsayılan olarak, pophiçbir bağımsız değişken olmadan son öğeyi kaldırır:

a = ['a', 'b', 'c', 'd']
a.pop()

# now a is ['a', 'b', 'c']

Diğerleri de belirtildiği gibi pop ve del şunlardır verilen dizinin bir öğeyi kaldırmak için etkili yollar. Ancak sadece tamamlama uğruna (aynı şey Python'da birçok yolla yapılabilir):

Dilimleri kullanma (bu, öğenin orijinal listeden kaldırılmasını sağlamaz):

(Ayrıca bu Python listesiyle çalışırken en az etkili yöntem olacaktır, ancak pop'u desteklemeyen, ancak a tanımlayan kullanıcı tanımlı nesnelerle çalışırken bu yararlı olabilir (ancak verimli değil, tekrar ediyorum) __getitem__):

>>> a = [1, 2, 3, 4, 5, 6]
>>> index = 3 # Only positive index

>>> a = a[:index] + a[index+1 :]
# a is now [1, 2, 3, 5, 6]

Not: Bu yöntemin, popve gibi yerdeki listeyi değiştirmediğini lütfen unutmayın del. Bunun yerine, listelerin iki kopyasını oluşturur (biri başlangıçtan dizine kadar ancak onsuz ( a[:index]) ve dizinden sonra son öğeye ( a[index+1:]) kadar) ve her ikisini de ekleyerek yeni bir liste nesnesi oluşturur. Bu daha sonra list değişkenine ( a) yeniden atanır . Bu nedenle, eski liste nesnesinin kaydı kaldırılır ve dolayısıyla çöp toplanır (orijinal liste nesnesine a dışında bir değişken tarafından başvurulmaması koşuluyla).

Bu, bu yöntemi çok verimsiz hale getirir ve ayrıca istenmeyen yan etkiler de üretebilir (özellikle diğer değişkenler değiştirilmemiş kalan orijinal liste nesnesini gösterdiğinde).

@MarkDickinson'a bunu işaret ettiği için teşekkürler ...

Bu Yığın Taşması yanıtı, dilimleme kavramını açıklar.

Ayrıca, bunun yalnızca pozitif endekslerle çalıştığını da unutmayın.

Nesnelerle birlikte kullanılırken, __getitem__yöntemin tanımlanmış olması ve daha da önemlisi, __add__her iki işlenenden öğeler içeren bir nesne döndürmek için yöntemin tanımlanmış olması gerekir.

Özünde, bu sınıf tanımı aşağıdaki gibi olan herhangi bir nesne ile çalışır:

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

Bu, listhangi yöntem __getitem__ve __add__yöntemleri tanımlar .

Verimlilik açısından üç yolun karşılaştırılması:

Aşağıdakilerin önceden tanımlandığını varsayın:

a = range(10)
index = 3

del object[index]yöntem:

Şimdiye kadar en verimli yöntem. Bir __del__yöntemi tanımlayan tüm nesneler çalışır .

Sökme aşağıdaki gibidir:

Kod:

def del_method():
    global a
    global index
    del a[index]

demontaj:

 10    0 LOAD_GLOBAL     0 (a)
       3 LOAD_GLOBAL     1 (index)
       6 DELETE_SUBSCR   # This is the line that deletes the item
       7 LOAD_CONST      0 (None)
      10 RETURN_VALUE
None

pop yöntem:

Del yönteminden daha az verimlidir ve silinen öğeyi almanız gerektiğinde kullanılır.

Kod:

def pop_method():
    global a
    global index
    a.pop(index)

demontaj:

 17     0 LOAD_GLOBAL     0 (a)
        3 LOAD_ATTR       1 (pop)
        6 LOAD_GLOBAL     2 (index)
        9 CALL_FUNCTION   1
       12 POP_TOP
       13 LOAD_CONST      0 (None)
       16 RETURN_VALUE

Dilim ve ekleme yöntemi.

En az verimlidir.

Kod:

def slice_method():
    global a
    global index
    a = a[:index] + a[index+1:]

demontaj:

 24     0 LOAD_GLOBAL    0 (a)
        3 LOAD_GLOBAL    1 (index)
        6 SLICE+2
        7 LOAD_GLOBAL    0 (a)
       10 LOAD_GLOBAL    1 (index)
       13 LOAD_CONST     1 (1)
       16 BINARY_ADD
       17 SLICE+1
       18 BINARY_ADD
       19 STORE_GLOBAL   0 (a)
       22 LOAD_CONST     0 (None)
       25 RETURN_VALUE
None

Not: Her üç sökme işleminde de temel olarak son iki satırı görmezden gelin return None. Ayrıca ilk iki satır global değerleri ave index.

popbir öğeyi listeden kaldırmak ve listeden tutmak da yararlıdır. Nerede delöğe gerçekten trashes.

>>> x = [1, 2, 3, 4]

>>> p = x.pop(1)
>>> p
    2

2, 3 ve 7 gibi bir listedeki belirli konum öğesini kaldırmak istiyorsanız. kullanamazsın

del my_list[2]
del my_list[3]
del my_list[7]

İkinci öğeyi sildikten sonra, sildiğiniz üçüncü öğe aslında orijinal listedeki dördüncü öğedir. Orijinal listedeki 2., 3. ve 7. öğeleri filtreleyebilir ve aşağıdaki gibi yeni bir liste alabilirsiniz:

new list = [j for i, j in enumerate(my_list) if i not in [2, 3, 7]]

Bu ne yapmak istediğinize bağlıdır.

Kaldırdığınız öğeyi döndürmek istiyorsanız şunu kullanın pop():

>>> l = [1, 2, 3, 4, 5]
>>> l.pop(2)
3
>>> l
[1, 2, 4, 5]

Ancak, yalnızca bir öğeyi silmek istiyorsanız, şunu kullanın del:

>>> l = [1, 2, 3, 4, 5]
>>> del l[2]
>>> l
[1, 2, 4, 5]

Ayrıca, deldilimler (örn. del[2:]) Kullanmanızı sağlar .

Genellikle aşağıdaki yöntemi kullanıyorum:

>>> myList = [10,20,30,40,50]
>>> rmovIndxNo = 3
>>> del myList[rmovIndxNo]
>>> myList
[10, 20, 30, 50]

Yine bir listeden bir elemanı bir dizine göre kaldırmanın başka bir yolu.

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# remove the element at index 3
a[3:4] = []
# a is now [0, 1, 2, 4, 5, 6, 7, 8, 9]

# remove the elements from index 3 to index 6
a[3:7] = []
# a is now [0, 1, 2, 7, 8, 9]

a [x: y], dizinden xile arasındaki öğelere işaret eder y-1. Listenin bu bölümünü boş bir liste ( []) olarak ilan ettiğimizde , bu öğeler kaldırılır.

Yalnızca silmek istediğiniz öğeyi arayabilirsiniz. Gerçekten çok basit. Misal:

    letters = ["a", "b", "c", "d", "e"]
    letters.remove(letters[1])
    print(*letters) # Used with a * to make it unpack you don't have to (Python 3.x or newer)

Çıktı: akde

Öğeyi listeden kaldırmak için aşağıdaki kodu kullanın:

list = [1, 2, 3, 4]
list.remove(1)
print(list)

output = [2, 3, 4]

Dizin öğesi verilerini listeden kaldırmak istiyorsanız şunu kullanın:

list = [1, 2, 3, 4]
list.remove(list[2])
print(list)
output : [1, 2, 4]

Daha önce de belirtildiği gibi, en iyi uygulama del (); veya değeri bilmeniz gerekiyorsa pop () işlevini kullanın.

Alternatif bir çözüm, yalnızca istediğiniz öğeleri yeniden yığınlamaktır:

    a = ['a', 'b', 'c', 'd'] 

    def remove_element(list_,index_):
        clipboard = []
        for i in range(len(list_)):
            if i is not index_:
                clipboard.append(list_[i])
        return clipboard

    print(remove_element(a,2))

    >> ['a', 'b', 'd']

eta: hmm ... negatif dizin değerleri üzerinde çalışmaz, düşünür ve günceller

sanırım

if index_<0:index_=len(list_)+index_

... ama aniden bu fikir çok kırılgan gözüküyor. İlginç düşünce deneyi olsa. Görünüşe göre bunu append () / list anlama ile yapmanın 'uygun' bir yolu olmalı.

düşünme

Bir liste listesiyle çalışıyormuşsunuz gibi gelmiyor, bu yüzden bunu kısa tutacağım. Pop kullanmak istiyorsunuz çünkü listelerdeki öğeleri değil öğeleri silecektir, bunun için del kullanmalısınız. Python'daki son elemanı çağırmak için "-1"

>>> test = ['item1', 'item2']
>>> test.pop(-1)
'item2'
>>> test
['item1']

l - değerlerin listesi; inds2rem listesinden dizinleri kaldırmamız gerekir .

l = range(20)
inds2rem = [2,5,1,7]
map(lambda x: l.pop(x), sorted(inds2rem, key = lambda x:-x))

>>> l
[0, 3, 4, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

"Del" işlevini kullanın :

del listName[-N]

Örneğin, son 3 öğeyi kaldırmak istiyorsanız, kodunuz şöyle olmalıdır:

del listName[-3:]

Örneğin, son 8 öğeyi kaldırmak istiyorsanız, kodunuz şöyle olmalıdır:

del listName[-8:]

Bir listeden tek bir öğenin nasıl kaldırılacağı ve farklı yöntemlerin hangi avantajlara sahip olduğu zaten belirtilmiştir. Ancak, birden çok öğeyi kaldırmanın bazı hatalar potansiyeli olduğunu unutmayın:

>>> l = [0,1,2,3,4,5,6,7,8,9]
>>> indices=[3,7]
>>> for i in indices:
...     del l[i]
... 
>>> l
[0, 1, 2, 4, 5, 6, 7, 9]

Orijinal listenin 3 ve 8 numaralı öğeleri (3 ve 7 değil) kaldırılmıştır (liste döngü sırasında kısaldığı için), bu amaçlanmamış olabilir. Birden çok dizini güvenle kaldırmak istiyorsanız, önce en yüksek dizine sahip öğeleri silmelisiniz, örneğin:

>>> l = [0,1,2,3,4,5,6,7,8,9]
>>> indices=[3,7]
>>> for i in sorted(indices, reverse=True):
...     del l[i]
... 
>>> l
[0, 1, 2, 4, 5, 6, 8, 9]

Veya birden çok dizin kaldırılması gerekiyorsa:

print([v for i,v in enumerate(your_list) if i not in list_of_unwanted_indexes])

Tabii ki de yapabilirdi:

print([v for i,v in enumerate(your_list) if i != unwanted_index])

Dizine göre öğeyi listeden kaldırmak için del veya pop komutunu kullanabilirsiniz. Pop listeden kaldırdığı üyeyi yazdırırken liste o üyeyi yazdırmadan siler.

>>> a=[1,2,3,4,5]
>>> del a[1]
>>> a
[1, 3, 4, 5]
>>> a.pop(1)
 3
>>> a
[1, 4, 5]
>>> 

Biri del veya pop kullanabilir, ancak del'i tercih ederim, çünkü indeks ve dilimleri belirtebilirsiniz ve kullanıcıya veriler üzerinde daha fazla kontrol sağlar.

Örneğin, gösterilen listeden başlayarak, son elemanını delbir dilim olarak kaldırabilir ve daha sonra son elemanı kullanarak sonuçtan kaldırabilirsiniz pop.

>>> l = [1,2,3,4,5]
>>> del l[-1:]
>>> l
[1, 2, 3, 4]
>>> l.pop(-1)
4
>>> l
[1, 2, 3]