Frage 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 fand die list.remove Methode, aber sagen, ich möchte das letzte Element entfernen, wie mache ich das? Es scheint, als würde der Standard-Remove die Liste durchsuchen, aber ich möchte nicht, dass eine Suche durchgeführt wird.


1050
2018-03-09 18:16


Ursprung


Antworten:


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


1211
2018-03-09 18:21



Du willst wahrscheinlich pop:

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

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

Standardmäßig, pop ohne Argumente entfernt den letzten Eintrag:

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

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

488
2018-03-09 18:17



Wie andere erwähnt Pop und Del sind das effiziente Möglichkeiten zum Entfernen eines Artikels mit einem bestimmten Index. Nur um der Vollständigkeit willen (da dasselbe in Python über viele Wege getan werden kann):

Verwenden von Slices (dies führt nicht zum Entfernen von Elementen aus der ursprünglichen Liste):

(Dies ist auch die am wenigsten effiziente Methode beim Arbeiten mit der Python-Liste, aber dies könnte nützlich sein (aber nicht effizient, wiederhole ich), wenn ich mit benutzerdefinierten Objekten arbeite, die Pop nicht unterstützen, aber a __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]

Hinweis: Bitte beachten Sie, dass diese Methode die Liste nicht ändert pop und del. Es erstellt stattdessen zwei Kopien von Listen (eine von Anfang bis zum Index, aber ohne sie (a[:index]) und eine nach dem Index bis zum letzten Element (a[index+1:])) und erstellt ein neues Listenobjekt, indem beide hinzugefügt werden. Dies wird dann der Listenvariablen (a). Das alte Listenobjekt wird daher dereferenziert und daher wird Müll gesammelt (vorausgesetzt, das ursprüngliche Listenobjekt wird von keiner anderen Variable als a referenziert).

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

Danke an @MarkDickinson für den Hinweis darauf ...

Dies Stack Overflow-Antwort erklärt das Konzept des Slicing.

Beachten Sie, dass dies nur mit positiven Indizes funktioniert.

Während der Verwendung mit Objekten, die __getitem__ Methode muss definiert worden sein und, was noch wichtiger ist, die __add__ Methode muss definiert worden sein, um ein Objekt zurückzugeben, das Elemente von beiden Operanden enthält.

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

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 was definiert __getitem__ und __add__ Methoden.

Vergleich der drei Wege in Bezug auf Effizienz:

Angenommen, das Folgende ist vordefiniert:

a = range(10)
index = 3

Das del object[index] Methode:

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

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

Das am wenigsten effiziente.

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: In allen drei Disassemblies ignorieren Sie die letzten beiden Zeilen, die grundsätzlich sind return None. Auch die ersten beiden Zeilen laden die globalen Werte a und index.


96
2018-06-22 15:21



pop ist auch nützlich, um ein Objekt aus einer Liste zu entfernen und zu behalten. Woher delTrashes tatsächlich den Artikel.

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

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

41
2017-10-19 13:10



Im Allgemeinen verwende ich die folgende Methode:

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

12
2017-10-05 12:23



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]

Zusätzlich, del ermöglicht es Ihnen, Scheiben (z. del[2:]).


10
2017-08-11 00:17



Noch 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 aus dem Index x zu y-1. Wenn wir diesen Teil der Liste als leere Liste deklarieren ([]), diese Elemente werden entfernt.


6
2017-10-30 09:21



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


6
2018-02-15 13:09