1.创建列表
使用中括号把要添加的元素括起来，不同元素用逗号隔开。
>>> rhyme = [1, 2, 3, 4, 5, "上山打老虎"]
>>> print(rhyme)
[1, 2, 3, 4, 5, '上山打老虎']
2.访问列表中的元素
（1）希望顺序访问列表中的元素：使用for语句
>>> for each in rhyme:
... print(each)
...
1
2
3
4
5
上山打老虎
（2）希望访问特定元素：使用下标的方法
>>> rhyme[0]
1
>>> rhyme[2]
3
>>> rhyme[5]
'上山打老虎'
3.Python中的下标索引
和C语言类似，从前往后是从0开始一直到最后
特殊的是，从后往前，是从-1开始索引的
4.列表切片
rhyme[1,2,3,4,5,6]
切片方式——rhyme[a : b : c]
切片参数的描述：
（1）首先参数都必须是整数；
（2）其次，a表示从下标为a的元素开始（包含下标为a的元素），b表示到下标为b的元素结束（不包含下标为b的元素），c表示下标跳转的增加的量。
（3）注意：abc三个参数不一定都需要存在；thyme[:]表示寻找整个列表的元素；thyme[::2]表示从下标为0的元素开始，每次跳转2个位移的增加量。
>>> rhyme[0:3]
[1, 2, 3]
>>> rhyme[3:6]
[4, 5, '上山打老虎']
>>> rhyme[:3]
[1, 2, 3]
>>> rhyme[3:]
[4, 5, '上山打老虎']
>>> rhyme[:]
[1, 2, 3, 4, 5, '上山打老虎']
>>> rhyme[0:6:2]
[1, 3, 5]
>>> rhyme[::2]
[1, 3, 5]
>>> rhyme[::-2]
['上山打老虎', 4, 2]
>>> rhyme[::-1]
['上山打老虎', 5, 4, 3, 2, 1]
5.列表的增
（1）对列表末尾追加一个元素，使用append（）的方法
>>> heros.append("黑寡妇")
>>> heros
['钢铁侠', '绿巨人', '黑寡妇']
（2）对列表末尾一次性追加多个元素，使用extend（）的方法
>>> heros.extend(["鹰眼", "灭霸", "雷神"])
>>> heros
['钢铁侠', '绿巨人', '灭霸', '黑寡妇', '鹰眼', '灭霸', '雷神']
其中extend（）的参数必须是可迭代对象——所以必须是一个列表
（3）使用列表切片的方法也可对列表进行元素的增添
>>> s = [1, 2, 3, 4, 5]
>>> # 下面的做法等同于 s.append(6)
>>> s[len(s):] = [6]
>>> s
[1, 2, 3, 4, 5, 6]
>>> # 下面的做法等同于 s.extend([7, 8, 9])
>>> s[len(s):] = [7, 8, 9]
>>> s
[1, 2, 3, 4, 5, 6, 7, 8, 9]
（4）对任意位置的元素进行增添——使用insert（）的方法
insert（a，b）有两个参数，a表示要插入元素的位置，b表示要添加的元素
>>> s = [1, 3, 4, 5]
>>> s.insert(1, 2)
>>> s
[1, 2, 3, 4, 5]
6.列表的删
（1）删除特定元素，使用remove（）的方法
>>> heros.remove("灭霸")
>>> heros
['钢铁侠', '绿巨人', '黑寡妇', '鹰眼', '灭霸', '雷神']
需要注意两点：
- 如果列表中存在多个要删除的元素，只会删除靠前的第一个元素；
- 如果要删除的元素不存在，则程序会报错。
（2）删除特定下标位置的元素，使用pop（）的方法
pop（）参数就是下标的数
>>> heros.pop(2)
'黑寡妇'
>>> heros
['钢铁侠', '绿巨人', '鹰眼', '灭霸', '雷神']
pop()的参数是可选的，如果没有选择，就会弹出并删除最后一个元素；
>>> heros.pop()
'雷神'
>>> heros
['钢铁侠', '绿巨人', '鹰眼', '灭霸']
（3）清空整个列表，使用clear（）
>>> heros.clear()
>>> heros
[]
7.列表的改
列表和字符串最大的区别是，列表是可改的，而字符串是不可改的
替换列表中元素和访问列表中的元素类似，找到要替换的元素后，通过赋值运算来修改
（1）修改特定元素
>>> heros = ['蜘蛛侠', '绿巨人', '黑寡妇', '鹰眼', '灭霸', '雷神']
>>> heros[4] = "钢铁侠"
>>> heros
['蜘蛛侠', '绿巨人', '黑寡妇', '鹰眼', '钢铁侠', '雷神']
（2）连续修改多个元素，使用切片来实现
>>> heros[3:] = ["武松", "林冲", "李逵"]
>>> heros
['蜘蛛侠', '绿巨人', '黑寡妇', '武松', '林冲', '李逵']
8.列表的排序和翻转
排序使用到sort（），翻转使用到reverse（）
>>> nums = [3, 1, 9, 6, 8, 3, 5, 3]
>>> nums.sort()
>>> nums
[1, 3, 3, 3, 5, 6, 8, 9]
>>> nums.reverse()
>>> nums
[9, 8, 6, 5, 3, 3, 3, 1]
>>> nums = [3, 1, 9, 6, 8, 3, 5, 3]
>>> nums.sort(reverse=True)
>>> nums
[9, 8, 6, 5, 3, 3, 3, 1]
9.列表中的查
（1）如果希望的到列表中的特定的元素存在几个，使用count（）
>>> nums.count(3)
3
表示nums列表中有3个元素为3的数
（2）找特定元素的下标，使用index（）
>>> heros.index("绿巨人")
4
注意，返回的是找到第一个元素的下标 ；
index有两个可选的参数，start和end，表示寻找元素下标的范围
>>> nums.index(3, 1, 7)
5
（3）拷贝列表
copy（）
>>> nums_copy1 = nums.copy()
>>> nums_copy1
[3, 1, 9, 6, 8, 3, 5, 3]
切片
>>> nums_copy2 = nums[:]
>>> nums_copy2
[3, 1, 9, 6, 8, 3, 5, 3]
这两种切片的方法被Python称为浅拷贝；
10.列表的加法和乘法
（1）列表的加法也是拼接，两个列表相加之后还是列表
>>> s = [1, 2, 3]
>>> t = [4, 5, 6]
>>> s + t
[1, 2, 3, 4, 5, 6]
（2）列表的乘法就是重复几次
>>> s * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
11.列表的嵌套
写法1：
>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
写法2：
>>> matrix = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
表示的是二位列表
12.访问嵌套列表
（1）for循环进行访问
>>> for i in matrix:
... for each in i:
... print(each)
...
1
2
3
4
5
6
7
8
9
（2）下标进行访问
>>> matrix[0]
[1, 2, 3]
>>> matrix[1]
[4, 5, 6]
>>> matrix[2]
[7, 8, 9]
>>> matrix[0][0]
1
>>> matrix[1][1]
5
>>> matrix[2][2]
9
13.使用for循环来创建和初始化二位列表
>>> A = [0] * 3
>>> for i in range(3):
... A[i] = [0] * 3
...
>>> A
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
高级错误：
A=[[0]*3]*3
14.变量不是盒子
在一些编程语言中，经常会有 “变量就是盒子” 这样的比喻，因为赋值操作就像是往盒子里面放东西。
但在 Python 中变量并不是一个盒子，当赋值运算发生的时候，Python 并不是将数据放进变量里面，而是将变量与数据进行挂钩，这个行为我们称之为引用。
15.浅拷贝和深拷贝
浅拷贝：利用列表的 copy() 方法或者切片来实现
深拷贝：利用copy模块的deepcopy（）函数来实现
浅拷贝可以用于处理一维列表，对于嵌套列表的拷贝，只能拷贝第一层数据，其余仅拷贝其引用：
>>> x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> y = x.copy()
>>> x[1][1] = 0
>>> x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
>>> y
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
浅拷贝的逻辑图如下：
深拷贝可以处理多维的列表：
>>> x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> y = copy.deepcopy(x)
>>> x[1][1] = 0
>>> x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
>>> y
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
深拷贝的逻辑图如下：
16.列表的推导式
列表推导式的优势：使代码变得简洁；程序运行速率高效。
>>> oho = [1, 2, 3, 4, 5]
>>> for i in range(len(oho)):
... oho[i] = oho[i] * 2
使用列表推导的可写成下面的形式
>>> oho = [1, 2, 3, 4, 5]
>>> oho = [i * 2 for i in oho]
17.列表推导的基本语法
[expression for target in iterable]
18.处理矩阵
利用列表推导式处理矩阵也是非常方便，比如下面代码是将矩阵第 2 列的元素给提取出来：
>>> matrix = [[1, 2, 3],
... [4, 5, 6],
... [7, 8, 9]]
>>> col2 = [row[1] for row in matrix]
>>> col2
[2, 5, 8]
又比如，下面代码是获取矩阵主对角线上的元素（就是从左上角到右下角这条对角线上的元素）：
>>> diag = [matrix[i][i] for i in range(len(matrix))]
>>> diag
[1, 5, 9]
19.创建二维列表的错误方式
不能这样创建二维列表
>>> B = [[0] * 3] * 3
>>> B
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
因为如果你试图修改其中的一个元素，就会发现有多个元素同时被修改了：
>>> B[1][1] = 1
>>> B
[[0, 1, 0], [0, 1, 0], [0, 1, 0]]
这是因为内部嵌套的列表不是三个独立的列表，而是同一个列表的三次引用而已。
正确的做法是：
>>> A = [0] * 3
>>> for i in range(3):
... A[i] = [0] * 3
...
>>> A
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> A[1][1] = 1
>>> A
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]
更好的方法：利用列表推导式来创建
>>> S = [[0] * 3 for i in range(3)]
>>> S
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> S[1][1] = 1
>>> S
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]
20.具有条件的列表推导式
列表推导式其实还可以添加一个用于筛选的 if 分句，完整语法如下：
[expression for target in iterable if condition1]
多层嵌套：
[expression for target1 in iterable1
for target2 in iterable2
…
for targetN in iterableN]
可附加条件：
[expression for target1 in iterable1 if condition1
for target2 in iterable2 if condition2
…
for targetN in iterableN if conditionN]
