list list() - Come rimuovere un elemento da un elenco per indice in Python?




append of (16)

Come rimuovere un elemento da un elenco per indice in Python?

Ho trovato il metodo list.remove , ma dico che voglio rimuovere l'ultimo elemento, come posso fare? Sembra che la rimozione predefinita ricerchi l'elenco, ma non voglio che venga eseguita alcuna ricerca.


Answers

Utilizzare il seguente codice per rimuovere l'elemento dall'elenco:

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

output = [2, 3, 4]

Se si desidera rimuovere i dati degli elementi indice dall'elenco, utilizzare:

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

Se si desidera rimuovere l'elemento posizione specifico in un elenco, ad esempio il 2 °, il 3 ° e il 7 °. non puoi usare

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

Poiché dopo aver eliminato il secondo elemento, il terzo elemento che elimini in realtà è il quarto elemento nell'elenco originale. Puoi filtrare il 2 °, il 3 ° e il 7 ° elemento nell'elenco originale e ottenere un nuovo elenco, come di seguito:

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

Usa la funzione "del" :

del listName[-N]

Ad esempio, se vuoi rimuovere gli ultimi 3 elementi, il tuo codice dovrebbe essere:

del listName[-3:]

Ad esempio, se vuoi rimuovere gli ultimi 8 elementi, il tuo codice dovrebbe essere:

del listName[-8:]

Come altri citati, pop e del sono i modi efficaci per rimuovere un elemento di un determinato indice. Eppure solo per il completamento (dal momento che la stessa cosa può essere fatta in molti modi in Python):

Utilizzo delle sezioni (ciò non comporta la rimozione degli articoli dall'elenco originale):

(Anche questo sarà il metodo meno efficiente quando si lavora con Python list, ma questo potrebbe essere utile (ma non efficiente, lo ripeto) quando si lavora con oggetti definiti dall'utente che non supportano pop, e tuttavia definire un __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]

Nota: si noti che questo metodo non modifica l'elenco in posizione come pop e del . Crea invece due copie di elenchi (uno dall'inizio fino all'indice ma senza di esso ( a[:index] ) e uno dopo l'indice fino all'ultimo elemento ( a[index+1:] )) e crea un nuovo oggetto lista aggiungendo entrambi. Questo viene quindi riassegnato alla variabile di lista ( a ). Il vecchio oggetto list è quindi dereferenziato e quindi garbage collection (a condizione che l'oggetto list originale non sia referenziato da alcuna variabile diversa da a).

Ciò rende questo metodo molto inefficiente e può anche produrre effetti collaterali indesiderati (specialmente quando altre variabili puntano sull'oggetto list originale che rimane non modificato).

Grazie a @MarkDickinson per averlo indicato ...

This risposta di Overflow dello stack spiega il concetto di affettamento.

Si noti inoltre che questo funziona solo con indici positivi.

Durante l'utilizzo con oggetti, il metodo __getitem__ deve essere stato definito e, soprattutto, il metodo __add__ deve essere stato definito per restituire un oggetto contenente elementi da entrambi gli operandi.

In sostanza, funziona con qualsiasi oggetto la cui definizione di classe sia simile a:

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 )

Funziona con un list che definisce i metodi __getitem__ e __add__ .

Confronto dei tre modi in termini di efficienza:

Supponiamo che quanto segue sia predefinito:

a = range(10)
index = 3

Il metodo del object[index] :

Di gran lunga il metodo più efficiente. __del__ tutti gli oggetti che definiscono un metodo __del__ .

Lo smontaggio è il seguente:

Codice:

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

Smontaggio:

 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

metodo pop :

È meno efficiente del metodo del e viene utilizzato quando è necessario ottenere l'elemento eliminato.

Codice:

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

Smontaggio:

 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

La fetta e aggiungi il metodo.

Il meno efficiente.

Codice:

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

Smontaggio:

 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

Nota: in tutti e tre i disassemblaggi ignorano le ultime due righe che sostanzialmente return None . Anche le prime due righe stanno caricando i valori globali a e index .


Si può usare del o pop, ma io preferisco del, dato che è possibile specificare indici e sezioni, dando all'utente un maggiore controllo sui dati.

Ad esempio, iniziando dall'elenco mostrato, si può rimuovere il suo ultimo elemento con del come slice, e quindi si può rimuovere l'ultimo elemento dal risultato usando pop .

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

In generale, sto usando il seguente metodo:

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

l - lista di valori; dobbiamo rimuovere gli indici dalla lista 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]

Potresti semplicemente cercare l'oggetto che desideri eliminare. È davvero semplice Esempio:

    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)

Uscita: acde


Puoi semplicemente usare la funzione remove di Python. Come questo:

v = [1, 2, 3, 4, 5, 6]
v.remove(v[4]) # I'm removing the number with index 4 of my array
print(v) # If you want verify the process

# It gave me this:
#[1,2,3,4,6]

Come accennato in precedenza, la best practice è del (); o pop () se è necessario conoscere il valore.

Una soluzione alternativa consiste nel ricollegare solo gli elementi desiderati:

    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 ... non funzionerà su valori di indice negativi, rifletterà e aggiornerà

Credo

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

lo aggiusterebbe ... ma improvvisamente questa idea sembra molto fragile. Esperimento di pensiero interessante però. Sembra che ci dovrebbe essere un modo "corretto" per farlo con append () / list comprehension.

ponderazione


Utilizza il e specifica l'indice dell'elemento che vuoi eliminare:

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

Supporta anche le fette:

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

Here la sezione del tutorial.


Non sembra che tu stia lavorando con un elenco di elenchi, quindi terrò questo breve. Si desidera utilizzare il pop poiché rimuoverà elementi non elementi che sono elenchi, si dovrebbe usare del per quello. Per chiamare l'ultimo elemento in python è "-1"

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

pop è anche utile per rimuovere e mantenere un elemento da un elenco. Dove del effettivamente distrugge l'oggetto.

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

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

Probabilmente vuoi pop :

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

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

Per impostazione predefinita, pop senza argomenti rimuove l'ultimo elemento:

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

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

Questo dipende da cosa vuoi fare.

Se vuoi restituire l'elemento rimosso, usa pop() :

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

Tuttavia, se si desidera eliminare un elemento, utilizzare del :

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

Inoltre, del consente di usare slice (es. del[2:] ).


Se si desidera una nuova lista mantenendo le due vecchie liste:

def concatenate_list(listOne, listTwo):
    joinedList = []
    for i in listOne:
        joinedList.append(i)
    for j in listTwo:
        joinedList.append(j)

    sorted(joinedList)

    return joinedList




python list