элементы - получить индекс элемента списка python




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

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

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


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

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

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

    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


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

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

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

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

Here раздел из учебника.


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

del listName[-N]

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

del listName[-3:]

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

del listName[-8:]

Как и другие, упомянутые 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 за это.

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

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

При использовании с объектами метод __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 .


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

размышляют


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

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

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


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

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

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




list