三、Python的列表

列表

1、什么是列表

2、列表的创建

3、列表的查操作之获得指定元素的索引

最后一个元素的索引是 -1 。

• 我们想要获得列表中9这个元素的索引，也就是要找到9这个元素在列表中对应的索引：

• 由于列表中可以存在重复的元素，像这个列表中就存在两个7，如果列表中存在多个指定元素，那么我们调用方法index后它会返回哪个元素的索引值呢？
  

• 如果我们在调用index方法的时候，列表中不存在指定的元素，那么方法index应该返回什么呢？
  
  这个时候抛出错误了，抛出ValueError：8 is not in list。

• 此外，我们在调用方法index的时候，我们还可以指定起始索引start和结束索引stop这两个参数：
  
  我想要查找7在列表中的索引，但是我从第3个索引开始进行查找：
  
  也就是从9这个元素开始往后查找，查找7在列表中的索引。
  注意，这个3是我指定的起始索引，大家注意，我可以只指定起始索引，但是我不能只指定结束索引。

• 当然我也可以同时指定起始索引和结束索引：

L.index(7, 3, 7)		# 能找到7在列表中的索引，是6
print(L.index(7, 3, 7)	# 6

从第3个索引开始，结束索引是7，当然不包含这个结束索引，也就是说，从9、2、1、7这四个数中查找7，那么当然能够找到。

但是如果结束索引我指定为5的话，也就是说从起始索引3开始，结束索引为5，当然不包含5的话，就指的是从9和2里面找7，当然找不到，所以又会抛出ValueError错误了，说7不在列表中：

print(L.index(7, 3, 5))		# ValueError：7 is not in list

所以呢，这个起始索引和结束索引就指定的是一个列表的一个子列表，从列表的一个子列表中查找指定的元素，但是这个子列表不包含stop这个参数所对应的那个索引。

4、列表的查操作之使用索引一次只获得一个元素

• 如上图所示，每个元素都有两个整数类型的索引

• 每个元素都有两个整数类型的索引，一个是大于0的，一个是小于0的，我通过索引就能获得列表中指定的元素。

例如print(L[0])获得列表L中索引为0的那个元素。

print(L[-10])的结果是：
大家看上面那张表，索引为0和索引为 -10对应的元素都是5，所以打印结果应该是5。

大家看上面那张表，6和 -4这两个索引对应的元素都是8，所以打印结果应该是8。

9和 -1这两个索引对应的元素都是2，索引都应该打印2。

• 如果我们指定的索引在列表中不存在，那么会打印出什么呢？

抛出错误了，列表的索引越界了、索引错误了。

好了，这就是如何通过的索引来获得列表中元素，它的语法非常的简单，就是在列表所对应的变量名后面添加一个中括号，把索引写在中括号里面，既可以使用正数的索引，也可以使用负数的索引，都可以获得这个索引所对应的列表中的元素。
但是呢，它一次只能获得一个元素；如果我们想要一次获得列表中的多个元素，该怎么操作呢？下节课会给大家详细讲解。

5、列表的查操作之使用切片一次获得多个元素

根据上图分析，print(L[1:7:2])得到的元素是3、4、6，下一个元素是1，但是不包括这个结束索引7，即不包括1这个元素，所以得到的切片是 [3, 4, 6] ，这个切片仍然是一个列表，它是原始列表的片段的一份拷贝。

• 我们再看一个start、stop、step都没有的例子：

L[::]

首先我把step省略掉，那么step的默认值是1，这个时候相当于step为正数，所以这个时候，我如果不指定start的话，切片的第一个元素默认是列表的第一个元素，并且如果不指定stop的话，切片的最后一个元素默认是列表的最后一个元素。
所以这样写的话，相当于把原始的列表全都取出来了。

• 当step为 -1 的情况：

• 如果不指定start，那么切片的第一个元素默认是下图所示列表的最后一个元素，也就是2，如果不指定stop，切片的最后一个元素默认是列表的第一个元素，也就是5；
• 2是第一个元素，5成了最后一个元素，相当于把以前的列表做了一个反转：
  

print(L[6:0:-2])

我们说当step为负数的时候，从索引start开始往前计算切片，start索引是6，也就是8这个元素，步长为 -2，往前计算切片，一直到索引0但是不包括索引0这个元素，也就是到3这个元素就结束了。
输出为：

[8, 0, 9]

再看一个例子：

print(L[0:6:-2])	# []

start是0，也就是说5这个元素，往前计算切片的话，是不是再往前就没有元素了，所以这个时候得到的是一个空列表。

• 再注意一个例子：

print(L[6::-2])	# [8, 0, 9, 5]

首先step为负数，这个时候呢从start开始，往前计算切片，也就是说从8这个元素开始往前计算切片：


我没有指定stop，所以切片的最后一个元素默认是列表的第一个元素，我从8这个元素开始往前计算切片，8，0，9，5，这个时候就包含5了，因为切片的最后一个元素默认是列表的第一个元素。

print(L[:5:-2])	# [2, 1]

步长是负2，所以从start开始往前计算切片，我没有指定start，所以切片的第一个元素默认是列表的最后一个元素，也就是说从最后一个元素2开始往前计算切片，stop是索引5，也就是6这个元素，但是切片不包含stop对应的元素，所以从2开始，由于步长是 -2，因此对应的切片是2和1组成的列表。

• 大家注意，切片操作是允许索引越界的

上节课我们在讲通过索引一次只获取列表中的一个元素的时候，是不允许索引越界的，但是切片操作是允许索引越界的。

我们再写一个例子：

L = []
print(L[:100:]	# [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

step的默认值是1，如果不指定start，切片的第一个元素默认是列表的第一个元素，运行该程序，不但没有抛出IndexError错误，我们还得到了结果，得到了一个列表，这个列表就是原始列表，我们指定的这个索引100，比列表中的stop要大，所以相当于是，如果超出了列表中的最大元素的话，它默认就是取整个列表。

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]
print(L[-100:]	# [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

这样写的话step的默认值仍然是1，start是 -100，当step为正数的时候，如果不指定stop，切片的最后一个元素默认是列表的最后一个元素。但是start是 -100，我们看列表中的索引不存在 -100这个索引，而远远的要比我们列表中的 -10要小，但是打印的结果仍然是原始的列表，也就是说我们指定的这个起始索引可以比列表中第一个元素的起始索引要小很多，这是可以的，我们指定的这个stop可以比列表中最大的那个索引大很多，也是可以的；总之是允许索引越界的。

• 内置函数slice

我们可以调用一个内置函数slice（或者说slice类的构造方法）来创建slice类型的对象。

我们调用slice(stop)进行测试：

好了，这就是使用切片操作，一次获得列表中的多个元素，切片操作在我们日后写程序的时候非常常用，所以大家一定要熟练的掌握本节我们讲的切片操作。

6、列表的查操作之使用运算符in检查是否存在指定元素

7、列表的改操作

如果我们想要修改列表中的元素，那么怎么来修改呢？常见的方式有两种。

• 大家注意，即便是只有一个元素，我也要把它放在列表中！
  
• 还要注意，当我们为指定的切片赋予一个新值的时候，等号左右的元素个数可以不同！

L = [3, 5, 9, 2, 7]
L[1:4] = [1, 8]	# 将列表中的元素5，9，2修改为1，8
print(L)	# [3, 1, 8, 7]

等号左边对应的是3个元素，而等号右边对应的是2个元素，修改之后列表变成了：

这种情况下，列表中其他元素的索引也会随之改变，大家看上图，我将5，9，2修改为了1和8，但是最后一个元素7它的索引本来是4，现在变成3了，而第一个元素3的索引也发生了变化，本来是索引 -5，现在变成 -4了。

这就是修改列表中元素的两种常见方式，如果你一次只修改一个元素的话，那么这两种方式你都可以使用，如果你想一次修改多个元素的话，那么你只能使用第二种方式，为指定的切片赋予一个新值。

8、列表的增操作

• 调用方法append

值得大家注意的是，其他元素的索引也随之发生了改变，尤其负数的索引也会随之改变。

我们发现程序输出为None，这是为什么打印出来是None呢？因为我们直接这样打印的话，是不是打印的是方法append的返回值啊，所以我们应该先调用一下append这个方法，然后打印列表L就行了：

接着我们在列表L的末尾添加9和10这两个元素，结果输出为：

从上面程序的输出可以看到，它是把9和10这个列表整体作为一个元素，添加在了列表L的末尾。

• 调用方法extend

我调用extend这个方法的时候，把[9, 10]这个列表直接传进来，根据运行结果，我们可以看到，这种extend方法把列表中的每一个元素单独又作为了一个元素，添加在了列表的末尾，这是exend和append的区别。

• 调用方法insert

当我们在列表中插入一个元素的时候，这个位置后面的所有元素都后移一个位置。

那么我可不可以在7这个元素后面，再添加一个元素9呢？这也是可以的。


我们调用内置函数len来获得列表的长度，大家知道，因为列表中元素的索引是从0开始的，所以列表中最后一个元素的索引是len(L)的返回值减1，所以呢，列表中最后一个元素后面的那个位置，它的索引就是len(L)的返回值。这种通过insert函数往列表尾部添加元素的方式，相当于是调用了append函数或者是extend函数。

• 为指定的切片赋予一个新值

L[2 : 3] = [8, 9]
print(L)	# [3, 4, 8, 9, 6]

在上节课讲列表的改操作的时候，上面代码的修改方式是为指定的切片赋予一个新值，这种是把列表中索引为2的元素5改成8和9了，所以列表中应该是[3, 4, 8, 9, 6]。
但是，我们这节课是要执行列表的增操作，所以我这样改：

如果是[2:3]的话指定的是索引为2的位置，如果是[2:2]的话，指定的是元素4和5之间的位置（如上图选中的那块），也就是要往4和5之间的位置添加8和9，所以输出是：

所以 L[2 : 2] 这种你不好理解的话，你可以跟列表的改操作结合起来，这样就比较好理解了。

• 内置函数len(L)

len(L)这个内置函数，把L传进去，它指的是列表L的最后一个元素后面那个位置的索引：

len(L)指的是上图最后面虚线框位置的索引，就相当于是在列表的末尾我们可以再来添加几个元素，给它赋值一个列表：

这就相当于是说，在列表的末尾再添加1和2这两个元素。

• 总结：

这就是往列表中添加元素的四种常见的方式。其中，前两种方式只能在列表的末尾添加，如果你想在末尾只添加一个元素，你可以调用方法append，如果你想在列表的末尾一次至少添加一个元素，你可以调用方法extend；第三种和第四种方式可以在列表的任意位置添加元素，如果你一次只添加一个元素的话，那么三和四这两种方法都是可以的，如果你想一次至少添加一个元素，那么你只能使用第四种方式，通过为指定的切片赋予一个新值。

9、列表的删操作

• 调用方法remove

• 我可以直接指定要删除的元素。

• 如果列表中存在多个指定元素，那么我们删除哪个元素呢？

列表中存在两个5，如果我指定要删除的是5的话，那么要删除的是哪个5呢？

• 如果我们要删除的指定元素在列表中不存在，会出现什么情况呢？

抛出错误，在列表中不存在。

• 调用方法pop

• 使用del语句

• 给指定的切片赋值一个空列表

• 调用方法clear清空列表

• 总结

这就是删除列表中相关元素的5种方式，我们再来回顾一下。
如果一次只删除一个指定的元素，可以调用方法remove；
如果一次只删除一个指定索引的元素，那么调用方法pop；
如果我们想要一次至少删除一个元素，那么既可以使用del语句，也可以给指定的切片赋值一个空列表；
如果我们想要将列表中的所有元素一次性清空，可以调用方法clear，当然也可以使用给指定的切片赋值一个空列表这种方式。

10、使用加法和乘法运算符操作列表

• 使用加法运算符操作列表

我们可以使用加法运算符将两个列表合并后生成一个新列表，并且被合并的两个列表不会发生任何的变化。


注意，从打印结果我们发现，L2也发生了变化！这是为什么呢？

• 参数赋值运算符 += 号它会对列表本身进行修改。

我们来看图进行分析：

看上图，刚开始，L1和L2这两个标签都指向1和2组成的这个列表（见上左图），接下来将这个L1和[3, 4]这个列表进行合并，合并后的列表再赋值给L1，所以L1指向了合并后的新列表[1, 2, 3, 4]，但是L2这个标签仍然指向的是[1, 2]这个列表。

我们再来看第2个例子：

看上图，刚开始，L1和L2都指向1和2组成的列表（见上左图），接下来将L1这个列表和[3, 4]这个列表进行了合并，合并后重新赋值给L1，但是因为参数赋值运算符 += 号它会对列表本身进行修改，也就是它相当于是说在L1指向的这个[1, 2]列表的基础上，后面又加了3和4两个元素，因此得到一个新列表，这样呢因为L2也指向的是[1, 2]这个列表，所以当我们对[1, 2]这个列表进行修改的时候，L2这个标签它所指向的列表，其实就是L1这个标签所指向的列表，它们始终一直指向同一个列表，所以当通过参数赋值运算符对L1指向的列表进行修改的时候，L1和L2这两个标签所指向的列表都会发生改变。
大家要注意，参数赋值运算符 += 会对列表本身进行修改。

• 使用乘法运算符操作列表

同样，使用乘法运算符操作列表的时候，被乘的列表也不会发生任何的改变，但是用乘法运算符操作列表之后，会是什么样的结果呢？
它会使用乘法运算符将列表中的所有元素重复n次后，生成一个新的列表。

乘法运算符操作列表的时候，它经常用于列表的初始化，如果我想创建一个列表L，将它初始化为所有值都为0的5个元素，我就这样写：

11、使用比较运算符比较两个列表

• 比较规则

首先比较两个列表中的第一个元素，如果它们相等的话，那继续比较下一个元素，这样依次比较下去，直到两个列表中的元素不相等时，那么比较结果就是两个列表的比较结果，这个时候呢，两个列表中的所有后续元素就不再继续比较下去了。
如下图所示：

上图两个列表的比较，首先比较两个列表中的第1个元素，都是2，它们相等，那么继续比较下一个元素，都是3，那么继续比较下一个元素，发现8小于9了，所以这个时候8和9的比较结果就作为这两个列表的比较结果，所有的后续元素都不再继续被比较了；因此这两个列表的比较结果，是上一个列表小于下一个列表。

• 再来举个例子：

对于大于号左边的列表，里面又嵌套了一个列表，右边那个列表也是这样的，是列表的嵌套。
首先比较第一个元素7和7是相等的，然后继续比较下一个元素，下一个元素就都是列表了，那么相当于又比较这两个被嵌套的列表是否是大于关系；先比较第一个元素2和2是相等的，再来比较下一个元素6和5，发现6大于5，因此6大于5的比较结果就是这两个列表的比较结果，因此仍然返回True。

• 还可以使用 is 对两个列表进行比较

a和b这两个标签指向的是同一个列表么？

print(a is b)	# True

确实是同一个列表，所以返回True。

a和c这两个标签引用的是同一个列表么？

print(a is c)	# False

不是同一个列表，所以返回False。

12、列表的反转

• 调用方法reverse

• 调用内置函数reversed

内置函数reversed它的返回值是一个迭代器对象，并且被反转的序列不发生变化。
将内置函数reversed的返回值赋值给一个变量，然后将这个内置函数的返回值（那个变量）打印出来看看：

大家可以看到，打印出来的是一个列表反转迭代器对象，为了能够清楚地看到这个对象所表示的内容，我们将它转换成列表：

• 总结：

这就是对列表中的所有元素进行反转的两种常见方式，一种是调用列表的方法，一种是调用内置函数；
一种是对列表本身进行了修改，另外一种是生成一个迭代器对象，但是被反转的列表不发生任何变化，所以大家一定要对这两者加以区分。

13、列表的排序

• 调用方法sort

在我们调用方法sort的时候，我们可以指定一个参数叫reverse，它代表的是反转、逆序，因此当我们指定这个reverse参数为True的时候，我们可以按照逆序进行排序：

就是按照从大到小的顺序进行了逆序排序。

• 调用内置函数sorted

在调用内置函数sorted的时候，我们也可以指定reverse参数，将它的值指定为True，从而按照逆序进行排序：

14、多维列表

当一个列表中的元素也是列表的时候，就构成了多维列表。比如说，当列表中的元素是一维列表时，就构成了二维列表；当列表中的元素时二维列表的时候，就构成了三维列表。因此呢我们可以把多维列表看成是一个特殊的一维列表。

• 一维列表的操作也适用于多维列表

首先，创建一个二维的列表，所谓二维列表就是列表中的元素也是一维列表：

如果我想获得列表中的8这个元素，该怎么样获得呢？
大家看下面这张图：

列表中包含了3个元素，每个元素都是一个一维列表，如果我想获得第2个元素中的一维列表中的8这个元素，该怎么获得呢？
我把第2个元素又分解成了上图中下面那个一维列表[6, 8, 9, 7]，所以我可以这样获得：
L[2] 这样获得的是 [6, 8, 9, 7] 这样一个列表，获得的是索引为2的元素，所对应的是 [6, 8, 9, 7] 这样一个列表。
然后对于 [6, 8, 9, 7] 这样一个列表，我想获得其中的8的话，继续写中括号，在上图中下面那个列表中这个8所对应的索引是1，所以：

也就是说，我先通过 L[2] 获得 [6, 8, 9, 7] 这个元素，然后对于 [6, 8, 9, 7] 这个列表再通过这个索引 1 得到对应的元素8。
对于列表的修改，比如说我想将索引为1的这个列表 [1, 5, 2] 修改为一个整数9；我还可以在列表的末尾追加一个列表：


我还可以删除列表中的某个元素，比如我想删除索引为2的这个元素 [6, 8, 9, 7] ：
L.pop(2) 这个 2 指定的是列表中的索引。

所以呢，一维列表的操作也适用于多维列表。

• 多维列表的初始化

在实际开放当中，我们如果用到多维列表的话，通常需要对多维列表进行初始化。
如果我想创建一个二维的列表，这个二维的列表由4个一维列表组成，这4个一维列表中的所有元素都是0：
[0] * 3 这样得到的列表是包含3个0的一个列表。

除了使用乘法运算符，我们还可以使用另外一种技术，列表生成式，在以后的课程中会讲，这里先写一下让大家了解下：

上图选中的 0 是列表中每一个元素的一个表达式，然后是for循环，循环3次，也就是说每次循环都将0添加到列表中，所以循环3次就得到了 [0, 0, 0] 这样一个列表；
然后我把 [0 for i in range(3)] 这个列表又作为一个元素，把它包含在另外一个列表生成式里面，再循环4次：

大家对此可以先有个了解，当然我也可以把这两种方式结合起来：