文章为自己的学习笔记，如有不正确的地方，还请提出指正，欢迎一起交流，学习，进步~~

列表

Python中是可以识别复合数据类型的，在Python中有列表、元组、集合、字典这四种可以存放多个数据元素的数据类型，它们都起着存放数据的作用，但每种类型又都有着各自的特点。其中最通用的是列表，它用方括号[]来包含数据，用逗号,来分隔数据（列表中的项），列表可能包含不同类型的项，但通常这些项都具有相同的类型。本文主要对列表进行介绍。

1.创建列表

列表的创建是简单的，使用方括号与逗号即可：

 >>> list1 = [1, 2, 3, 4, "Hello"]
 >>> list1
 [1, 2, 3, 4, 'Hello']

2.列表的索引与切片

与字符串（其它内建序列类型）一样，列表也是可以被索引和切片的，切片的语法规则是这样的：

list[start: end: step]

其中start是起始索引数，end是末尾索引数，step是步距，并且是左变闭区间右变开区间。

下面是索引方法以及常用的切片方法：

 >>> list1 = [1, 2, 3, 4, "Hello"]
 >>> list1[1]    #列表索引
 2
 >>> list1[:2]   #冒号左边没写，默认从第一个元素开始，即下标为0的元素
 [1, 2]          #等价于list1[0:2],即第一个元素和第二个元素
 >>> list1[3:]   #冒号右边没写，默认到最后一个元素结束
 [4, 'Hello']    #list[3]=4; list[4]='Hello'
 >>> list1[:]    #只有一个冒号，即将整个列表输出
 [1, 2, 3, 4, 'Hello']
 >>> list1[::-1] #同样输出整个列表，但由于步距是-1，所以是将列表倒序输出
 ['Hello', 4, 3, 2, 1]

3.列表的操作

与字符串不同，列表是可以被更改的，列表的内容可以按照需求更改，下面是通过一张表格总结了对列表进行相应操作的方法：

3.1列表的添加

 >>> heros = ["Spider Man", "Iron Man"]
 >>> heros.append("黑寡妇")                 #添加单个对象
 >>> heros
 ['Spider', 'Iron Man', '黑寡妇'] 
 
 >>> heros.extend(["绿巨人", "雷神", "flash"])    #添加多个对象
 >>> heros
 ['Spider', 'Iron Man', '黑寡妇', '绿巨人', '雷神', 'flash']
 ?
 #通过切片的方式添加
 >>> a = [1,2,3]                 
 >>> a[len(a):] = [4]
 >>> a
 [1, 2, 3, 4]
 >>> a[len(a):] = [6, 7, 8]
 >>> a
 [1, 2, 3, 4, 6, 7, 8]
 ?
 #通过insert()函数添加
 >>> b = [1, 3, 4, 5]
 >>> b.insert(1, 2)          #在下标为1的位置（列表中第二个元素3）之前添加2
 >>> b
 [1, 2, 3, 4, 5]
 >>> b.insert(len(b), 6)     #len()函数返回的是列表的元素个数，即返回5，列表中第六个元素前添加6，通常用于在列表末尾添加元素
 >>> b
 [1, 2, 3, 4, 5, 6]

3.2列表的删除

 >>> c = [1, 3, 2, 2, 4, 5, 6]
 >>> c.remove(2)         #删除列表中第一个元素2
 >>> c
 [1, 3, 2, 4, 5, 6]
 >>> c.pop(3)            #删除列表中索引为3的元素，即第四个元素4
 4                       #pop()函数会将值进行返回
 >>> c
 [1, 3, 2, 5, 6]
 >>> del c[0]            #删除列表中索引为0的元素，即第一个元素1，del不会像pop一样返回值
 >>> c
 [3, 2, 5, 6]
 #del同样可以用切片的操作
 >>> del c[:]            #清空列表   
 >>> c
 []
 >>> d = [1, 2, 3]       
 >>> d.clear()           #使用clear()函数清空列表
 >>> d
 []

3.3列表的修改

 >>> e = [1, 3, 2, 2, 4, 5, 6]
 >>> e[4] = 8            #通过索引对列表进行修改
 >>> e
 [1, 3, 2, 2, 8, 5, 6]
 ?
 >>> e[3:] = [9, 8, 7, 6]    #通过切片对多个元素就行替换
 >>> e
 [1, 3, 2, 9, 8, 7, 6]

3.4列表的查询与计数

 #列表的查询
 >>> f = [2, 4, 5, 3, 2, 8, 9, 6]
 >>> f.index(2)          #在列表中查询第一次出现2的地方
 0
 >>> f.index(2, 3, 8)    #在列表中的(3,8)范围内查询第一次出现2的地方
 4
 >>> f.index(8)
 5
 ?
 #列表的计数
 >>> f.count(2)
 2
 >>> f.count(8)
 1
 >>> f.count(100)        #100不在列表中，所以返回0
 0

3.5列表的排序

可以对数字，字符串等类型的列表进行排序，但是必须保证列表中元素的类型是一致的。

 #正序
 >>> g = [2, 45, 4, 8, 6, 17, 20]
 >>> g.sort()
 >>> g
 [2, 4, 6, 8, 17, 20, 45]
 >>> str1 = ["Ivring", "Michael", "James"]
 >>> str1.sort()
 >>> str1
 ['Ivring', 'James', 'Michael']
 ?
 #逆序
 >>> g.reverse()
 >>> g
 [45, 20, 17, 8, 6, 4, 2]
 >>> str1.reverse()
 >>> str1
 ['Michael', 'James', 'Ivring']

3.6列表的拷贝

 #使用copy()函数进行拷贝
 >>> h = [6, 2, 9, 5]
 >>> h_copy1 = h.copy()      
 >>> h_copy1
 [6, 2, 9, 5]
 ?
 #利用切片进行拷贝
 >>> h_copy2 = h[:]
 >>> h_copy2
 [6, 2, 9, 5]

备注：上面两种拷贝方式都属于浅拷贝，与之对应的就还有深拷贝，这些之后会单独讨论。

4.列表的嵌套

4.1列表的加法与乘法

与字符串一样，列表也是可以进行加法和乘法的

#列表的加法，就是想两个列表拼接起来，加号两边要求都是列表
>>> x = [1, 3, 5]
>>> y = [2, 4 ,6]
>>> x + y
[1, 3, 5, 2, 4, 6]

#列表乘法就是重复列表内的元素相应的次数
>>> x * 3
[1, 3, 5, 1, 3, 5, 1, 3, 5]

4.2嵌套列表

嵌套列表就是在一个列表中嵌入一个新的列表

#二维列表的创建
>>> matrix = [[1,2,3],[4,5,6],[7,8,9]]
>>> matrix = [[1,2,3],
               
>>> matrix
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

#访问嵌套列表
>>> for i in matrix:			#利用for循环对列表进行遍历，然后将其一个一个打印出来
              for each in i:
                  print(each, end = "  ")
              print()
	
1  2  3  
4  5  6  
7  8  9  

#通过下标访问嵌套列表
>>> matrix[1]			#只有一个下标代表访问的是列表的某一行元素
[4, 5, 6]
>>> matrix[1][1]		#两个下标则说明访问的是列表的某一个元素
5

我们还可以通过循环初始化的方式来创建二维列表

>>> for i in range(3):
	              aa[i] = [0] * 3
	
>>> aa
[[0, 0, 0], [0, 0, 0], [0, 0, 0]] 

当然有些朋友可能会用下面这种方式进行二维列表的初始化：

>>> bb = [[0] * 3] * 3
>>> bb
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

注意：咋一看这种方法好像更加简单了，不过这种方法实际上是错误的，并且错的非常的隐蔽。我们可以通过做一些测试来验证：

#修改aa的第二行第二列的值
>>> aa[1][1] = 1
>>> aa
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]

#修改bb的第二行第二列的值
>>> bb[1][1] = 1
>>> bb
[[0, 1, 0], [0, 1, 0], [0, 1, 0]]

我们想要的仅仅是修改第二行第二列的值，但是bb列表的每一行的第二个元素却都被修改了，这是为什么呢？

在解释之前我们还需要再做一些测试，同时会使用到is运算符，即同一性运算符，它是用于检验两个变量，是否指向同一个对象的运算符。

#is运算符举例
>>> x = "Hello"
>>> y = "Hello"
>>> x is y
True
>>> x = [1, 2, 3]
>>> y = [1, 2, 3]
>>> x is y
False

Python对于不同的对象存储机制是不一样的，对于字符串来说，由于它的不可更改性，所以Python只需要在内存中开辟一个位置来存放即可，但是列表与字符串不同，列表是可变的，由于Python无法预测用户什么时候对列表进行操作，增删改等等，所以需要准备两个不同的位置来分别将其存放。

在了解这个后，我们回到前面的问题，为什么bb列表的每一行的第二个元素却都被修改了？

#检测aa的每一行
>>> aa[0] is aa[1]
False
>>> aa[0] is aa[2]
False
>>> aa[1] is aa[2]
False
#检测bb的每一行
>>> bb[0] is bb[1]
True
>>> bb[0] is bb[2]
True
>>> bb[1] is bb[2]
True

于是乎，我们就知道了，对于aa它的每一行指向的都是不同的位置，而对于bb而言它的每一行指向的都是相同的位置。结论：对于bb列表来说，它对[0] * 3列表后在乘以3只是对该列表的引用，而非物理上的拷贝，相当于让多个标签都指向了那个列表。

那么知道了这个后，如果我们要创建多维列表可以采用下面这种方法：

>>> cc = [0] * 3
>>> for i in range(3):
							cc[i] = [0] * 3
	
>>> cc
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

5.列表推导式（List Comprehensions）

5.1基础操作

先看一个例子，我想要将一个列表内的所有元素都扩大三倍，采用for循环的方法:

>>> aaa = [1, 2, 3, 4, 5]
>>> for i in range(len(aaa)):
   						 aaa[i] = aaa[i] * 3

>>> aaa
[3, 6, 9, 12, 15]

采用列表推导式的方法:

>>> aaa = [1, 2, 3, 4, 5]
>>> aaa = [i * 3 for i in aaa]
>>> aaa
[3, 6, 9, 12, 15]

如此一来，程序的代码量看上去就小了很多了，更重要的是，这样的程序执行起来效率会更高。

下面对程序进行解释，首先是列表推导式的语法规则：

语法规则 [expression for target in interable]

列表推导式会先执行for循环的迭代，然后再计算表达式(expression)，最后将值存放到列表中，通过下面这个程序也可以看得出来：

x = [i for i in range(10)]
x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = [i + 1 for i in range(10)]
x
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 

如此一来，对于二维列表的创建，这里又多了一种方法：

#嵌套列表--列表推导式
>>> x = [[0] * 3 for i in range(3)]
>>> x
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> x[1][1] = 1
>>> x
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]

可以看出，通过这种方式创建的二维列表，也是符合我们要求的。

当然，我们也可以对二维列表进行一些操作：

>>> matrix = [[1,2,3],
             						[4,5,6],
             				    [7,8,9]]
>>> col = [row for row in matrix]		#row仅代表获取的仅是二维列表的行。
>>> col
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> col = [row[1] for row in matrix]	#row[1]则代表获取的是二维列表中每一行的第二个元素
>>> col
[2, 5, 8]

总体分析：首先通过for循环获取矩阵的每一行的元素，然后存放到列表里面的每一行的row[1]，即每一行的第二个元素，于是结果就是第二列的元素。为了便于理解下面还有两个例子：

#主对角线
>>> diag = [matrix[i][i] for i in range(len(matrix))]
>>> diag
[1, 5, 9]

#副对角线
>>> diag2 = [matrix[i][len(matrix) - 1 - i] for i in range(len(matrix))]
>>> diag2
[3, 5, 7]

5.2列表推导式的if条件

语法规则：

[expression for target in iterable if condition]

示例代码，求0-9之间的偶数：

>>> even1 = [i for i in range(10) if i % 2 == 0]
>>> even1
[0, 2, 4, 6, 8]

程序具体执行的顺序是：先执行for，后执行if 最后执行expression，测试代码：

>>> even2 = [i + 1 for i in range(10) if i % 2 == 0]
>>> even2
[1, 3, 5, 7, 9]

可以发现even2最后的值是在even1的结果上每一项都加了1，说明i+1是最后才执行的。

用于理解的补充程序：

>>> words = ["Great", "Fine", "Brilliant", "Excellent", "Fantistic"]
>>> f = [i for i in words if i[0] == "F"]
>>> f
['Fine', 'Fantistic']

5.3列表推导式的嵌套

语法规则1：

[expression for target1 in iterable1 for target2 in iterable2 for target3 in iterable3 ...... for targetN in iterableN]

示例代码：

#嵌套的列表推导式方法
>>> matrix = [[1,2,3],
             						[4,5,6],
	                      [7,8,9]]
>>> line1 = [col for row in matrix for col in row]
>>> line1
[1, 2, 3, 4, 5, 6, 7, 8, 9]

#嵌套循环的方法
>>> for row in matrix:
        			for col in row:
           					 line2.append(col)

>>> line2
[1, 2, 3, 4, 5, 6, 7, 8, 9]

语法规则2：

[expression for target1 in iterable1 if condition1 for target2 in iterable2 if condition2 for target3 in iterable3 if condition3 ...... for targetN in iterableN if conditionN]

示例代码：

#输出同时满足能被2整除的x，和能被3整除的y的二维列表
#列表推导式
xy = [[x, y] for x in range(10) if x % 2 == 0 for y in range(10) if y % 3 == 0]
>>> xy
[[0, 0], [0, 3], [0, 6], [0, 9], [2, 0], [2, 3], [2, 6], [2, 9], [4, 0], [4, 3], [4, 6], [4, 9], [6, 0], [6, 3], [6, 6], [6, 9], [8, 0], [8, 3], [8, 6], [8, 9]]

#循环的方式
>>> for x in range(10):
                

>>> xy
[[0, 0], [0, 3], [0, 6], [0, 9], [2, 0], [2, 3], [2, 6], [2, 9], [4, 0], [4, 3], [4, 6], [4, 9], [6, 0], [6, 3], [6, 6], [6, 9], [8, 0], [8, 3], [8, 6], [8, 9]]

备注：虽然列表推导式代码简洁，执行效率高，但如果在多层嵌套是，产生了阅读上的障碍，那么对于它的使用就得多加斟酌了。