Как удалить элемент из списка по индексу в Python?

Я нашел метод list.remove, но сказал, что хочу удалить последний элемент, как мне это сделать? Похоже, что удаление по умолчанию выполняет поиск в списке, но я не хочу, чтобы какой-либо поиск выполнялся.

1827
Joan Venge 9 Мар 2009 в 21:16

18 ответов

Лучший ответ

Используйте del и укажите индекс элемента, который вы хотите удалить:

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

Также поддерживает ломтики:

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

Здесь - раздел из учебника.

1673
Neil Chowdhury 5 Июн 2018 в 03:18

Можно использовать либо del, либо pop, но я предпочитаю del, поскольку вы можете указать индекс и срезы, предоставляя пользователю больший контроль над данными.

Например, начиная с показанного списка, можно удалить его последний элемент с del в качестве среза, а затем можно удалить последний элемент из результата, используя pop.

>>> l = [1,2,3,4,5]
>>> del l[-1:]
>>> l
[1, 2, 3, 4]
>>> l.pop(-1)
4
>>> l
[1, 2, 3]
2
Bill Bell 17 Апр 2017 в 15:02

Уже упоминалось, как удалить один элемент из списка и какие преимущества имеют различные методы. Обратите внимание, что удаление элементов нескольких может привести к ошибкам:

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

Элементы 3 и 8 (не 3 и 7) исходного списка были удалены (так как список был сокращен во время цикла), что, возможно, не было намерением. Если вы хотите безопасно удалить несколько индексов, вы должны сначала удалить элементы с самым высоким индексом, например, как это:

>>> 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]
5
Kopfgeldjaeger 20 Авг 2019 в 13:13

Не похоже, что вы работаете со списком списков, поэтому я буду кратким. Вы хотите использовать pop, поскольку он удалит элементы, а не элементы, которые являются списками, для этого следует использовать del. Для вызова последнего элемента в Python это "-1"

>>> test = ['item1', 'item2']
>>> test.pop(-1)
'item2'
>>> test
['item1']
8
Mo Ali 27 Дек 2016 в 14:29

l - список значений; мы должны удалить индексы из списка 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]
8
Jo Ja 25 Сен 2017 в 17:02

Как правило, я использую следующий метод:

>>> myList = [10,20,30,40,50]
>>> rmovIndxNo = 3
>>> del myList[rmovIndxNo]
>>> myList
[10, 20, 30, 50]
17
Mayur Koshti 5 Окт 2015 в 12:23

Или, если несколько индексов должны быть удалены:

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

Конечно, тогда также можно сделать:

print([v for i,v in enumerate(your_list) if i != unwanted_index])
4
U10-Forward 23 Сен 2018 в 06:13

Вы можете просто найти элемент, который вы хотите удалить. Это действительно просто. Пример:

    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)

Выход: a c d e

12
Peter Mortensen 23 Май 2018 в 23:28

Как и другие упомянутые, pop и del являются эффективными способами удаления элемента с указанным индексом. Тем не менее, просто для завершения (поскольку то же самое можно сделать несколькими способами в Python):

Использование ломтиков (это не означает удаление элемента из исходного списка):

(Также это будет наименее эффективный метод при работе со списком Python, но это может быть полезно (но неэффективно, я повторяю) при работе с пользовательскими объектами, которые не поддерживают pop, но все же определяют __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]

Примечание. Обратите внимание, что этот метод не изменяет список на месте, например pop и del. Вместо этого он создает две копии списков (один от начала до индекса, но без него (a[:index]) и один после индекса до последнего элемента (a[index+1:])) и создает новый объект списка, добавляя и то и другое. Затем он переназначается на переменную списка (a). Следовательно, старый объект списка разыменовывается и, следовательно, собирается сборщиком мусора (при условии, что на исходный объект списка не ссылаются никакие переменные, кроме a).

Это делает этот метод очень неэффективным и может также вызывать нежелательные побочные эффекты (особенно когда другие переменные указывают на исходный объект списка, который остается неизменным).

Спасибо @MarkDickinson за указание на это ...

Этот ответ переполнения стека объясняет концепцию нарезки.

Также обратите внимание, что это работает только с положительными показателями.

При использовании с объектами должен быть определен метод __getitem__, и, что более важно, должен быть определен метод __add__ для возврата объекта, содержащего элементы из обоих операндов.

По сути, это работает с любым объектом, чье определение класса похоже на:

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 )

Это работает с list, который определяет методы __getitem__ и __add__.

Сравнение трех способов с точки зрения эффективности:

Предположим, что предопределено следующее:

a = range(10)
index = 3

Метод del object[index]:

Безусловно, самый эффективный метод. Он будет работать со всеми объектами, которые определяют метод __del__.

Разборка заключается в следующем:

Код:

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

Разборка :

 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 метод

Он менее эффективен, чем метод del, и используется, когда вам нужно получить удаленный элемент.

Код:

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

Разборка :

 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

Метод нарезки и добавления.

Наименее эффективный.

Код:

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

Разборка :

 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

Примечание: во всех трех разборках игнорируйте последние две строки, которые в основном являются return None. Также первые две строки загружают глобальные значения a и index.

129
Peter Mortensen 23 Май 2018 в 23:26

Используйте функцию "del" :

del listName[-N]

Например, если вы хотите удалить последние 3 элемента, ваш код должен быть:

del listName[-3:]

Например, если вы хотите удалить последние 8 элементов, ваш код должен быть:

del listName[-8:]
6
lloydyu24 4 Июн 2017 в 11:05

Как упоминалось ранее, наилучшей практикой является del (); или pop (), если вам нужно знать значение.

Альтернативное решение состоит в том, чтобы повторно сложить только те элементы, которые вы хотите:

    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: хмм ... не будет работать с отрицательными значениями индекса, обдумает и обновит

Я предполагаю

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

Залатать это ... но вдруг эта идея кажется очень хрупкой. Интересный мысленный эксперимент. Кажется, должен быть «правильный» способ сделать это с помощью append () / списка.

< EM> обдумывание

8
litepresence 28 Июн 2016 в 14:48

pop также полезен для удаления и сохранения элемента в списке. Где del фактически уничтожает элемент.

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

>>> p = x.pop(1)
>>> p
    2
50
Cristian Ciupitu 23 Окт 2015 в 08:18

Это зависит от того, что вы хотите сделать.

Если вы хотите вернуть удаленный элемент, используйте pop():

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

Однако, если вы просто хотите удалить элемент, используйте del:

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

Кроме того, del позволяет использовать фрагменты (например, del[2:]).

18
Neil Chowdhury 11 Авг 2017 в 00:17

Вы можете использовать del или pop для удаления элемента из списка на основе индекса. Pop распечатает элемент, который он удаляет из списка, а список удалит этот элемент без его распечатки.

>>> a=[1,2,3,4,5]
>>> del a[1]
>>> a
[1, 3, 4, 5]
>>> a.pop(1)
 3
>>> a
[1, 4, 5]
>>> 
2
Aashutosh jha 13 Дек 2016 в 04:59

Используйте следующий код для удаления элемента из списка:

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

output = [2, 3, 4]

Если вы хотите удалить данные элемента индекса из списка, используйте:

list = [1, 2, 3, 4]
list.remove(list[2])
print(list)
output : [1, 2, 4]
10
Ivan Burlutskiy 22 Май 2017 в 15:26

Еще один способ удалить элемент (ы) из списка по индексу.

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] указывает на элементы из индекса x в y-1. Когда мы объявляем эту часть списка как пустой список ([]), эти элементы удаляются.

13
progyammer 23 Мар 2018 в 05:51

Вы, вероятно, хотите pop:

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

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

По умолчанию pop без аргументов удаляет последний элемент:

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

# now a is ['a', 'b', 'c']
625
Jarret Hardie 9 Мар 2009 в 18:17

Если вы хотите удалить определенный элемент позиции в списке, например, 2-й, 3-й и 7-й. ты не можешь использовать

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

Поскольку после удаления второго элемента третий удаляемый элемент фактически является четвертым элементом в исходном списке. Вы можете отфильтровать 2-й, 3-й и 7-й элемент в исходном списке и получить новый список, как показано ниже:

new list = [j for i, j in enumerate(my_list) if i not in [2, 3, 7]]
20
xiaojia zhang 24 Июл 2018 в 02:38