Python3列表删除的三种方式实现

目录

• 1. 删除列表（list）的三种方式
• （1）.按照元素删除—remove（）
• （2）.按照索引删除—pop（）
• （3）.按照索引删除—del（）
• 2. 删除元素引发的思考
• （1）.事故发生现场
• （2）.列表----正序遍历的过程分析
• （3）.列表----倒序遍历的过程分析
• 3. 删除列表中重复的元素
• （1）.根据索引删除—(如上倒序的方式)
• （2）.根据元素删除—(结果正确，但是过程是错误)

1. 删除列表（list）的三种方式

（1）.按照元素删除—remove（）

• 直接删除具体某个元素，remove里面传递的是元素的值
• 从最左边开始寻找第一个符合要求的元素
• remove函数没有结果返回
• 如果没有对应的元素，则抛出错误

my_list = [1, 2, 3, 4, 2, 5]
my_list.remove(2)
print(my_list)

# 结果
[1, 3, 4, 2, 5]

my_list = [1, 2, 3, 4, 2, 5]
my_list.remove(6)				# 没有元素6，最终会抛出异常
print(my_list)

# 结果
Traceback (most recent call last):
  File "/Users/alien_test.py", line 58, in <module>
    my_list.remove(6)
ValueError: list.remove(x): x not in list

（2）.按照索引删除—pop（）

• 根据索引删除某个元素
• pop执行完会返回对应元素的值
• pip()中如果不传递索引，则删除最后一位元素
• pop删除的索引，如果越界会抛出异常

# 根据索引删除元素

my_list = [1, 2, 3, 4, 2, 5]
item = my_list.pop(1)
print(my_list)
print(item)

# 结果
[1, 3, 4, 2, 5]
2		# 元素2是对应索引为1的值

# 删除最后一个元素

my_list = [1, 2, 3, 4, 2, 5]
item = my_list.pop()
print(my_list)
print(item)

# 最终结果
[1, 2, 3, 4, 2]
5

# 越界抛出异常

my_list = [1, 2, 3, 4, 2, 5]
item = my_list.pop(8)
print(my_list)
print(item)

# 结果
Traceback (most recent call last):
  File "/Users/test/alien_test.py", line 58, in <module>
    item = my_list.pop(8)
IndexError: pop index out of range

（3）.按照索引删除—del（）

• 根据索引删除，最终结果没有返回值
• 索引越界抛出异常

my_list = [1, 2, 3, 4, 2, 5]

del my_list[1]      #等同于 del(my_list[1])
print(my_list)

# 结果
[1, 3, 4, 2, 5]

my_list = [1, 2, 3, 4, 2, 5]
del my_list[8]
print(my_list)

# 异常结果
Traceback (most recent call last):
  File "/Users/test/alien_test.py", line 58, in <module>
    del my_list[8]
IndexError: list assignment index out of range

2. 删除元素引发的思考

（1）.事故发生现场

【case 1：】

my_list = [1, 2, 2, 3, 2]
for item in my_list:
    if item == 2:
        my_list.remove(item)
print(my_list)

# [1, 3, 2]

【case 2：】

my_list = [1, 2, 2, 3, 2]
for index in range(len(my_list)):
    if my_list[index] == 2:
        my_list.pop(index)
print(my_list)

# 结果

Traceback (most recent call last):
  File "/Users/test/alien_test.py", line 59, in <module>
    if my_list[index] == 2:
IndexError: list index out of range

（2）.列表----正序遍历的过程分析

my_list = [1, 2, 2, 3, 2]
for item in my_list:
    print("item-------->", item)
    if item == 2:
        my_list.remove(item)
print(my_list)

# 结果：

item--------> 1
item--------> 2
item--------> 3
item--------> 2
[1, 3, 2]

【分析过程：】

• 如上过程，发现for循环的过程居然没有遍历所有的元素，打印的结果少一个索引位置为2的元素2
• 具体原因是，for循环的时候，列表的元素是动态变化的。具体可参考如下过程

step1:列表的遍历过程如下

列表的遍历是通过游标来控制列表的位置，从索引为0号位一直到最后一个位置，依次遍历

step2:列表的删除某个元素流程如下

当遍历到索引为1的位置时候，准备删除这个位置元素

• 删除完index=1这个元素之后，紧接着index=2的元素会向左移动到原始index=1的位置。此时，游标已经在index=1的位置。
• 下一次再遍历的时候，游标会自增1，变为从index=2开始。而此时index=2的元素是3，跳过了原始的index=2的元素2。
• 所以，如果有连续的相同的元素2，则会少遍历一次这个元素。如上2个案例，都是这个原因导致的问题。

（3）.列表----倒序遍历的过程分析

my_list = [1, 2, 2, 3, 2]
for index in range(len(my_list) - 1, -1, -1):
    item = my_list[index]
    print("item-------->", index, "--->", item)
    if item == 2:
        my_list.pop(index)
print(my_list)

# 结果
item--------> 4 ---> 2
item--------> 3 ---> 3
item--------> 2 ---> 2
item--------> 1 ---> 2
item--------> 0 ---> 1

[1, 3]

1.通过倒序的遍历，可以把所有的2元素都删除了，倒序为什么能解决如上的问题?
2.倒序也会出现删除的元素的位置，被新元素占用的情况？

step1:列表倒序的遍历过程如下

step2:列表的删除某个元素流程如下

当遍历到索引为4的位置时候，准备删除这个位置元素

• 删除完索引index=4的元素之后
• 下一个遍历的索引是index=3，此时游标在index=3的位置，从元素3开始再遍历
• 当删除index=2的元素2的时候，因为这个元素前面的所有索引的位置都没有变动，所以再下一次，还能遍历到index=1的第一个2
• 最终，倒序最大的优势是，从后往前遍历，而前面所有元素的索引是没有变动的，固后续的遍历过程没有受是否删除元素的影响。这个是倒序最核心的优势！！！

3. 删除列表中重复的元素

（1）.根据索引删除—(如上倒序的方式)

my_list = [1, 2, 2, 3, 2]
for index in range(len(my_list) - 1, -1, -1):
    item = my_list[index]
    print("item-------->", index, "--->", item)
    if item == 2:
        my_list.pop(index)
print(my_list)

（2）.根据元素删除—(结果正确，但是过程是错误)

my_list = [1, 2, 2, 3, 2]
for index in range(len(my_list) - 1, -1, -1):
    item = my_list[index]
    print("item-------->", index, "--->", item)
    if item == 2:
        my_list.remove(item)
        print("--->", my_list)
print(my_list)

# 结果

item--------> 4 ---> 2
---> [1, 2, 3, 2]				# 此处倒序遍历，其实删除的是从左向右的第一个元素2

item--------> 3 ---> 2
---> [1, 3, 2]					# 此除遍历的是第二个2，删除的也是第二个元素

item--------> 2 ---> 2
---> [1, 3]						# 次数遍历的是最后一个2，删除的也是这个元素

item--------> 1 ---> 3
item--------> 0 ---> 1

[1, 3]

如上的方式不好的地方是：

• 倒序遍历了，但是最终删除的元素是从左向右排序的元素。如果出现多个相同的元素，则删除的不是当前遍历到的元素。
• 次方法， 慎重使用！！！

到此这篇关于Python3列表删除的三种方式实现的文章就介绍到这了,更多相关Python3列表删除内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！