Différence entre supprimer, supprimer et faire apparaître des listes


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

Y a-t-il une différence entre les trois méthodes ci-dessus pour supprimer un élément d'une liste?


1
Article connexe sur des lignes similaires pour la structure de données définie - Différence d'exécution entre les méthodes set.discard et set.remove en Python?
RBT

Réponses:


1335

Oui, removesupprime la première valeur correspondante , pas un index spécifique:

>>> a = [0, 2, 3, 2]
>>> a.remove(2)
>>> a
[0, 3, 2]

del supprime l'élément à un index spécifique:

>>> a = [9, 8, 7, 6]
>>> del a[1]
>>> a
[9, 7, 6]

et popsupprime l'élément à un index spécifique et le renvoie.

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

Leurs modes d'erreur sont également différents:

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

14
@jxramos: deln'est pas un maintien de la syntaxe, non. La syntaxe est inchangée, tout comme returnou ifou while.
Martijn Pieters

6
Il convient de mentionner que les utilisateurs doivent être prudents lorsqu'ils parcourent une liste et utilisent ces fonctions dessus en même temps qu'ils itèrent.
hamaney

16
L' delexemple est quelque peu trompeur. Quel élément est supprimé, exactement? Le 2e ou le 3e? Vous auriez dû utiliser [9, 8, 7, 6], del a[1]et[9, 7, 6]
gromit190

2
@ rite2hhh il teste l'égalité. Les tests d'égalité testent d'abord l'identité comme une optimisation
Martijn Pieters

1
@ rite2hhh: l'égalité des valeurs est couverte dans la référence d'expression .
Martijn Pieters

184

Permet delde supprimer un élément par index, pop()de le supprimer par index si vous avez besoin de la valeur renvoyée et remove()de supprimer un élément par valeur. Ce dernier nécessite une recherche dans la liste et augmente ValueErrorsi aucune valeur de ce type n'apparaît dans la liste.

Lors de la suppression id'un index d'une liste d' néléments, les complexités de calcul de ces méthodes sont

del     O(n - i)
pop     O(n - i)
remove  O(n)

1
La pop nécessite-t-elle une recherche dans la liste
sachin irukula

31
+1 pour la ventilation de la complexité. Illustre comment la suppression et le pop sont constants lorsque l'élément se trouve à la fin de la liste.
Big Sharpie

2
Rappelez-vous les gars ... tout ce qui est basé sur un index est un coup O (n-1) ... si vous devez faire une recherche (par valeur), il traversera la collection jusqu'à ce que l'élément soit trouvé.
Pepito Fernandez

2
@PepitoFernandez Les recherches par index dans une liste sont O (1) en Python. (Une liste en Python est similaire à un vecteur en C ++.)
Sven Marnach

3
@PlasmaBinturong Vous devez utiliser ce que vous pensez être plus lisible, sauf si vous disposez de données prouvant que les performances sont importantes. Et si c'est le cas, vous devez mesurer ce qui est plus rapide dans votre cas spécifique. Je suppose également que delc'est un peu plus rapide, mais pour une raison différente: la recherche d' __delitem__un type implémenté en C se fait par index plutôt que par nom, alors popqu'il faut rechercher en suivant le protocole de descripteur entier. L'exécution des fonctions elles-mêmes devrait prendre le même temps. Les deux renvoient un pointeur - l'un vers l'objet supprimé, l'autre vers None.
Sven Marnach

92

Étant donné que personne d'autre ne l'a mentionné, notez que del(contrairement à pop) permet la suppression d'une plage d'index en raison du découpage de liste:

>>> lst = [3, 2, 2, 1]
>>> del lst[1:]
>>> lst
[3]

Cela permet également d'éviter un IndexErrorsi l'index n'est pas dans la liste:

>>> lst = [3, 2, 2, 1]
>>> del lst[10:]
>>> lst
[3, 2, 2, 1]

55

Déjà bien répondu par d'autres. Celui de ma fin :)

supprimer vs pop vs del

Evidemment, popc'est le seul qui renvoie la valeur, et removec'est le seul qui cherche l'objet, tout en se dellimitant à une simple suppression.


2
Thnx! Une remarque: en python, en raison de la façon dont les listes sont implémentées (il y a pratiquement des tableaux ...!), "Avancer jusqu'à la position de ce nœud" est O (1)
ntg

19

pop - Prend l'indice et renvoie la valeur

remove - Prend de la valeur, supprime la première occurrence et ne renvoie rien

delete - Prend l'index, supprime la valeur à cet index et ne renvoie rien


19

De nombreuses meilleures explications sont ici, mais je ferai de mon mieux pour simplifier davantage.

Parmi toutes ces méthodes, reverse & pop sont des suffixes tandis que delete est un préfixe .

remove (): utilisé pour supprimer la première occurrence de l'élément

remove(i) => première occurrence de la valeur i

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

pop (): utilisé pour supprimer l'élément si:

non spécifié

pop() => à partir de la fin de la liste

>>>a.pop()
>>>a
[0, 3, 2, 1, 4, 6, 5]

spécifié

pop(index) => d'index

>>>a.pop(2)
>>>a
[0, 3, 1, 4, 6, 5]

AVERTISSEMENT: méthode dangereuse à venir

delete () : C'est une méthode de préfixe.

Gardez un œil sur deux syntaxes différentes pour la même méthode: [] et (). Il possède le pouvoir de:

1. supprimer l'index

del a[index] => utilisé pour supprimer l'index et sa valeur associée comme pop.

>>>del a[1]
>>>a
[0, 1, 4, 6, 5]

2.Supprimez les valeurs dans la plage [index 1: index N]

del a[0:3] => plusieurs valeurs dans la plage

>>>del a[0:3]
>>>a
[6, 5]

3.Dernière mais pas la liste, pour supprimer toute la liste en une seule fois

del (a) => comme dit ci-dessus.

>>>del (a)
>>>a

J'espère que cela clarifie la confusion, le cas échéant.


2

Toute opération / fonction sur différentes structures de données est définie pour des actions particulières. Ici, dans votre cas, c'est à dire supprimer un élément, supprimer, Pop et supprimer. (Si vous considérez les ensembles, ajoutez une autre opération - jetez) Un autre cas déroutant est lors de l'ajout. Insérer / ajouter. Pour démonstration, implémentons deque. deque est une structure de données linéaire hybride, dans laquelle vous pouvez ajouter des éléments / supprimer des éléments aux deux extrémités (extrémités arrière et avant).

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

Ici, voir les opérations:

def deleteFront(self):

    return self.items.pop(0)
def deleteRear(self):
    return self.items.pop()

Les opérations doivent retourner quelque chose. Alors, pop - Avec et sans index. Si je ne veux pas retourner la valeur: del self.items [0]

Supprimer par valeur et non par index:

  • retirer :

    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

Renvoie [1,3,5,7]

considérons le cas des ensembles.

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.

1

Tandis que pop et delete prennent tous les deux des indices pour supprimer un élément comme indiqué dans les commentaires ci-dessus. Une différence clé est la complexité temporelle pour eux. La complexité temporelle pour pop () sans index est O (1) mais ce n'est pas le même cas pour la suppression du dernier élément.

Si votre cas d'utilisation est toujours de supprimer le dernier élément, il est toujours préférable d'utiliser pop () plutôt que delete (). Pour plus d'explications sur les complexités temporelles, vous pouvez vous référer à https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt


2
C'est faux de plusieurs façons. Il n'existe pas de méthode telle que delete. Les différences sont que poprenvoie la valeur et que cela delfonctionne sur les tranches. Dans les cas où cela popfonctionne, dela exactement la même complexité de calcul (et est légèrement plus rapide par un terme constant).
abarnert

1

L' opération de suppression sur une liste reçoit une valeur à supprimer. Il recherche dans la liste pour trouver un élément avec cette valeur et supprime le premier élément correspondant qu'il trouve. C'est une erreur s'il n'y a pas d'élément correspondant, déclenche une ValueError .

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

L' instruction del peut être utilisée pour supprimer une liste entière. Si vous avez un élément de liste spécifique comme argument à supprimer (par exemple, listname [7] pour référencer spécifiquement le 8ème élément de la liste), il suffit de supprimer cet élément. Il est même possible de supprimer une "tranche" d'une liste. C'est une erreur s'il y a un index hors de portée, déclenche une IndexError .

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

L'utilisation habituelle de pop consiste à supprimer le dernier élément d'une liste lorsque vous utilisez la liste comme une pile. Contrairement à del, pop renvoie la valeur qu'il a extraite de la liste. Vous pouvez éventuellement attribuer une valeur d'index à pop et pop à partir de la fin de la liste (par exemple, listname.pop (0) supprimera le premier élément de la liste et renverra ce premier élément comme résultat). Vous pouvez l'utiliser pour que la liste se comporte comme une file d'attente, mais il existe des routines de bibliothèque qui peuvent fournir des opérations de file d'attente avec de meilleures performances que pop (0). C'est une erreur s'il y a un index hors de portée, déclenche une IndexError .

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

Voir collections.deque pour plus de détails.


-1

Supprimer fonctionne essentiellement sur la valeur. Supprimer et afficher le travail sur l'index

Supprimer supprime essentiellement la première valeur correspondante. Supprimer supprime l'élément d'un index spécifique. Pop prend essentiellement un index et renvoie la valeur à cet index. La prochaine fois que vous imprimerez la liste, la valeur n'apparaîtra pas.

Exemple:


3
Bien que nous vous remercions pour votre réponse, il serait préférable qu'elle apporte une valeur supplémentaire en plus des autres réponses. Dans ce cas, votre réponse n'apporte aucune valeur supplémentaire, car d'autres utilisateurs ont couvert tout ce que vous avez inclus dans votre réponse. En tant que problème secondaire, veuillez ne pas inclure le texte en tant qu'images lorsque vous pouvez le coller en tant que texte. Si une réponse précédente vous a été utile, vous devriez la voter .
David Buck

-3

Vous pouvez également utiliser remove pour supprimer également une valeur par index.

n = [1, 3, 5]

n.remove(n[1])

n ferait alors référence à [1, 5]


43
Essayez n = [5, 3, 5]donc n.remove(n[2]).
abarnert

@abarnert votre cas d'utilisation fonctionne en synchronisation avec le cas ci-dessous n = [5,3,5], puis n.remove (5). Ces deux suppriment le premier élément rencontré de la liste.
Akhil Ghatiki

@AkhilGhatiki n.remove(n[2])supprime n[0], non n[2]. Ce n'est donc pas seulement un temps linéaire sans raison (peut-être pas un gros problème quand N = 3), c'est aussi faux (un gros problème quel que soit N)
abarnert
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.