2009-03-09 18:16

如何在 Python 中按索引从列表中删除元素?


How do I remove an element from a list by index in Python?

I found the list.remove method, but say I want to remove the last element, how do I do this? It seems like the default remove searches the list, but I don't want any search to be performed.


  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 复制链接分享
  • 邀请回答


  • weixin_41568183 零零乙 12年前

    Use del and specify the index of the element you want to delete:

    >>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> del a[-1]
    >>> a
    [0, 1, 2, 3, 4, 5, 6, 7, 8]

    Also supports slices:

    >>> del a[2:4]
    >>> a
    [0, 1, 4, 5, 6, 7, 8, 9]

    Here is the section from the tutorial.

    点赞 25 评论 复制链接分享
  • weixin_41568110 七度&光 12年前

    You probably want pop:

    a = ['a', 'b', 'c', 'd']
    # now a is ['a', 'c', 'd']

    By default, pop without any arguments removes the last item:

    a = ['a', 'b', 'c', 'd']
    # now a is ['a', 'b', 'c']
    点赞 29 评论 复制链接分享
  • csdnceshi73 喵-见缝插针 7年前

    Like others mentioned pop and del are the efficient ways to remove an item of given index. Yet just for the sake of completion (since the same thing can be done via many ways in Python):

    Using slices (this does not do in place removal of item from original list):

    (Also this will be the least efficient method when working with Python list, but this could be useful (but not efficient, I reiterate) when working with user defined objects that do not support pop, yet do define 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]

    Note: Please note that this method does not modify the list in place like pop and del. It instead makes two copies of lists (one from the start until the index but without it (a[:index]) and one after the index till the last element (a[index+1:])) and creates a new list object by adding both. This is then reassigned to the list variable (a). The old list object is hence dereferenced and hence garbage collected (provided the original list object is not referenced by any variable other than a).

    This makes this method very inefficient and it can also produce undesirable side effects (especially when other variables point to the original list object which remains un-modified).

    Thanks to @MarkDickinson for pointing this out ...

    This Stack Overflow answer explains the concept of slicing.

    Also note that this works only with positive indices.

    While using with objects, the __getitem__ method must have been defined and more importantly the __add__ method must have been defined to return an object containing items from both the operands.

    In essence, this works with any object whose class definition is like:

    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 )

    This works with list which defines __getitem__ and __add__ methods.

    Comparison of the three ways in terms of efficiency:

    Assume the following is predefined:

    a = range(10)
    index = 3

    The del object[index] method:

    By far the most efficient method. It works will all objects that define a __del__ method.

    The disassembly is as follows:


    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

    pop method:

    It is less efficient than the del method and is used when you need to get the deleted item.


    def pop_method():
        global a
        global 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

    The slice and add method.

    The least efficient.


    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

    Note: In all three disassembles ignore the last two lines which basically are return None. Also the first two lines are loading the global values a and index.

    点赞 21 评论 复制链接分享
  • csdnceshi79 python小菜 8年前

    pop is also useful to remove and keep an item from a list. Where del actually trashes the item.

    >>> x = [1, 2, 3, 4]
    >>> p = x.pop(1)
    >>> p
    点赞 10 评论 复制链接分享
  • csdnceshi52 妄徒之命 4年前

    Yet another way to remove an element(s) from a list by index.

    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] points to the elements from index x to y-1. When we declare that portion of the list as an empty list ([]), those elements are removed.

    点赞 10 评论 复制链接分享
  • csdnceshi69 YaoRaoLov 4年前

    You could just search for the item you want to delete. It is really simple. Example:

        letters = ["a", "b", "c", "d", "e"]
        print(*letters) # Used with a * to make it unpack you don't have to (Python 3.x or newer)

    Output: a c d e

    点赞 10 评论 复制链接分享
  • csdnceshi59 ℙℕℤℝ 4年前

    Use the following code to remove element from the list:

    list = [1, 2, 3, 4]
    output = [2, 3, 4]

    If you want to remove index element data from the list use:

    list = [1, 2, 3, 4]
    output : [1, 2, 4]
    点赞 10 评论 复制链接分享
  • csdnceshi60 ℡Wang Yan 4年前

    Use the "del" function:

    del listName[-N]

    For example, if you want to remove the last 3 items, your code should be:

    del listName[-3:]

    For example, if you want to remove the last 8 items, your code should be:

    del listName[-8:]
    点赞 9 评论 复制链接分享
  • csdnceshi55 ~Onlooker 5年前

    One can either use del or pop, but I prefer del, since you can specify index and slices, giving the user more control over the data.

    For example, starting with the list shown, one can remove its last element with del as a slice, and then one can remove the last element from the result using pop.

    >>> l = [1,2,3,4,5]
    >>> del l[-1:]
    >>> l
    [1, 2, 3, 4]
    >>> l.pop(-1)
    >>> l
    [1, 2, 3]
    点赞 8 评论 复制链接分享
  • csdnceshi70 笑故挽风 6年前

    Generally, I am using the following method:

    >>> myList = [10,20,30,40,50]
    >>> rmovIndxNo = 3
    >>> del myList[rmovIndxNo]
    >>> myList
    [10, 20, 30, 50]
    点赞 8 评论 复制链接分享
  • csdnceshi52 妄徒之命 5年前

    It doesn't sound like you're working with a list of lists, so I'll keep this short. You want to use pop since it will remove elements not elements that are lists, you should use del for that. To call the last element in python it's "-1"

    >>> test = ['item1', 'item2']
    >>> test.pop(-1)
    >>> test
    点赞 6 评论 复制链接分享
  • csdnceshi54 hurriedly% 4年前

    l - list of values; we have to remove indexes from inds2rem list.

    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]
    点赞 5 评论 复制链接分享
  • weixin_41568196 撒拉嘿哟木头 4年前

    This depends on what you want to do.

    If you want to return the element you removed, use pop():

    >>> l = [1, 2, 3, 4, 5]
    >>> l.pop(2)
    >>> l
    [1, 2, 4, 5]

    However, if you just want to delete an element, use del:

    >>> l = [1, 2, 3, 4, 5]
    >>> del l[2]
    >>> l
    [1, 2, 4, 5]

    Additionally, del allows you to use slices (e.g. del[2:]).

    点赞 4 评论 复制链接分享
  • csdnceshi74 7*4 5年前

    As previously mentioned, best practice is del(); or pop() if you need to know the value.

    An alternate solution is to re-stack only those elements you want:

        a = ['a', 'b', 'c', 'd'] 
        def remove_element(list_,index_):
            clipboard = []
            for i in range(len(list_)):
                if i is not index_:
            return clipboard
        >> ['a', 'b', 'd']

    eta: hmm... will not work on negative index values, will ponder and update

    I suppose

    if index_<0:index_=len(list_)+index_

    would patch it... but suddenly this idea seems very brittle. Interesting thought experiment though. Seems there should be a 'proper' way to do this with append() / list comprehension.


    点赞 2 评论 复制链接分享
  • csdnceshi61 derek5. 3年前

    If you want to remove the specific position element in a list, like the 2th, 3th and 7th. you can't use

    del my_list[2]
    del my_list[3]
    del my_list[7]

    Since after you delete the second element, the third element you delete actually is the fourth element in the original list. You can filter the 2th, 3th and 7th element in the original list and get a new list, like below:

    new list = [j for i, j in enumerate(my_list) if i not in [2, 3, 7]]
    点赞 1 评论 复制链接分享
  • csdnceshi77 狐狸.fox 3年前

    Or if multiple indexes should be removed:

    print([v for i,v in enumerate(your_list) if i not in list_of_unwanted_indexes])

    Of course then could also do:

    print([v for i,v in enumerate(your_list) if i != unwanted_index])
    点赞 评论 复制链接分享
  • csdnceshi65 larry*wei 5年前

    You can use either del or pop to remove element from list based on index. Pop will print member it is removing from list, while list delete that member without printing it.

    >>> a=[1,2,3,4,5]
    >>> del a[1]
    >>> a
    [1, 3, 4, 5]
    >>> a.pop(1)
    >>> a
    [1, 4, 5]
    点赞 评论 复制链接分享
  • csdnceshi66 必承其重 | 欲带皇冠 4年前

    You can simply use the remove function of Python. Like this:

    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:
    点赞 评论 复制链接分享