Как удалить элемент из списка по индексу в Python?
Я нашел метод list.remove
, но, скажем, я хочу удалить последний элемент, как мне это сделать? Похоже, что метод 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]
Здесь - раздел из учебника.
Вы, вероятно, хотите поп
:
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 список, но это может быть полезно (но не эффективный, я подтверждаю) при работе пользователя с определенными объектами, которые не поддерживают поп, пока еще определить __метод 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]
Примечание: Пожалуйста, обратите внимание, что этот метод не изменяет список на месте, как " поп " и "Дель". Вместо этого он делает две копии списков (по одному от начала до индекса, но без него (а [индекс]
) и один после того, как индекс до последнего элемента (а[индекс+1:]
)) и создает новый список объектов, добавив как. Это потом переназначили в списке переменных ("а"). Старый список объектов, следовательно, разыменован и, следовательно, мусора (при условии, что исходный объект список не ссылается любой переменной, кроме).
Это делает этот метод очень неэффективен, и это также может привести к нежелательным побочным эффектам (особенно когда другие переменные указывают на исходный объект списка, который по-прежнему ООН-модифицированный).
Спасибо @MarkDickinson указывающих на это ...
Этот переполнение стека ответ объясняет концепцию нарезки.
Также обратите внимание, что это работает только с позитивных показателей.
При использовании с объектами, метод __метод getitem__
должны быть определены и, что более важно, __добавить__
метод должен быть определен, чтобы возвратить объект, содержащий элементы из обоих операндов.
В сущности, это работает с любой объект, класс которого является определение как:
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 )
Это работает с список
определяющий __метод getitem__ и__методы__
.
Сравнение трех способов с точки зрения эффективности:
Предположим следующий предопределен:
a = range(10)
index = 3
Объект-дель-метод[индекс]
:
На сегодняшний день наиболее эффективный метод. Он работает все объекты, которые определяют методомдель`.
Разборки выглядит следующим образом:
Код:
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
поп
метод:
Он менее эффективен, чем метод 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
Примечание: во всех трех демонтирует игнорировать последние две строки, которые по сути являются возврата нет
. Также первые две строки-загрузка глобального значения A
и индекс
.
Это зависит от того, что вы хотите сделать.
Если вы хотите вернуть элемент, который вы удалили, использовать поп()`:
>>> l = [1, 2, 3, 4, 5]
>>> l.pop(2)
3
>>> l
[1, 2, 4, 5]
Однако, если вы просто хотите, чтобы удалить элемент, использовать "дель":
>>> l = [1, 2, 3, 4, 5]
>>> del l[2]
>>> l
[1, 2, 4, 5]
Кроме того, дель позволяет использовать ломтики (например, Дель[2:]
).
Как правило, я использую следующий метод:
>>> myList = [10,20,30,40,50]
>>> rmovIndxNo = 3
>>> del myList[rmovIndxNo]
>>> myList
[10, 20, 30, 50]
Если вы хотите удалить определенный элемент позиция в списке, как 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]]
Еще один способ, чтобы удалить элемент(ы) из списка по индексу.
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]
а[Х: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)
Вывод: С D Е
Используйте следующий код, чтобы удалить элемент из списка:
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 для этого. Для вызова последнего элемента в Python это'ы с "-1"и
>>> test = ['item1', 'item2']
>>> test.pop(-1)
'item2'
>>> test
['item1']
л - список значений; мы должны удалить индексы с 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]
Как упоминалось ранее, рекомендуется дель(); или 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']
ета: хм... не будет работать на отрицательных значениях индекса, будет обдумывать и обновление
Я полагаю
if index_<0:index_=len(list_)+index_
будет патч... но вдруг эта идея кажется очень хрупким. Хотя интересный мысленный эксперимент. Кажется, там должен быть 'правильный' способ сделать это с помощью append() / список понимания.
размышляя
Используйте "в деле" по функция:
del listName[-N]
Например, если вы хотите удалить последние 3 деталей, ваш код должен быть:
del listName[-3:]
Например, если вы хотите удалить последние 8 элементов, ваш код должен быть:
del listName[-8:]
Или если несколько индексов должны быть удалены:
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])
Уже было сказано как удалить один элемент из списка и преимущества различных методов. Однако следует отметить, что удаление несколько элементы есть потенциал для ошибки:
>>> 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]
Можно использовать либо Del или поп, но я предпочитаю дель, так как вы можете указывать индекс и ломтиками, давая пользователю больше контроля над данными.
Например, начиная с указанного списка, можно удалить его последний элемент с "Дель", как ломоть, а потом можно удалить последний элемент из результат, используя "поп".
>>> l = [1,2,3,4,5]
>>> del l[-1:]
>>> l
[1, 2, 3, 4]
>>> l.pop(-1)
4
>>> l
[1, 2, 3]
Вы можете использовать либо Del или поп, чтобы удалить элемент из списка, основанные на индексе. Поп будет печатать член его удаление из списка, а список удалить этого члена без заказа печати.
>>> a=[1,2,3,4,5]
>>> del a[1]
>>> a
[1, 3, 4, 5]
>>> a.pop(1)
3
>>> a
[1, 4, 5]
>>>
Вы можете просто использовать удалить
функция в 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]