Python 入门笔记6——列表
序列
序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列就是一块用来存放多个值的连续的内存空间。比如一个整数序列[10,20,30,40]，可以这样示意表示：
由于 Python3 中一切皆对象，在内存中实际是按照如下方式存储的：
序列中存储的是整数对象的地址，而不是整数对象的值。Python中常用的序列结构有：
列表
列表：用于存储任意数目、任意类型的数据集合。
列表是内置可变序列，是包含多个元素的有序连续的内存空间。列表定义的标准语法格式：
其中，10,20,30,40 这些称为列表 a 的元素。
列表中的元素可以各不相同，可以是任意类型。比如：
列表对象的常用方法汇总如下:
| 方法 | 要点 | 描述 |
|---|---|---|
| list.append(x) | 增加元素 | 将元素 x 增加到列表 list 尾部 |
| list.extend(aList) | 增加元素 | 将列表 alist 所有元素加到列表 list 尾部 |
| list.insert(index,x) | 增加元素 | 在列表 list 指定位置 index 处插入元素 x |
| list.remove(x) | 删除元素 | 在列表 list 中删除首次出现的指定元素 x |
| list.pop([index]) | 删除元素 | 删除并返回列表 list 指定为止 index 处的元素，默认是最后一个元素 |
| list.clear() | 删除所有元素 | 删除列表所有元素，并不是删除列表对象 |
| list.index(x) | 访问元素 | 返回第一个 x 的索引位置，若不存在 x 元素抛出异常 |
| list.count(x) | 计数 | 返回指定元素 x 在列表 list 中出现的次数 |
| len(list) | 列表长度 | 返回列表中包含元素的个数 |
| list.reverse() | 翻转列表 | 所有元素原地翻转 |
| list.sort() | 排序 | 所有元素原地排序 |
| list.copy() | 浅拷贝 | 返回列表对象的浅拷贝 |
Python 的列表大小可变，根据需要随时增加或缩小。
字符串和列表都是序列类型，一个字符串是一个字符序列，一个列表是任何元素的序列。我们前面学习的很多字符串的方法，在列表中也有类似的用法，几乎一模一样。
列表的创建
基本语法[]创建
代码示例：
>>> a = [123,"abc",{
"name":"russell"},{
1,2,3},(1,2,3)]
>>> a
[123, 'abc', {
'name': 'russell'}, {
1, 2, 3}, (1, 2, 3)]
>>> b = []
>>> b
[]
list()创建
使用 list()可以将任何可迭代的数据转化成列表
代码示例：
>>> list((2,9)) #转换元组
[2, 9]
>>> a = {
"name":"Russell","age":18}
>>> list(a.items()) #转换字典
[('name', 'Russell'), ('age', 18)]
>>> list("I love study") #转换字符串
['I', ' ', 'l', 'o', 'v', 'e', ' ', 's', 't', 'u', 'd', 'y']
range()创建整数列表
range()可以帮助我们非常方便的创建整数列表，这在开发中及其有用。语法格式为：
start 参数：可选，表示起始数字。默认是 0
end 参数：必选，表示结尾数字。
step 参数：可选，表示步长，默认为 1
注：start，end，step都必须是整型，否则就会报以下错误
>>> range(11.1)
Traceback (most recent call last):
File "<pyshell#18>", line 1, in <module>
range(11.1)
TypeError: 'float' object cannot be interpreted as an integer
python3 中 range()返回的是一个 range 对象，而不是列表。我们需要通过list()方法将其转换成列表对象。
代码示例：
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]
推导式生成列表
使用列表推导式可以非常方便的创建列表，在开发中经常使用。
代码示例：
>>> [x for x in range(5)]
[0, 1, 2, 3, 4]
>>> [x for x in range(10) if x%2==0]
[0, 2, 4, 6, 8]
列表元素的增加
当列表增加和删除元素时，列表会自动进行内存管理，大大减少了程序员的负担。但这个特点涉及列表元素的大量移动，效率较低。除非必要，我们一般只在列表的尾部添加元素或删除元素，这会大大提高列表的操作效率。
append()方法
原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用。
代码示例：
>>> a = [10, 20, 30]
>>> a.append(50)
>>> a
[10, 20, 30, 50]
+运算符操作
并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中。这样，会涉及大量的复制操作，对于操作大量元素不建议使用。
代码示例：
>>> a = [10, 20]
>>> id(a)
2734942897792
>>> a = a+[50]
>>> a
[10, 20, 50]
>>> id(a)
2734942895872
+=运算符操作
在原列表尾部增加元素，不会新建对象，运行时间介于append方法和+运算符方法之间。
代码示例：
>>> a = [10, 20]
>>> id(a)
2734942897792
>>> a += [30,]
>>> a
[10, 20, 30]
>>> id(a)
2734942897792
extend()方法
将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。
注虽然不产生新的对象，但extend()花费时间较长，不推荐
代码示例：
>>> a = [20,40]
>>> id(a)
1878090231232
>>> a.extend([50])
>>> id(a)
1878090231232
四种尾部加元素方法消耗时间比较的代码示例：
import time
time01 = time.time()
a = []
for i in range(100000):
a.append(i)
time02 = time.time()
print("append方法消耗时间：{}".format((time02-time01)))
time03 = time.time()
a = []
for i in range(100000):
a += [i]
time04 = time.time()
print("+=方法消耗时间：{}".format((time04-time03)))
time05 = time.time()
a = []
for i in range(100000):
a = a + [i]
time06 = time.time()
print("+方法消耗时间：{}".format((time06-time05)))
time07 = time.time()
a = []
for i in range(100000):
a.extend([i])
time08 = time.time()
print("extend方法消耗时间：{}".format((time06-time05)))
运行结果
append方法消耗时间：0.015956878662109375
+=方法消耗时间：0.019945859909057617
+方法消耗时间：32.136921405792236
extend方法消耗时间：32.136921405792236
insert()插入元素
使用 insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。
类似发生这种 移动的函数还有：remove()、pop()、del()，它们在删除非尾部元素时也会发生操作位置后 面元素的移动。
代码示例：
>>> a = [1,2,3,4,5,6]
>>> a.insert(2,30)
>>> a
[1, 2, 30, 3, 4, 5, 6]
乘法扩展
使用乘法扩展列表，生成一个新列表，新列表元素时原列表元素的多次重复。
>>> a = [1,2,3,4,5,6]
>>> b = a*3
>>> b
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
列表元素的删除
del 删除
删除列表指定位置的元素。
代码示例：
>>> a = [1,2,3,4,5,6]
>>> del a[1]
>>> a
[1, 3, 4, 5, 6]
pop()方法删除
pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素。
代码示例：
>>> a = [1,2,3,4,5,6]
>>> a.pop()
6
>>> a
[1, 2, 3, 4, 5]
>>> a.pop(1)
2
>>> a
[1, 3, 4, 5]
remove()方法删除
删除首次出现的指定元素，若不存在该元素抛出异常。
代码示例:
>>> a = [1,2,3,4,5,6,5,4,3,2,1]
>>> a.remove(2)
>>> a
[1, 3, 4, 5, 6, 5, 4, 3, 2, 1]
>>> a.remove(20)
Traceback (most recent call last):
File "<pyshell#22>", line 1, in <module>
a.remove(20)
ValueError: list.remove(x): x not in list
列表元素访问和计数
通过索引直接访问元素
我们可以通过索引直接访问元素。索引的区间在[0, 列表长度-1]这个范围。超过这个范围则会抛出异常。
代码示例：
>>> a = [1,2,3,4,5,6,7,8,9,0]
>>> a[2]
3
>>> a[9]
0
>>> a[10]
Traceback (most recent call last):
File "<pyshell#26>", line 1, in <module>
a[10]
IndexError: list index out of range
index()索引
index()可以获取指定元素首次出现的索引位置。语法是：
value-- 查找的对象。
start-- 可选，查找的起始位置。
end-- 可选，查找的结束位置。
代码示例：
>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.index(20)
1
>>> a.index(20,3)
5
>>> a.index(20,6,9)
7
count()方法计数
count()可以返回指定元素在列表中出现的次数。
代码示例：
>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.count(20)
3
len()返回列表长度
代码示例：
>>> a = [10,20,30,40,50,20,30,20,30]
>>> len(a)
9
列表成员判断
判断列表中是否存在指定的元素，我们可以使用 count()方法，返回 0 则表示不存在，返回大于 0 则表示存在。但是，一般我们会使用更加简洁的 in或not in 关键字来判断，直接返回 True 或 False。
代码示例：
>>> a = [10,20,30,40,50,20,30,20,30]
>>> 20 in a
True
>>> 50 not in a
False
列表切片操作
切片是 Python 序列及其重要的操作，适用于列表、元组、字符串等等。切片的格式如下：
切片 slice 操作可以让我们快速提取子列表或修改。标准格式为：
代码示例：
>>> a = [10,20,30,40,50,20,30,20,30]
>>> a[1:6:2]
[20, 40, 20]
列表的遍历
通常通过for循环遍历列表。
代码示例：
>>> a = [1,2,3,4,5,
>>> for i in a:
print(i)
1
2
3
4
5
复制列表
如下代码实现列表元素的复制了吗？
>>> list1 = [30,40,50]
>>> list2 = list1
列表对象本身并没有复制，只是将 list2 也指向了列表对象，也就是说 list1 和 list2 持有地址值是相同的。
我们可以通过如下简单方式，实现列表元素内容的复制：
>>> list1 = [30,40,50]
>>> list2 = [] + list1
>>> id(list1)
2054043319040
>>> id(list2)
2054037204736
列表排序
修改原列表，不建新列表的排序
代码示例：
>>> a = [3,2,1,8,2]
>>> id(a)
2054043715840
>>> a.sort()
>>> a
[1, 2, 2, 3, 8]
>>> id(a)
2054043715840
>>> a.sort(reverse=True)
>>> a
[8, 3, 2, 2, 1]
>>> import random
>>> random.shuffle(a)
>>> a
[2, 3, 8, 2, 1]
>>> id(a)
2054043715840
建新列表的排序
我们也可以通过内置函数 sorted()进行排序，这个方法返回新列表，不对原列表做修改。
代码示例：
>>> a = [3,2,1,8,2]
>>> id(a)
2054043376768
>>> a = sorted(a)
>>> a
[1, 2, 2, 3, 8]
>>> id(a)
2054043715136
>>> a = [3,2,1,8,2]
>>> b = sorted(a)
>>> a
[3, 2, 1, 8, 2]
>>> b
[1, 2, 2, 3, 8]
reversed()返回迭代器
内置函数 reversed()也支持进行逆序排列，与列表对象 reverse()方法不同的是，内置函数reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。
>>> a = [3,2,1,8,2]
>>> c = reversed(a)
>>> c
<list_reverseiterator object at 0x000001DE3E877940>
>>> list(c)
[2, 8, 1, 2, 3]
>>> list(c)
[]
打印输出 c 发现提示是：list_reverseiterator。也就是一个迭代对象。同时，我们使用 list© 进行输出，发现只能使用一次。第一次输出了元素，第二次为空。那是因为迭代对象在第一次时已经遍历结束了，第二次不能再使用。
列表相关的其他内置函数汇总
max() 和 min()
用于返回列表中最大和最小值。
代码示例：
>>> a = [3,2,1,8,2]
>>> max(a)
8
>>> min(a)
1
sum()
对数值型列表的所有元素进行求和操作，对非数值型列表运算则会报错。
代码示例：
>>> a = [3,2,1,8,2]
>>> sum(a)
16
多维列表
一维列表可以帮助我们存储一维、线性的数据。
二维列表可以帮助我们存储二维、表格的数据。
例如下表的数据：
| 姓名 | 年龄 | 薪资 | 城市 |
|---|---|---|---|
| Russell1 | 18 | 15000 | 西安 |
| Russell2 | 19 | 20000 | 北京 |
| Russell3 | 21 | 21000 | 杭州 |
代码示例：
>>> cha = [["姓名","年龄","薪资","城市"],
["Russell1",18,15000,"西安"],
["Russell2",19,20000,"北京"],
["Russell3",20,21000,"杭州"]]
>>> cha
[['姓名', '年龄', '薪资', '城市'], ['Russell1', 18, 15000, '西安'], ['Russell2', 19, 20000, '北京'], ['Russell3', 20, 21000, '杭州']]
循环遍历：
>>> for i in range(4):
for j in range(4):
print(cha[i][j], end="\t")
print()
姓名 年龄 薪资 城市
Russell1 18 15000 西安
Russell2 19 20000 北京
Russell3 20 21000 杭州