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

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

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

Используйте 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]

Вот раздел из учебника.

Вы, вероятно, хотите 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']

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

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

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

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

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

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

Если вы хотите удалить определенный элемент позиции в списке, например, 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]]

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

Если вы хотите вернуть удаленный элемент, используйте 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:]).

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

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

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

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

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

    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)

Выход: acde

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

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]

Как упоминалось ранее, наилучшей практикой является 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 () / списка.

обдумывание

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

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

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]

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

del listName[-N]

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

del listName[-3:]

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

del listName[-8:]

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

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

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

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

Вы можете использовать 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]
>>> 

Можно использовать либо 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]