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



supprimer un élément d'une liste c# (11)

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

J'ai trouvé la méthode list.remove , mais dis que je veux supprimer le dernier élément, comment je fais ça? Il semble que la suppression par défaut effectue une recherche dans la liste, mais je ne souhaite pas que la recherche soit effectuée.

https://src-bin.com


Answer #1

Cela dépend de ce que vous voulez faire.

Si vous voulez 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]

Cependant, si vous voulez juste 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:] ).


Answer #2

Comme d'autres ont mentionné pop et del sont les moyens efficaces pour supprimer un élément d'index donné. Pourtant, juste pour l'achèvement (puisque la même chose peut être faite de plusieurs façons en python):

Utilisation de tranches (Cela ne supprime pas l'élément de la liste d'origine):

(Ce sera aussi la méthode la moins efficace quand on travaille avec la liste python mais cela pourrait être utile (mais pas efficace, je le répète) lorsqu'on travaille avec des objets définis par l'utilisateur qui ne supportent pas 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 ]

Note: S'il vous plaît noter que cette méthode ne modifie pas la liste inplace comme pop et del . Il fait deux copies de listes (une depuis le 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 ). L'ancien objet liste est donc déréférencé et donc récupéré (à condition que l'objet liste d'origine ne soit référencé par aucune 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 liste original qui reste non modifié).

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

This réponse explique le concept de découpage.

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 n'importe quel objet dont la définition de classe est:

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 la list qui définit les méthodes __getitem__ et __add__ .

Comparaison des trois façons en termes d'efficacité:

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

a = range(10)
index = 3

La méthode del object[index] :

De loin la méthode la plus efficace. Works sera tous les objets qui définissent une méthode __del__ .

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

méthode pop :

Moins efficace que la méthode del. Utilisé 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 tranche et ajouter la méthode.

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 2 dernières lignes qui sont fondamentalement return None Les deux premières lignes chargent aussi les valeurs globales a et index .


Answer #3

En général, j'utilise la méthode suivante:

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

Answer #4

Encore une autre façon de supprimer un élément (s) 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 de l'index x à y-1 . Lorsque nous déclarons cette partie de la liste comme une liste vide ( [] ), ces éléments sont supprimés.


Answer #5

On peut soit utiliser del ou pop, mais je préfère del, puisque vous pouvez spécifier l'index et les tranches, donnant à l'utilisateur plus de contrôle sur les données.

Par exemple, en commençant par la liste affichée, on peut enlever son dernier élément avec del comme une tranche, et ensuite on peut enlever 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]

Answer #6

Utilisez del et spécifiez l'élément que vous voulez supprimer avec l'index:

In [9]: a = list(range(10))
In [10]: a
Out[10]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [11]: del a[-1]
In [12]: a
Out[12]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

Here la section du tutoriel.


Answer #7

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 des données d'éléments d'index de la liste, utilisez:

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

Answer #8

Vous pourriez juste rechercher l'article que vous voulez supprimer. vraiment simple. Exemple:

    letters = ["a", "b", "c", "d", "e"]
    numbers.remove(numbers[1])
    print(*letters) # used a * to make it unpack you don't have to

sortie: acde


Answer #9

Vous pouvez utiliser del ou pop pour supprimer un élément de la liste en fonction de l'index. Pop va imprimer le membre qu'il retire de la liste, tandis que la liste supprime 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]
>>> 

Answer #10

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

Answer #11

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

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]




list