python--列表(List)的操作(元素的添加和删除以及列表的复制)

---

参考链接：
python 列表1
python 列表2

一、列表元素的添加

1. list.append()

append()方法在列表末尾添加一个元素，例如：

list1 = ['a']
print(list1)
list1.append('b')
print(list1)

打印结果如下：

[‘a’]
[‘a’, ‘b’]

上述例子中添加的都是字符串元素，也可以添加不同类型的，如数值，或者列表元素，如下所示：

list1 = ['a']
print(list1)
list1.append('b')
print(list1)
list1.append(88)
print(list1)
list1.append(['c'])
print(list1)

结果如下：

[‘a’]
[‘a’, ‘b’]
[‘a’, ‘b’, 88]
[‘a’, ‘b’, 88, [‘c’]]

2. list.extend()

extend()也是在列表的末尾添加元素，与append()方法不同的是，extend()方法可以添加单个或者多个元素。但是需要注意的是单个元素添加方法与append()方法一样，而多个元素添加时需要元素本身组成一个列表的形式。例如：

list1 = ['a']
list1.append('b')
print(list1)
list2 = []
list2.extend('c')
print(list2)
list2.extend(list1)
print(list2)

结果如下，可以看出extend()方法在添加多个元素组成的列表时，将列表中的元素取出，然后按照顺序依次添加到目标列表中。而在append()方法中，遇到添加的元素是列表形式时，直接将其当作一个元素添加进去。

[‘a’, ‘b’]
[‘c’]
[‘c’, ‘a’, ‘b’]

3. list.insert()

list.insert(index, obj)
insert()方法在列表索引值index位置之前插入元素。

list1 = ['a','b','c']
list1.insert(0,'d')
print(list1)

结果：

[‘d’, ‘a’, ‘b’, ‘c’]

---

二、列表元素的删除

1. del list[index]

删除列表中某个索引处的元素，如下：

list1 = ['a','b','c','d','a','b']
print(list1)
del list1[2]
print(list1)

结果如下，原来索引值2的位置时元素‘c’，执行以后被删除了。

[‘a’, ‘b’, ‘c’, ‘d’, ‘a’, ‘b’]
[‘a’, ‘b’, ‘d’, ‘a’, ‘b’]

2. list.remove(obj)

删除列表中第一个符合条件的元素，例如：

list1 = ['a','b','c','d','a','b']
print(list1)
del list1[2]
print(list1)
list1.remove('b')
print(list1)

结果如下，remove之前，列表中有两个‘b’，执行remove之后第一个’b’被删除了。
这里可能会联想到如何删除重复的元素呢？这里后面再讲。

[‘a’, ‘b’, ‘c’, ‘d’, ‘a’, ‘b’]
[‘a’, ‘b’, ‘d’, ‘a’, ‘b’]
[‘a’, ‘d’, ‘a’, ‘b’]

3. list.pop(index)

删除指定位置的元素，没有指定删除的索引值时默认删除末尾的元素

list1 = ['a','b','c','d','a','b']
print(list1)
res = list1.pop()
print(list1)
print(res)
res = list1.pop(2)
print(list1)
print(res)

结果如下，函数返回值是删除的元素。

[‘a’, ‘b’, ‘c’, ‘d’, ‘a’, ‘b’]
[‘a’, ‘b’, ‘c’, ‘d’, ‘a’]
b
[‘a’, ‘b’, ‘d’, ‘a’]
c

---

三、删除重复元素

参考：
python删除列表重复元素
python四种方法实现去除列表中的重复元素

1. 通过集合(set)转换

集合没有重复元素，因此先转换为集合自动删除重复元素，然后再转换为列表。
该方法的优点是使用简单，缺点是元素顺序打乱了。

list1 = ['9','8','9','3','6','6','3','8']
print(list1)
list2 = list(set(list1))
print(list2)

结果如下，集合删除重复元素看起来没有什么规律：

[‘9’, ‘8’, ‘9’, ‘3’, ‘6’, ‘6’, ‘3’, ‘8’]
[‘9’, ‘3’, ‘6’, ‘8’]

2. 通过字典键值(key)转换

先将列表中的元素转换为一个字典的关键字（dict.fromkeys），由于字典关键字是唯一的，因此可以自动去重。然后获取该字典中的关键字（dict.keys），最后将其转换为列表即可。如下：

list1 = ['9','8','9','3','6','6','3','8']
print(list1)
list2 = dict.fromkeys(list1).keys()
print(list2)
list2 = list(list2)
print(list2)

结果如下，dict.keys()获取的字典关键字类型是dict_keys，因此还需要进行列表转换。

[‘9’, ‘8’, ‘9’, ‘3’, ‘6’, ‘6’, ‘3’, ‘8’]
dict_keys([‘9’, ‘8’, ‘3’, ‘6’])
[‘9’, ‘8’, ‘3’, ‘6’]

3. 使用numpy中的unique去重

先通过np.unique()去除重复元素，再通过将结果由numpy数组转换为list。

import numpy as np
list1 = ['9','8','9','3','6','6','3','8']
print(list1)
list2 = list(np.unique(list1))
print(list2)

结果：

[‘9’, ‘8’, ‘9’, ‘3’, ‘6’, ‘6’, ‘3’, ‘8’]
[‘3’, ‘6’, ‘8’, ‘9’]

4. 循环判断

通过判断元素是否在新列表中，从而为新列表添加元素。
方法的优点是元素顺序仍然保留，缺点是时间复杂度比较大。

list1 = ['9','8','9','3','6','6','3','8']
print(list1)
list2 = []
for obj in list1:
    if obj not in list2:
        list2.append(obj)
print(list2)

结果：

[‘9’, ‘8’, ‘9’, ‘3’, ‘6’, ‘6’, ‘3’, ‘8’]
[‘9’, ‘8’, ‘3’, ‘6’]

5. 排序以后相邻元素比较

先对列表元素进行排序，排序以后重复元素会相邻，于是可以循环判断相邻元素是否相等来操作。
此处笔者是先将重复的元素前一个设置成空值，然后再判断空值从而删除。
该方法的好处是不用另外开辟空间存储新列表，且时间复杂度比较低（排序部分未计入）；缺点就是原先元素的顺序因排序被打乱。

list1 = ['9','8','9','3','6','6','3','8']
print(list1)
list1.sort()
for i in range(len(list1)-1):
    if list1[i] == list1[i+1]:
        list1[i] = ''
for obj in list1:
    if obj == '':
        list1.remove(obj)
print(list1)

或者还有一种办法，从列表末尾往前遍历，直接删除重复的元素，这样在删除重复元素以后不会影响前面的索引值，如下：

list1 = ['9','8','9','3','6','6','3','8']
print(list1)
list1.sort()
for i in range(len(list1)-2,-1,-1):	
	if list1[i+1] == list1[i]:		
		list1.remove(list1[i+1])
print(list1)

两种方法的结果都是：

[‘9’, ‘8’, ‘9’, ‘3’, ‘6’, ‘6’, ‘3’, ‘8’]
[‘3’, ‘6’, ‘8’, ‘9’]

---

四、列表的拷贝(复制)

更新一个列表复制的好文：正确复制列表的方法

---

1. 直接赋值

list1 = [1, 2, 3]
list2 = list1
print(list1)
print(list2)
list1.remove(1)
print(list1)
print(list2)

上述代码中用list1赋值list2，之后删除list1中的元素，会发现list2也跟随变化，结果如下：

[1, 2, 3]
[1, 2, 3]
[2, 3]
[2, 3]

两个列表直接赋值，其实指向的是同一个地址，因此修改一个会导致另一个发生改变。
这样的结果其实不是我们愿意看到的，那么有没有办法让两个列表分别变成独立变量呢？这便涉及到了拷贝。我们先来看看浅拷贝。

2. 浅拷贝

python3中list有个copy()的方法，我们先来试试看：

list1 = [1, 2, 3]
list2 = list1.copy()
list1.remove(1)
print(list1)
print(list2)

结果如下：

[2, 3]
[1, 2, 3]

我们惊喜的发现，用copy()的方法可以实现两个list相互独立，那么是不是这样就可以了呢？别急，往后看。
我们再来看一个例子；

list1 = [1, [1, 2, 3], 3]
list2 = list1.copy()
list1.remove(3)
list1[1][0] =3
print(list1)
print(list2)

list1是一个嵌套列表，其中包含列表元素，我们先删除其中元素3，然后修改嵌套列表中的1为3，结果如下：

[1, [3, 2, 3]]
[1, [3, 2, 3], 3]

理论上list2的结果应该是[1, [1, 2, 3], 3]对不对，而实际上结果却是list2的嵌套列表中的元素会随list1而改变，这意味着copy()其实只是外层元素的拷贝，嵌套列表元素还是赋值的形式。这是什么原因呢？我们想想，前面我们说直接赋值其实是将两个变量指向了同一个地址，那么内容改变的话，两个变量都会发生改变。回到这里就好解释了，嵌套列表存储的实际是列表的地址，因此list1和list2的内存列表指向的是同一个地址。

了解了上述原理之后，我们就可以知道，其他的诸如列表生成式、for循环或者切片方式(参考文末链接)，这些基本都是浅拷贝，原理都是嵌套列表保存的是地址。到这里你可能想问，既然有浅拷贝，那是不是有深拷贝呢？是不是有方法可以将两个不论多少层嵌套的列表相互独立呢？有的！

3. 深拷贝

深拷贝的实现要借助copy包中的deepcopy()方法，例子如下：

import copy
list1 = [1, [1, 2, 3], 3]
list2 = copy.deepcopy(list1)
list1.remove(3)
list1[1][0] =3
print(list1)
print(list2)

结果如下：

[1, [3, 2, 3]]
[1, [1, 2, 3], 3]

---

参考链接：
https://www.cnblogs.com/Black-rainbow/p/9577029.html
https://www.runoob.com/python3/python3-list.html