1839 votes

Comment faire pour supprimer un élément d’une liste par index en Python ?

Comment faire pour supprimer un élément d’une liste par index en Python ?

J’ai trouvé la méthode list.remove mais dire que je veux supprimer le dernier élément, comment puis-je faire cela ? Il semble que la valeur par défaut supprimer recherche dans la liste, mais je ne veux pas vos recherches à effectuer.

761voto

Jarret Hardie Points 36266

Vous voulez probablement pop :

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

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

Par défaut, pop sans aucun argument supprime le dernier élément:

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

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

163voto

rvraghav93 Points 528

Comme d'autres l'ont mentionné pop et del sont les moyens efficaces pour supprimer un élément de l'index donné. Encore juste pour le plaisir d'achèvement ( depuis la même chose peut être fait via de nombreuses façons en python ):

À l'aide de tranches ( Ce n'est pas en place la suppression de l'élément de la liste originale ) :

( Aussi ce sera la méthode la moins efficace lorsque l'on travaille avec une liste python, mais cela pourrait être utile ( mais pas efficace, je le répète ) lorsque vous travaillez avec des objets définis par l'utilisateur qui ne prennent pas en charge de la pop, mais de définir 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 ]

Remarque: Veuillez noter que cette méthode ne permet pas de modifier la liste en place, comme pop et del. Au lieu de cela, il fait deux copies de listes ( de la start jusqu'à ce que l'index mais sans elle ( a[:index] ) et l'un après l'index jusqu'au dernier élément ( a[index+1:] ) ) et crée un nouvel objet de la liste en ajoutant les deux. C'est ensuite réaffectés à la liste des variables ( a ). L'ancien objet de la liste est donc déréférencé et donc les ordures collectées ( à condition que la liste d'origine de l'objet n'est pas référencé par une variable quelconque autre qu'un )

Ce qui rend cette méthode très efficace, et il peut aussi produire des effets secondaires indésirables ( en particulier lorsque d'autres variables point à la liste d'origine de l'objet qui reste non-modifiée )

Grâce à @MarkDickinson pour le signaler ...

Ce Débordement de Pile réponse explique le concept de découpage.

Notez également que cela fonctionne uniquement avec des indices positifs.

Lors de l'utilisation avec des objets, l' __getitem__ méthode doit avoir été défini et plus important encore, l' __add__ méthode doit avoir été défini pour renvoyer un objet contenant des éléments des deux opérandes.

En substance, cela fonctionne avec n'importe quel objet dont la définition de la classe, c'est comme :

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 )

Cela fonctionne avec list qui définit __getitem__ et __add__ méthodes.

La comparaison des trois méthodes en termes d'efficacité:

Supposons que celui-ci est prédéfini :

a = range(10)
index = 3

L' del object[index] méthode:

De loin la méthode la plus efficace. Les œuvres seront tous les objets qui définissent un __del__ méthode.

Le démontage est comme suit :

Code:

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

Démontage:

 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 méthode:

Moins efficace que la del de la méthode. Utilisé lorsque vous avez besoin pour obtenir l'élément supprimé.

Code:

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

Démontage:

 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 tranche et ajouter une méthode.

La moins efficace.

Code:

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

Démontage:

 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

Remarque : Dans tous les trois démonte ignorer les 2 dernières lignes qui sont fondamentalement return None Aussi les 2 premières lignes sont en train de charger les valeurs globales a et index.

57voto

Mark0978 Points 3328

pop est également utile pour supprimer et conserver un élément d'une liste. Où del efface réellement l'élément.

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

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

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X