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

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

как и другие упомянутые поп и Дель the эффективные способы удаления элемента данного индекса. Но только ради завершения (так как то же самое можно сделать многими способами в 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:])) и создает новый объект списка, добавляя оба. Затем он переназначается в переменную list (a). Старое объект list, следовательно, разыменован и, следовательно, собран мусор (при условии, что исходный объект list не ссылается на какую-либо переменную, кроме 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

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

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

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

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

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

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

выход: A c d e

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

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

использовать "дель" функция:

del listName[-N]

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

del listName[-3:]

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

del listName[-8:]

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 или 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-й, 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]]

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

Вы можете просто использовать remove функция Python. Вот так:

v = [1, 2, 3, 4, 5, 6]
v.remove(v[4]) # I'm removing the number with index 4 of my array
print(v) # If you want verify the process

# It gave me this:
#[1,2,3,4,6]

или если необходимо удалить несколько индексов:

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