web-dev-qa-db-fra.com

Comment supprimer un élément d'une liste par index en Python?

Comment supprimer un élément d'une liste par index en Python?

J'ai trouvé la méthode list.remove, mais disons que je veux supprimer le dernier élément, comment puis-je procéder? Il semble que le paramètre par défaut, remove, recherche dans la liste, mais je ne souhaite pas qu’une recherche soit effectuée.

1175
Joan Venge

Utilisez del et spécifiez l'index de l'élément que vous souhaitez supprimer:

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

Prend également en charge les tranches:

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

Ici est la section du tutoriel.

1384
unbeknown

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']
554
Jarret Hardie

Comme d’autres, pop et del sont des the méthodes efficaces pour supprimer un élément d’un index donné. Mais juste pour compléter (car on peut faire la même chose de différentes façons en Python):

Utilisation de tranches (cela ne supprime pas en place un élément de la liste d'origine):

(Ce sera également la méthode la moins efficace lorsque vous utiliserez la liste Python, mais cela pourrait être utile (mais pas efficace, je le répète) lorsque vous utilisez des objets définis par l'utilisateur qui ne prennent pas en charge le pop, mais définissent 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 modifie pas la liste en place comme pop et del. Au lieu de cela, il crée deux copies des listes (une du début jusqu'à l'index mais sans elle (a[:index]) et une après l'index jusqu'au dernier élément (a[index+1:])) et crée un nouvel objet de liste en ajoutant les deux. Ceci est ensuite réaffecté à la variable de liste (a). Le vieil objet de liste est donc déréférencé et, partant, garbage collecté (à condition que l'objet de liste d'origine ne soit pas référencé par une variable autre que a).

Cela rend cette méthode très inefficace et peut également produire des effets secondaires indésirables (en particulier lorsque d’autres variables pointent vers l’objet de liste initial qui n’a pas été modifié).

Merci à @MarkDickinson de l'avoir signalé ...

Cette réponse Stack Overflow explique le concept de découpage en tranches.

Notez également que cela ne fonctionne qu'avec des indices positifs.

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

En substance, cela fonctionne avec tout objet dont la définition de classe 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 )

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

Comparaison des trois voies en termes d'efficacité:

Supposons que les éléments suivants soient prédéfinis:

a = range(10)
index = 3

La méthode del object[index]:

De loin la méthode la plus efficace. Cela fonctionne avec tous les objets qui définissent une méthode __del__.

Le démontage est le suivant:

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:

Elle est moins efficace que la méthode del et est utilisée lorsque vous devez 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 méthode slice et add.

Le 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 les trois désassemblages, ignorez les deux dernières lignes qui sont fondamentalement return None. De même, les deux premières lignes chargent les valeurs globales a et index.

114
Raghav RV

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

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

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

Généralement, j'utilise la méthode suivante:

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

Cela dépend de ce que vous voulez faire.

Si vous souhaitez retourner l'élément que vous avez supprimé, utilisez pop():

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

Toutefois, si vous souhaitez simplement supprimer un élément, utilisez del:

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

De plus, del vous permet d'utiliser des tranches (par exemple del[2:]).

14
Neil Chowdhury

Encore un autre moyen de supprimer un ou plusieurs éléments d’une liste par index.

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] pointe vers les éléments d'index x à y-1. Lorsque nous déclarons cette partie de la liste comme une liste vide ([]), ces éléments sont supprimés.

Vous pouvez simplement rechercher l'élément que vous souhaitez supprimer. C’est très simple… .. Exemple:

    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)

Sortie: a c d e

9
SollyBunny

Utilisez le code suivant pour supprimer un élément de la liste: 

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

output = [2, 3, 4]

Si vous souhaitez supprimer les données d'élément d'index de la liste, utilisez:

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

Comme mentionné précédemment, la meilleure pratique est del (); ou pop () si vous avez besoin de connaître la valeur.

Une autre solution consiste à ne réempiler que les éléments souhaités:

    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 ... ne fonctionnera pas sur les valeurs d'index négatives, réfléchira et mettra à jour

Je suppose 

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

le corrigerais ... mais soudain cette idée semble très fragile. Expérience de pensée intéressante cependant. Il semble qu'il devrait y avoir un moyen "approprié" de procéder avec la compréhension avec append ()/list. 

méditer

6
litepresence

Il ne semble pas que vous travailliez avec une liste de listes, je vais donc rester bref. Vous voulez utiliser pop car cela supprimera des éléments et non des éléments de listes, utilisez del pour cela Pour appeler le dernier élément en python, c'est "-1"

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

l - liste de valeurs; nous devons supprimer les index de inds2rem list.

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]
6
Jo Ja

Utilisez la fonction "del"

del listName[-N]

Par exemple, si vous souhaitez supprimer les 3 derniers éléments, votre code doit être:

del listName[-3:]

Par exemple, si vous souhaitez supprimer les 8 derniers éléments, votre code devrait être:

del listName[-8:]
5
lloydyu24

Si vous souhaitez supprimer l'élément de position spécifique dans une liste, comme les 2, 3 et 7. vous ne pouvez pas utiliser

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

Après la suppression du deuxième élément, le troisième élément que vous supprimez est en fait le quatrième élément de la liste d'origine. Vous pouvez filtrer les deuxième, troisième et septième éléments de la liste d'origine et en obtenir une nouvelle, comme ci-dessous:

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

Nous avons déjà indiqué comment supprimer un seul élément d'une liste et quels avantages les différentes méthodes présentent. Notez toutefois que la suppression d’éléments multiples peut entraîner des erreurs:

>>> l = [0,1,2,3,4,5,6,7,8,9]
>>> indices=[3,7]
>>> for i in indices:
...     del l[i]
... 
>>> l
[0, 1, 2, 4, 5, 6, 7, 9]

Les éléments 3 et 8 (et non 3 et 7) de la liste d'origine ont été supprimés (la liste ayant été raccourcie au cours de la boucle), ce qui n'était peut-être pas l'intention. Si vous souhaitez supprimer plusieurs index en toute sécurité, vous devez plutôt supprimer d’abord les éléments avec l’indice le plus élevé, par exemple. comme ça:

>>> l = [0,1,2,3,4,5,6,7,8,9]
>>> indices=[3,7]
>>> for i in sorted(indices, reverse=True):
...     del l[i]
... 
>>> l
[0, 1, 2, 4, 5, 6, 8, 9]
1
Kopfgeldjaeger

On peut utiliser del ou pop, mais je préfère del, car vous pouvez spécifier des index et des tranches, ce qui permet à l'utilisateur de mieux contrôler les données.

Par exemple, en commençant par la liste affichée, on peut supprimer son dernier élément avec del en tant que tranche, puis supprimer le dernier élément du résultat en utilisant pop.

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

Mais n'utilisez jamais pop () avec loop .it provoquera une erreur .use pop () sans loop.

0
DeV

Ou si plusieurs index doivent être supprimés:

print([v for i,v in enumerate(your_list) if i not in list_of_unwanted_indexes])

Bien sûr, alors pourrait aussi faire:

print([v for i,v in enumerate(your_list) if i != unwanted_index])
0
U9-Forward

Vous pouvez utiliser del ou pop pour supprimer un élément de la liste en fonction de l'index. Pop imprimera le membre qu'il supprime de la liste, tandis que la liste supprimera ce membre sans l'imprimer.

>>> a=[1,2,3,4,5]
>>> del a[1]
>>> a
[1, 3, 4, 5]
>>> a.pop(1)
 3
>>> a
[1, 4, 5]
>>> 
0
Aashutosh jha