it-swarm.com.de

Wie entferne ich ein Element aus einer Liste nach Index in Python?

Wie entferne ich ein Element aus einer Liste nach Index in Python?

Ich habe die list.remove-Methode gefunden, aber ich möchte das letzte Element entfernen. Wie mache ich das? Es scheint, als würde das standardmäßige Entfernen die Liste durchsuchen, aber ich möchte nicht, dass eine Suche ausgeführt wird.

1175
Joan Venge

Verwenden Sie del und geben Sie den Index des Elements an, das Sie löschen möchten:

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

Unterstützt auch Slices:

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

Hier ist der Abschnitt aus dem Tutorial.

1384
unbeknown

Sie möchten wahrscheinlich pop:

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

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

Standardmäßig entfernt pop ohne Argumente das letzte Element:

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

# now a is ['a', 'b', 'c']
554
Jarret Hardie

Wie andere bereits erwähnte pop und del sind the effiziente Möglichkeiten, ein Element aus einem bestimmten Index zu entfernen. Nur um der Vervollständigung willen (da in Python auf viele Arten dasselbe gemacht werden kann):

Verwenden von Slices (das Entfernen von Elementen aus der ursprünglichen Liste ist nicht erforderlich):

(Dies ist auch die am wenigsten effiziente Methode, wenn Sie mit der Python-Liste arbeiten. Dies kann jedoch nützlich sein (aber nicht effizient, ich wiederhole es noch), wenn Sie mit benutzerdefinierten Objekten arbeiten, die kein Pop unterstützen, jedoch einen __getitem__ definieren.

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

Hinweis: Bitte beachten Sie, dass diese Methode die vorhandene Liste wie pop und del nicht ändert. Stattdessen werden zwei Kopien von Listen erstellt (eine vom Start bis zum Index, jedoch ohne (a[:index]) und eine nach dem Index bis zum letzten Element (a[index+1:])). Durch Hinzufügen von beiden wird ein neues Listenobjekt erstellt. Diese wird dann der Listenvariablen (a) zugewiesen. Das alte Listenobjekt wird daher dereferenziert und der Müll wird gesammelt (sofern das ursprüngliche Listenobjekt nicht von einer anderen Variablen als a referenziert wird).

Dies macht dieses Verfahren sehr ineffizient und kann auch unerwünschte Nebeneffekte erzeugen (insbesondere wenn andere Variablen auf das ursprüngliche Listenobjekt zeigen, das unverändert bleibt).

Vielen Dank an @MarkDickinson für diesen Hinweis ...

Diese Stack Overflow-Antwort erklärt das Konzept des Aufteilens.

Beachten Sie auch, dass dies nur bei positiven Indizes funktioniert.

Bei der Verwendung mit Objekten muss die __getitem__-Methode definiert worden sein, und vor allem muss die __add__ -Methode definiert sein, um ein Objekt zurückzugeben, das Elemente aus beiden Operanden enthält.

Im Wesentlichen funktioniert dies mit jedem Objekt, dessen Klassendefinition wie folgt lautet:

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 )

Dies funktioniert mit list, die __getitem__- und __add__-Methoden definiert.

Vergleich der drei Wege in Sachen Effizienz:

Angenommen, Folgendes ist vordefiniert:

a = range(10)
index = 3

Die del object[index]-Methode:

Bei weitem die effizienteste Methode. Es funktioniert alle Objekte, die eine __del__-Methode definieren.

Die Demontage ist wie folgt:

Code:

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

Demontage:

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

Es ist weniger effizient als die Methode del und wird verwendet, wenn Sie das gelöschte Element abrufen müssen.

Code:

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

Demontage:

 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

Die Slice- und Add-Methode.

Die am wenigsten effizient.

Code:

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

Demontage:

 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

Hinweis: Bei allen drei Disassembles werden die letzten beiden Zeilen ignoriert, die im Grunde return None sind. Auch die ersten beiden Zeilen laden die globalen Werte a und index.

114
Raghav RV

pop ist auch nützlich, um ein Element aus einer Liste zu entfernen und zu behalten. Wo del den Artikel tatsächlich in den Papierkorb bringt.

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

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

Im Allgemeinen verwende ich die folgende Methode:

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

Dies hängt davon ab, was Sie tun möchten.

Wenn Sie das entfernte Element zurückgeben möchten, verwenden Sie pop():

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

Wenn Sie jedoch nur ein Element löschen möchten, verwenden Sie del:

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

Außerdem können Sie mit del Slices verwenden (z. B. del[2:]).

14
Neil Chowdhury

Eine weitere Möglichkeit, ein Element aus einer Liste nach Index zu entfernen.

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] zeigt auf die Elemente vom Index x bis y-1. Wenn wir diesen Teil der Liste als leere Liste ([]) deklarieren, werden diese Elemente entfernt.

Sie können einfach nach dem Element suchen, das Sie löschen möchten. Es ist wirklich einfach ... __ Beispiel:

    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)

Ausgabe: a c d e

9
SollyBunny

Verwenden Sie den folgenden Code, um ein Element aus der Liste zu entfernen: 

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

output = [2, 3, 4]

Wenn Sie Indexelementdaten aus der Liste entfernen möchten, verwenden Sie Folgendes:

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

Wie bereits erwähnt, ist die beste Vorgehensweise del (); oder pop (), wenn Sie den Wert kennen müssen.

Eine alternative Lösung besteht darin, nur die gewünschten Elemente neu zu stapeln:

    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 ... funktioniert nicht bei negativen Indexwerten, wird nachdenken und aktualisieren

Schätze ich 

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

würde es patchen ... aber plötzlich scheint diese Idee sehr spröde zu sein. Interessantes Gedankenexperiment. Es scheint einen "richtigen" Weg zu geben, dies mit append ()/list verstehen zu tun. 

nachdenken

6
litepresence

Es hört sich nicht so an, als würden Sie mit einer Liste von Listen arbeiten. Sie möchten pop verwenden, da dadurch Elemente entfernt werden, die keine Listen sind. Sie sollten dafür del verwenden. Um das letzte Element in Python aufzurufen, ist es "-1".

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

l - Liste von Werten; Wir müssen Indizes aus inds2rem list entfernen.

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]
6
Jo Ja

Verwenden Sie die Funktion "del"

del listName[-N]

Wenn Sie beispielsweise die letzten drei Elemente entfernen möchten, muss Ihr Code folgendermaßen lauten:

del listName[-3:]

Wenn Sie beispielsweise die letzten 8 Elemente entfernen möchten, muss Ihr Code folgendermaßen lauten:

del listName[-8:]
5
lloydyu24

Wenn Sie das bestimmte Positionselement in einer Liste entfernen möchten, z. B. das 2., 3. und 7. Element. Sie können nicht verwenden

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

Nachdem Sie das zweite Element gelöscht haben, ist das dritte Element, das Sie tatsächlich löschen, das vierte Element in der ursprünglichen Liste. Sie können das 2., 3. und 7. Element in der ursprünglichen Liste filtern und erhalten eine neue Liste wie unten:

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

Es wurde bereits erwähnt, wie ein einzelnes Element aus einer Liste entfernt werden kann und welche Vorteile die verschiedenen Methoden haben. Beachten Sie jedoch, dass das Entfernen von mehreren Elementen möglicherweise zu Fehlern führt:

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

Die Elemente 3 und 8 (nicht 3 und 7) der ursprünglichen Liste wurden entfernt (da die Liste während der Schleife gekürzt wurde), was möglicherweise nicht beabsichtigt war. Wenn Sie mehrere Indizes sicher entfernen möchten, sollten Sie stattdessen die Elemente mit dem höchsten Index zuerst löschen, z. so was:

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

Sie können entweder del oder pop verwenden, aber ich bevorzuge del, da Sie Index und Slices angeben können, um dem Benutzer mehr Kontrolle über die Daten zu geben.

Beginnend mit der angezeigten Liste kann man beispielsweise sein letztes Element mit del als Slice entfernen, und dann kann man das letzte Element mit pop aus dem Ergebnis entfernen.

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

Verwenden Sie jedoch niemals pop () mit loop .it, was zu einem Fehler führt .use pop () ohne loop.

0
DeV

Oder wenn mehrere Indizes entfernt werden sollen:

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

Dann könnten Sie natürlich auch folgendes tun:

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

Sie können entweder del oder pop verwenden, um ein Element aus der Liste basierend auf dem Index zu entfernen. Pop druckt das Mitglied, das es aus der Liste entfernt, während die Liste dieses Mitglied löscht, ohne es zu drucken.

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