font - subplot python title
Diferencia entre del, quitar y pop en las listas (10)
Como nadie más lo ha mencionado, tenga en cuenta que del (a diferencia de pop ) permite la eliminación de un rango de índices debido a la división de la lista:
>>> lst = [3, 2, 2, 1]
>>> del lst[1:]
>>> lst
[3]
Esto también permite evitar un IndexError si el índice no está en la lista:
>>> lst = [3, 2, 2, 1]
>>> del lst[10:]
>>> lst
[3, 2, 2, 1]
>>> a=[1,2,3]
>>> a.remove(2)
>>> a
[1, 3]
>>> a=[1,2,3]
>>> del a[1]
>>> a
[1, 3]
>>> a= [1,2,3]
>>> a.pop(1)
2
>>> a
[1, 3]
>>>
¿Hay alguna diferencia entre los tres métodos anteriores para eliminar un elemento de una lista?
Cualquier operación / función en diferentes estructuras de datos se define para acciones particulares. Aquí en su caso, es decir, eliminar un elemento, eliminar, abrir y eliminar. (Si considera conjuntos, agregue otra operación - descartar) Otro caso confuso es al agregar. Insertar / Añadir. Para la demostración, vamos a implementar deque. deque es una estructura de datos lineal híbrida, donde puede agregar elementos / eliminar elementos de ambos extremos (extremos posterior y delantero)
class Deque(object):
def __init__(self):
self.items=[]
def addFront(self,item):
return self.items.insert(0,item)
def addRear(self,item):
return self.items.append(item)
def deleteFront(self):
return self.items.pop(0)
def deleteRear(self):
return self.items.pop()
def returnAll(self):
return self.items[:]
Aquí, ver las operaciones:
def deleteFront(self):
return self.items.pop(0)
def deleteRear(self):
return self.items.pop()
Las operaciones tienen que devolver algo. Entonces, pop - Con y sin un índice. Si no quiero devolver el valor: del self.items [0]
Eliminar por valor no índice:
retirar :
list_ez=[1,2,3,4,5,6,7,8] for i in list_ez: if i%2==0: list_ez.remove(i) print list_ez
Devoluciones [1,3,5,7]
Consideremos el caso de los conjuntos.
set_ez=set_ez=set(range(10))
set_ez.remove(11)
# Gives Key Value Error.
##KeyError: 11
set_ez.discard(11)
# Does Not return any errors.
La operación de remove en una lista tiene un valor para eliminar. Busca en la lista para encontrar un elemento con ese valor y elimina el primer elemento coincidente que encuentra. Es un error si no hay un elemento coincidente, genera un ValueError .
>>>del a[1]
>>>a
[0, 1, 4, 6, 5]
La declaración del se puede utilizar para eliminar una lista completa. Si tiene un elemento de lista específico como su argumento para eliminar (por ejemplo, nombre de lista [7] para hacer referencia específicamente al octavo elemento de la lista), simplemente eliminará ese elemento. Incluso es posible eliminar una "porción" de una lista. Es un error si el índice está fuera de rango, genera un IndexError .
>>>del a[0:3]
>>>a
[6, 5]
El uso habitual de pop es eliminar el último elemento de una lista a medida que utiliza la lista como una pila. A diferencia de del, pop, devuelve el valor que salió de la lista. Opcionalmente, puede otorgar un valor de índice para que aparezca y salga desde el final de la lista (por ejemplo, listname.pop (0) eliminará el primer elemento de la lista y devolverá ese primer elemento como resultado). Puede usar esto para hacer que la lista se comporte como una cola, pero hay rutinas de biblioteca disponibles que pueden proporcionar operaciones de cola con un mejor rendimiento que pop (0). Es un error si el índice está fuera de rango, genera un IndexError .
>>>del (a)
>>>a
Ver collections.deque para más detalles.
Mientras abre y elimina, ambos toman índices para eliminar un elemento como se indica en los comentarios anteriores. Una diferencia clave es la complejidad del tiempo para ellos. La complejidad del tiempo para pop () sin índice es O (1) pero no es el mismo caso para la eliminación del último elemento.
Si su caso de uso es siempre eliminar el último elemento, siempre es preferible usar pop () en lugar de delete (). Para obtener una explicación más detallada sobre las complejidades del tiempo, puede consultar https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt
Muchas mejores explicaciones están aquí, pero haré mi mejor esfuerzo para simplificar más.
Entre todos estos métodos, reverse y pop son postfix, mientras que delete es prefix .
remove (): se utiliza para eliminar la primera aparición del elemento
remove(i) => primera aparición del valor i
>>> x = [1, 0, 0, 0, 3, 4, 5]
>>> x.remove(4)
>>> x
[1, 0, 0, 0, 3, 5]
>>> del x[7]
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
del x[7]
IndexError: list assignment index out of range
pop (): se utiliza para eliminar elementos si:
no especificado
pop() => del final de la lista
>>> x = [1, 2, 3, 4]
>>> del x[3]
>>> x
[1, 2, 3]
>>> del x[4]
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
del x[4]
IndexError: list assignment index out of range
especificado
pop(index) => del index
>>> x = [1, 2, 3]
>>> x.pop(2)
3
>>> x
[1, 2]
>>> x.pop(4)
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
x.pop(4)
IndexError: pop index out of range
ADVERTENCIA: método peligroso por delante
delete () : Es un método de prefijo.
Mantenga un ojo en dos sintaxis diferentes para el mismo método: [] y (). Posee poder para:
Índice 1.Delete
del a[index] => se usa para eliminar el índice y su valor asociado como pop.
>>> a = [0, 2, 3, 2, 1, 4, 6, 5, 7]
>>> a.remove(2) # where i = 2
>>> a
[0, 3, 2, 1, 4, 6, 5, 7]
2. Eliminar valores en rango [índice 1: índice N]
del a[0:3] => múltiples valores en el rango
>>>a.pop()
>>>a
[0, 3, 2, 1, 4, 6, 5]
3.Last pero no lista, para eliminar la lista entera en un tiro
del (a) => como se dijo anteriormente.
>>>a.pop(2)
>>>a
[0, 3, 1, 4, 6, 5]
Espero que esto aclare la confusión si la hay.
Sí, remove elimina el primer valor coincidente, no un índice específico:
>>> a = [0, 2, 3, 2]
>>> a.remove(2)
>>> a
[0, 3, 2]
del elimina el elemento en un índice específico:
>>> a = [3, 2, 2, 1]
>>> del a[1]
>>> a
[3, 2, 1]
y pop elimina el elemento en un índice específico y lo devuelve.
>>> a = [4, 3, 5]
>>> a.pop(1)
3
>>> a
[4, 5]
Sus modos de error también son diferentes:
>>> a = [4, 5, 6]
>>> a.remove(7)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> del a[7]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
>>> a.pop(7)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: pop index out of range
También puede usar eliminar para eliminar un valor por índice también.
n = [1, 3, 5]
n.remove(n[1])
n se referiría entonces a [1, 5]
Use del para eliminar un elemento por índice, pop() para eliminarlo por índice si necesita el valor devuelto, y remove() para eliminar un elemento por valor. Este último requiere buscar en la lista, y genera ValueError si tal valor no aparece en la lista.
Al eliminar el índice i de una lista de n elementos, las complejidades computacionales de estos métodos son
del O(n - i)
pop O(n - i)
remove O(n)
pop - Toma índice y devuelve valor
eliminar: toma el valor, elimina la primera aparición y no devuelve nada
eliminar: toma el índice, elimina el valor en ese índice y no devuelve nada