Jak usunąć element z listy według indeksu

Prawdopodobnie chcesz pop:

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

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

Domyślnie, pop bez żadnych argumentów usuwa ostatnią pozycję:

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

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

Podobnie jak inne wspomniane pop i del są skutecznymi sposobami usuwania elementu z podanego indeksu. Jednak tylko ze względu na ukończenie (ponieważ to samo można zrobić na wiele sposobów w Pythonie): {]}

Za pomocą plasterków (nie powoduje to usunięcia elementu z oryginalnej listy):

(również będzie to najmniej efektywna metoda podczas pracy z listą Pythona, ale może być przydatna (ale nie wydajna, powtarzam) podczas pracy z obiektami zdefiniowanymi przez użytkownika które nie obsługują pop, a jednak definiują __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]

Uwaga: należy pamiętać, że ta metoda nie modyfikuje listy w miejscu, jak pop i del. Zamiast tego tworzy dwie kopie list (jedną Od początku do indeksu, ale bez niego (a[:index]) i jedną po indeksie do ostatniego elementu (a[index+1:])) i tworzy nowy obiekt list przez dodanie obu. Jest to następnie przypisane do zmiennej list (a). Stary obiekt listy jest więc zdereferowany, a co za tym idzie zbierane śmieci (pod warunkiem, że oryginalny obiekt list nie jest odwołany przez żadną zmienną inną niż a).

To sprawia, że ta metoda jest bardzo nieefektywna i może również wywoływać niepożądane skutki uboczne (zwłaszcza gdy inne zmienne wskazują na oryginalny obiekt list, który pozostaje niezmodyfikowany).

Dzięki @ MarkDickinson za wskazanie tego ...

Ta odpowiedź przepełnienie stosu wyjaśnia pojęcie krojenia.

Zauważ również, że działa to tylko z pozytywnym indeksy.

Podczas używania z obiektami, metoda __getitem__ musi być zdefiniowana i co ważniejsze __add__ metoda musi być zdefiniowana, aby zwrócić obiekt zawierający elementy z obu operandów.

W istocie działa to z dowolnym obiektem, którego definicja klasy jest następująca:

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 )

To działa z list, który definiuje __getitem__ i __add__ metody.

Porównanie trzech sposobów pod względem wydajności:

Załóżmy, że następująca jest predefiniowana:

a = range(10)
index = 3

Metoda del object[index]:

Demontaż wygląda następująco:

Kod:

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

Demontaż:

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

Jest mniej wydajny niż metoda del i jest używany, gdy trzeba uzyskać usunięte pozycji.

Kod:

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

Demontaż:

 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

Plasterek i dodać metodę.

Najmniej wydajny.

Kod:

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

Demontaż:

 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

Uwaga: we wszystkich trzech demontażach ignoruj dwie ostatnie linie, które w zasadzie są return None. Również pierwsze dwie linie ładują wartości globalne a i index.

pop jest również przydatny do usuwania i utrzymywania pozycji z listy. Gdzie del faktycznie niszczy przedmiot.

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

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

Jeśli chcesz usunąć określony element pozycji na liście, taki jak 2, 3 i 7. nie możesz używać

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

Ponieważ po usunięciu drugiego elementu, trzeci element, który usuniesz, jest czwartym elementem na oryginalnej liście. Możesz filtrować 2, 3 i 7 element w oryginalnej liście i uzyskać nową listę, jak poniżej:

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

Ogólnie stosuję następującą metodę:

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

To zależy od tego, co chcesz zrobić.

Jeśli chcesz zwrócić element, który usunąłeś, użyj pop():

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

Jeśli jednak chcesz usunąć element, użyj del:

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

Dodatkowo, del pozwala na użycie plastrów (np. del[2:]).

Yet another way to remove a element(s) from a list by index.

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] wskazuje na elementy z indeksu x do y-1. Gdy zadeklarujemy tę część listy jako pustą listę ([]), elementy te zostaną usunięte.

Już wspomniano, jak usunąć pojedynczy element z listy i jakie zalety mają różne metody. Należy jednak pamiętać, że usunięcie wielu elementów może powodować błędy:

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

Elementy 3 i 8 (nie 3 i 7) oryginalnej listy zostały usunięte (ponieważ lista została skrócona podczas pętli), co mogło nie być zamierzone. Jeśli chcesz bezpiecznie usunąć wiele indeksów, zamiast tego Usuń elementy o najwyższym indeksie po pierwsze, np. tak:

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

Możesz po prostu wyszukać element, który chcesz usunąć. To naprawdę proste. Przykład:

    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)

Wyjście: a c d e

Użyj następującego kodu, aby usunąć element z listy:

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

output = [2, 3, 4]

Jeśli chcesz usunąć dane elementu indeksu z listy użyj:

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

Użyj del oświadczenie:

del listName[-N]

Na przykład, jeśli chcesz usunąć Ostatnie 3 elementy, Twój kod powinien być:

del listName[-3:]

Na przykład, jeśli chcesz usunąć ostatnie 8 elementów, Twój kod powinien być:

del listName[-8:]

L - Lista wartości; musimy usunąć indeksy z listy inds2rem.

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]

Jak wcześniej wspomniano, najlepszą praktyką jest del (); lub pop (), jeśli chcesz znać wartość.

Alternatywnym rozwiązaniem jest ponowne ułożenie tylko tych elementów, które chcesz:

    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... nie będzie działać na ujemnych wartościach indeksu, rozważy i zaktualizuje

Przypuszczam

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

rozważania

Nie wygląda na to, że pracujesz z listą list, więc będę się streszczał. Chcesz użyć pop ponieważ usunie elementy, a nie elementy, które są listami, powinieneś użyć del do tego. Aby wywołać ostatni element w Pythonie to jest " -1 "

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

Lub jeśli należy usunąć wiele indeksów:

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

Oczywiście wtedy można też zrobić:

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

Możesz użyć del lub pop, aby usunąć element z listy na podstawie indeksu. Pop wydrukuje członka, którego usuwa z listy, podczas gdy lista usuwa tego członka bez jego drukowania.

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

Można użyć del lub pop, ale wolę del, ponieważ można określić indeks i plasterki, dając użytkownikowi większą kontrolę nad danymi.

Na przykład, zaczynając od pokazanej listy, można usunąć jego ostatni element za pomocą del jako plasterka, a następnie można usunąć ostatni element z wyniku za pomocą pop.

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