【python基础】列表

本文的操作环境为win7_64 + Python 3.7.0_64

基本定义

In [1]: a = []  #定义一个空列表

In [2]: a = list() #使用内建函数list定义一个空列表

In [3]: a = [1, 2, 3] #定义一个列表，包含3个元素

In [4]: a = list(a) #使用内建函数list定义一个列表，初始内容是上面定义的a列表的内容

In [5]: a = [1, 2, "abc", [3, 4]] #定义一个列表，包含四个元素，分别是整数1和2，第三个元素是字符串abc，第四个元素是一个列表，这个列表有两个元素3和4

python里面的列表类似C语言的数组，只不过python的列表元素类型可以任意组合

基本操作

元素的访问

和绝大部分语言一样，python也是以0开始表示第一个元素。

In [5]: a = [1, 2, "abc", [3, 4]]

In [6]: a[0] #访问第一个元素
Out[6]: 1

In [7]: a[1] #访问第二个元素
Out[7]: 2

In [8]: a[3] #访问第四个元素
Out[8]: [3, 4]

In [9]: a[4] #访问越界，这里会报错(IndexError: list index out of range)

python访问元素还可以使用负数表示，其中-1表示倒数第一个元素，-2表示倒数第二个，以此类推

In [10]: a
Out[10]: [1, 2, 'abc', [3, 4]]

In [11]: a[-1] #倒数第一个元素
Out[11]: [3, 4]

In [12]: a[-2] #倒数第二个元素
Out[12]: 'abc'

列表的截取

In [13]: a
Out[13]: [1, 2, 'abc', [3, 4]]

In [14]: b = a[0:2] #从0位置开始取到2位置，不包含2这个位置的元素

In [15]: b
Out[15]: [1, 2]

In [16]: b = a[1:2] #从1位置开始取到2位置，不包含2这个位置的元素

In [17]: b
Out[17]: [2]

In [18]: b = a[:3] #从0位置开始取到3位置，不包含3这个位置的元素

In [19]: b
Out[19]: [1, 2, 'abc']

In [20]: b = a[2:] #从2位置开始取到最后位置

In [21]: b
Out[21]: ['abc', [3, 4]]

In [22]: b = a[2:-1] #从2位置开始取到最后位置(-1)这个位置的元素，不包含-1这个位置的元素

In [23]: b
Out[23]: ['abc']

In [24]: b = a[:-1] #从0位置开始取到最后位置(-1)这个位置的元素，不包含-1这个位置的元素

In [25]: b
Out[25]: [1, 2, 'abc']

python列表的截取，还可以指定步长，下面的示例为了方便起见，定义列表a的值为100,200,300,400,500

In [35]: a = [100, 200, 300, 400, 500]

In [36]: a
Out[36]: [100, 200, 300, 400, 500]

In [37]: a[0:4:1] #取0到4位置，不包含4这个位置，步长为1
Out[37]: [100, 200, 300, 400]

In [38]: a[0:4:2] #取0到4位置，不包含4这个位置，步长为2
Out[38]: [100, 300]

当然，上面访问元素可以使用负索引，那么我们这里的步长也可以使用负数

In [44]: a
Out[44]: [100, 200, 300, 400, 500]

In [45]: a[-1:0:-1] #从最后一个位置(-1)，取到0这个位置，不包含0
Out[45]: [500, 400, 300, 200]

总结规则：

1. 列表元素的访问可以是负数，负数代表反方向访问
2. 列表的截取，起始和结束位置均可以不指定
3. 列表的截取，如果未指定起始位置，表示从0开始，如果未指定结束位置，表示取到最后一个元素
4. 列表的截取，如果指定了起始位置，那么截取的元素包含这个元素，如果指定了结束位置，那么是没有包含这个元素的
5. 列表的截取，起始位置+步长，一定是在往结束位置的方向前进的，如果不符合这个规则，则取得的结果是一个空列表

针对总结的第五点，下面用代码说明：

In [48]: a
Out[48]: [100, 200, 300, 400, 500]

In [49]: a[1:-1:1]
Out[49]: [200, 300, 400]

这里很好理解，取1位置到-1位置(也就是最后一个元素)，步长为1，那么起始位置为1+步长为1，是往-1这个位置方向前进的

接下来看看步长为负数的:

In [50]: a
Out[50]: [100, 200, 300, 400, 500]

In [51]: a[-1:-5:-1]
Out[51]: [500, 400, 300, 200]

取-1(最后一个元素)到-5(第一个元素)，步长为-1，那么起始位置-1+步长-1，是往-5这个方向前进的

看看下面这个为什么取得值为空：

In [53]: a
Out[53]: [100, 200, 300, 400, 500]

In [54]: a[0:-2:-1]
Out[54]: []

首先起始位置为0，步长为-1， 0±1=-1，这是-1，也就是和从0到-2这个方向相反的(也就是实际应该从左往右取值，但是得到的结果是从右往左取值的)，不符合总结规则5，那么得到的结果为[]

列表的反转

In [63]: a
Out[63]: [100, 200, 300, 400, 500]

In [64]: list(reversed(a)) #python3的reversed内建函数返回的是迭代器，python2返回的直接是一个列表
Out[64]: [500, 400, 300, 200, 100]

我们看看更简单的方法：

In [65]: a
Out[65]: [100, 200, 300, 400, 500]

In [66]: a[::-1]
Out[66]: [500, 400, 300, 200, 100]

起始a[::-1]就是a[-1::-1]，python会很智能的判断，最后的步长为-1，表示需要从右往左遍历元素，在根据上面的总结规则2和3条得到最终的结果