Python教程-列表
列表
列表是Python中最基本且常用的数据结构之一。列表中的每个元素都被分配一个数字作为索引，用于表示该元素在列表中的位置。索引从0开始，第一个元素的索引是0，第二个元素的索引是1，依此类推。
Python的列表是一个有序可重复的元素集合，它支持嵌套、迭代、修改、切片、追加和删除操作，并且可以用于判断元素是否属于列表。
从数据结构的角度来看，Python的列表是一个可变长度的顺序存储结构，每个位置存放的是对象的指针。
举个例子，对于列表 alist = [1, "a", [11, 22], {"k1": "v1"}]，它在内存中的存储方式可以表示为：
1. 创建方式
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。列表内的元素，可以是其它任意类型的数据，可多层嵌套列表，元素个数无限制。
>>> lis = [] # 创建一个空列表
>>> lis = [1, 2, 3]
>>> lis = [1, 'a', [11,22], {'k1':'v1'}]
>>> lis = [1, 2, [3, 4, 5]]2. 访问列表内的元素
列表从0开始为它的每一个元素顺序创建下标索引，直到总长度减一。要访问它的某个元素，以方括号加下标值的方式即可。注意要确保索引不越界，一旦访问的 索引超过范围，会抛出异常。所以，一定要记得最后一个元素的索引是len(list)-1。
>>> lis = ["a", "b", "c"]
>>> lis[0]
'a'
>>> lis[1]
'b'
>>> lis[2]
'c'
>>> lis[3]
Traceback (most recent call last):
File "<pyshell#7>", line 1, in <module>
lis[3]
IndexError: list index out of range3. 修改元素的值
直接对元素进行重新赋值。
>>> lis[0]
'a'
>>> lis[0] = "d"
>>> lis[0]
'd'4. 删除元素
使用del语句或者remove(),pop()方法删除指定的元素。
>>> lis = ["a", "b", "c"]
>>> del lis[0]
>>> lis
['b', 'c']
>>> lis.remove("b")
>>> lis
['c']
>>> lis.pop()
'c'
>>> lis
[]5. 列表的特殊操作
除了以上的常规操作，列表还有很多有用的其它操作。
| 语句 | 结果 | 描述 |
|---|---|---|
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合两个列表 |
| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 列表的乘法 |
| 3 in [1, 2, 3] | True | 判断元素是否存在于列表中 |
| for x in [1, 2, 3]: print x, | 1 2 3 | 迭代列表中的每个元素 |
6. 针对列表的常用函数
Python有很多内置函数，可以操作列表。
| 函数 | 作用 |
|---|---|
| len(list) | 返回列表元素个数，也就是获取列表长度 |
| max(list) | 返回列表元素最大值 |
| min(list) | 返回列表元素最小值 |
| list(seq) | 将序列转换为列表 |
让我们看一些例子：
>>> s = [1, 4, 9, 16, 25]
>>> len(s)
5
>>> max(s)
25
>>> min(s)
1
>>> s = list((1, "a", "b", 2))
>>> s
[1, 'a', 'b', 2]
>>> max(s) # 不能混合不同类型进行最大最小求值
Traceback (most recent call last):
File "<pyshell#20>", line 1, in <module>
max(s)
TypeError: '>' not supported between instances of 'str' and 'int'这些操作都不会修改列表本身，属于安全操作。max、min在Python3中，不能对不同类型的对象进行大小的比较了。
7. 切片
切片指的是对序列进行截取，选取序列中的某一段。
切片的语法是： list[start:end]
使用冒号来分割索引，其中start表示起始索引，end表示结束索引。如果省略start，则表示从列表的开头开始。如果省略end，则表示直到列表的结尾。需要注意的是，切片操作是左闭右开的，也就是说，[start:end]将截取索引为start到end-1的元素，不包括索引为end的元素。切片操作不会修改原始列表，可以将结果保存到新的变量中，因此是一种安全的操作。通常用于复制列表，例如 newlist = oldlist[:]。
如果提供的是负数索引，将从列表的末尾开始向头部进行查找。例如，-1表示最后一个元素，-3表示倒数第三个元素。
在切片过程中，还可以设置步长（间隔），使用第二个冒号进行分割。例如，list[3:9:2]表示每隔2个元素取一个，从索引3开始到索引9之前。
下面是一些例子，让你有更清晰的了解。
>>> a = [1,2,3,4,5,6,7,8,9,10]
>>> a[3:6]
[4, 5, 6]
>>> a[:7]
[1, 2, 3, 4, 5, 6, 7]
>>> a[2:]
[3, 4, 5, 6, 7, 8, 9, 10]
>>> s = a[:]
>>> s
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> s.remove(4)
>>> s
[1, 2, 3, 5, 6, 7, 8, 9, 10]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a[-1]
10
>>> a[-3]
8
>>> a[-5:]
[6, 7, 8, 9, 10]
>>> a[::-1]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> a[1:8:2]
[2, 4, 6, 8]
>>> a[1:8:-2]
[]
>>> a[-8::-2]
[3, 1]
>>> a[-8::2]
[3, 5, 7, 9]8. 多维列表（嵌套列表）
列表可以嵌套列表，形成多维列表，形如矩阵。其元素的引用方法是listi[k].....。当然，也可以嵌套别的数据类型。
>>> a = [[1,2,3],[4,5,6],[7,8,9]]
>>> a[0][3]
2
>>> a = [[1,2,3],[4,5,6],[7,8,9],{"k1":"v1"}]
>>> a[3]["k1"]
'v1'9. 列表的遍历
列表有好几种遍历方式：
a = [1,2,3,4,5,6]
---------------------------
for i in a: # 遍历每一个元素本身
print(i)
------------------------------
for i in range(len(a)): # 遍历列表的下标，通过下标取值
print(i, a[i])
--------------------------------
x = 9
if x in a: # 进行是否属于列表成员的判断。该运算速度非常快。
print("True")
else:
print("False")10. 列表的内置方法
下图中的方法是列表专有的内置方法，请熟记于心。
| 方法 | 作用 |
|---|---|
| append(obj) | 在列表末尾添加新的对象 |
| count(obj) | 统计某个元素在列表中出现的次数 |
| extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
| insert(index, obj) | 将对象插入列表 |
| pop(obj=list[-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| remove(obj) | 移除列表中某个值的第一个匹配项 |
| reverse() | 反向列表中元素 |
| sort([func]) | 对原列表进行排序 |
| copy() | 复制列表 |
| clear() | 清空列表，等于del lis[:] |
注意：其中的类似 append，insert, remove 等方法会修改列表本身，并且没有返回值（严格的说是返回None）。
注意例子中的lis变量，不要写成list了。有些发生错误的地方是错误用法展示，仔细看为什么错了。
>>> lis = ["a", "b", "c", "d"]
>>> lis.append("A")
>>> lis
['a', 'b', 'c', 'd', 'A']
>>> lis.count()
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
lis.count()
TypeError: count() takes exactly one argument (0 given)
>>> lis.count("a")
1
>>> lis.extend(["a","b"])
>>> lis
['a', 'b', 'c', 'd', 'A', 'a', 'b']
>>> lis.count("a")
2
>>> lis.index("a")
0
>>> lis.index("A")
4
>>> lis.insert(3, "E")
>>> lis
['a', 'b', 'c', 'E', 'd', 'A', 'a', 'b']
>>> s = lis.pop()
>>> s
'b'
>>> lis
['a', 'b', 'c', 'E', 'd', 'A', 'a']
>>> s = lis.pop(4)
>>> s
'd'
>>> lis
['a', 'b', 'c', 'E', 'A', 'a']
>>> lis.remove(3)
Traceback (most recent call last):
File "<pyshell#19>", line 1, in <module>
lis.remove(3)
ValueError: list.remove(x): x not in list
>>> lis.remove("E")
>>> lis
['a', 'b', 'c', 'A', 'a']
>>> lis.reverse()
>>> lis
['a', 'A', 'c', 'b', 'a']
>>> newlis = lis.copy()
>>> lis
['a', 'A', 'c', 'b', 'a']
>>> newlis
['a', 'A', 'c', 'b', 'a']
>>> newlis.clear()
>>> newlis
[]
>>> lis.sort()
>>> lis
['A', 'a', 'a', 'b', 'c']11. 将列表当做堆栈
Python的列表非常适合用作堆栈数据结构，并且非常方便。堆栈是一种特定的数据结构，最先进入的元素最后被释放（后进先出）。通过将列表的开头作为栈底，列表的末尾作为栈顶，我们可以创建一个堆栈结构。使用列表的append()方法可以将一个元素添加到堆栈的顶部（实际上是在列表的末尾添加一个元素）。而使用pop()方法时不指定索引，可以从堆栈的顶部释放一个元素（即从列表的末尾弹出一个元素）。例如：
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]列表在内存内部是顺序存储结构的，所以在其尾部的添加和删除动作，也就是append和pop方法的效率非常高，具备随机存取速度，也就是O(1)的时间复杂度，因此用作堆栈是再合适不过了。
12. 将列表当作队列
Python的列表也可以用作队列。队列是一种先进先出（First-In-First-Out，FIFO）的数据结构。然而，使用列表作为队列并不高效。虽然在列表的末尾添加和弹出元素的速度很快，但在列表的开头弹出第一个元素的速度较慢（因为所有其他元素都需要依次向左移动一个位置）。为了实现高效的队列操作，Python提供了queue.Queue作为单向队列，以及collections.deque作为双向队列。
