Python中的列表

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]