Как удалить элемент из списка по индексу в 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']
Как и другие, упомянутые 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.
pop также полезно удалить и сохранить элемент из списка. Где del фактически уничтожает элемент.
>>> x = [1, 2, 3, 4]
>>> p = x.pop(1)
>>> p
2
Это зависит от того, что вы хотите сделать.
Если вы хотите вернуть элемент, который вы удалили, используйте 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. Когда мы объявляем эту часть списка пустым списком ([]), эти элементы удаляются.
Если вы хотите удалить определенный элемент позиции в списке, например, 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]]
Вы можете просто найти элемент, который хотите удалить. Это действительно просто. Пример:
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: hmm... не будет работать с отрицательными значениями индекса, будет размышлять и обновлять
Предположим, что
if index_<0:index_=len(list_)+index_
исправит его... но внезапно эта идея кажется очень хрупкой. Интересный мысленный эксперимент. Кажется, должен быть "правильный" способ сделать это с помощью append()/list.
обдумывая
Не похоже, что вы работаете со списком списков, поэтому я буду держать это в курсе. Вы хотите использовать 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:]
Или, если нужно удалить несколько индексов:
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, но я предпочитаю 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]
Уже упоминалось, как удалить один элемент из списка, и какие преимущества имеют различные методы. Однако обратите внимание, что удаление нескольких элементов может привести к ошибкам:
>>> 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 или pop для удаления элемента из списка на основе индекса. Pop будет печатать член, который он удаляет из списка, а список удаляет этот элемент без его печати.
>>> a=[1,2,3,4,5]
>>> del a[1]
>>> a
[1, 3, 4, 5]
>>> a.pop(1)
3
>>> a
[1, 4, 5]
>>>
Никогда не используйте pop() с циклом. Это приведет к ошибке. Используйте pop() без цикла.
Вы можете просто использовать функцию 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]