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.
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.
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']
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.
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
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]
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:]).
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
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]
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
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']
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]
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:]
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]]
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]
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]
Mais n'utilisez jamais pop () avec loop .it provoquera une erreur .use pop () sans loop.
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])
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]
>>>