我们前面已经复习过了基本对象，但是对于一些对象组合成的一些基本知识还没有复习过，学习是一个循序渐进的过程，我们就要慢慢理解其中的奥妙

在此之前我们先来了解一下其分类

列表

包含若干元素的有序连续内存空间。当列表增加或删除元素时，列表对象自动进行内存的扩展或收缩，从而保证相邻元素之间没有缝隙
使用整数作为下标来访问其中的元素
列表对象常用方法

在看完这个表，我们就能知道一些的基本用法，而一些例子啥的我们都可以在网上找到，这里就不细说了，毕竟列表的内容太多

列表对象支持的运算符

• 加法运算符
  实现列表增加元素的目的
  e.g.

x = [1,2,3]
x += [4] #连接两个列表
#输出[1,2,3,4]
id[x] #输出内存地址

• 乘法运算符
  列表和整数相乘，表示序列重复，返回新列表
  e.g.

x = [1,2,3,4]
x = x*2 #元素重复，返回新列表
#输出[1,2,3,4,1,2,3,4]

[1,2,3]*0
#输出[],重复0次，清空

• 成员测试运算符in
  测试列表中是否包含某个元素，查询时间随着列表长度的增加而线性增加
  e.g.

3 in [1,2,3]
#输出True 

3 in [1,2,'3']
#输出False

内置函数对列表的操作

我们举一些例子就能更好的说明一下了

x = list(range(11)) #生成列表
import random
random.shuffle(x) #打乱列表中的顺序
#输出x为[0,6,10,9,8,7,4,5,2,1,3]

all(x)
#测试所有元素是否都等价于True，输出False
any(x)
#测试是否存在等价于True的元素，输出True
max(x)
#输出10，最大值
max(x,key=str)
#指定的规则返回最大值，9
min(x)
#输出0
sum(x)
#所有元素之和，输出55
len(x)
#列表元素个数，11
list(zip(x,[1]*11))
#多列表元素重新组合
#输出为[(0,1),(6,1),(10,1),,,(x,1),,,(3,1)]

list(zip(range(1,4)))
#用于一个序列或迭代对象
#输出[(1,),(2,),(3,)]
list(zip(['a','b','c'],[1,2]))
#如果两个列表不等长，以短的为主
#[('a',1),('b',2)]

使用列表模拟向量

from random import randint
x = [randint(1,100) for i in range(10)]
#生成10个[1,100]区间内的随机数
list(map(lambda i: i+5,x)) #所有元素同时加5

#列表推导式实现同样的功能
[i+5 for i in x]

列表推导式语法及应用案例

列表推导式，即列表解析式，可以使用非常简洁的方式对列表或其它迭代对象的元素进行遍历，过滤或再次计算，快速生成满足特定需求的新列表
.e.g.

aList = []
for x in range(10):
	aList.append(x*x)

或者可以这样

aList = [x*x for x in range(10)]

aList = list(map(lambda x: x*x, range(10)))

aList = list(map(lambda x: pow(x,2),range(10)))

再如果我们期望实现嵌套列表的平铺
e.g.

vec = [[1,2,3], [4,5,6], [7,8,9]]
[num for elem in vec for num in elem]
#输出[1,2,3,4,5,6,7,8,9]

或者可以等价于

vec = [[1,2,3], [4,5,6], [7,8,9]]
result = []
for elem in vec:
	for num in elem:
		result.append(num)
#可输出为[1,2,3,4,5,6,7,8,9]

又或者
调用标准库中的itertools中的chain()函数，可将子列表串成一个列表

vec= [[1,2,3], [4,5,6], [7,8,9]]
from itertools import chain
list(chain(*vec))
#输出为[1,2,3,4,5,6,7,8,9]

过滤不符合条件的元素
e.g.

aList = [-1,-4,6,7,5,-2.3,9,-11]
[i for i in aList if i>0]
#所有大于0的数字
#输出为[6,7.5,9]

from random import randint
x = [randint(1,10) for i in range(20)]
输出为[10,2,3,4,10,9,2....5,6]

[index for index, value in enumerate(x) if value==m]
#输出最大整数的所有出现位置

同时遍历多个列表或可迭代对象
e.g.

[(x,y) for x in [1,2,3] for y in [3,1,4] if x != y]
#输出为[(1,3),(1,4),(2,3),(2,1),(2,4),(3,1),(3,4)]

[(x,y) for x in [1,2,3] if x ==1 for y in [3,1,4] if y != x]
#输出为[(1,3), (1,4)]

也可等价如下

result = []
for x in [1,2,3]:
	for y in [3,1,4]:
		if x != y:
			result.append((x,y))

列表推导式实现矩阵转置

matrix = [[1,2,3,4], [5,6,7,8],[9,10,11,12]]
[[row[i] for row in matrix] for i in range(4)]
#可输出为[[1,5,9],[2,6,10],[3,7,11],[4,8,12]]

等价为

matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
result = []
for i in range(len(matrix[0])):
	result.append([row[i] for row in matrix])
#输出同样结果

list(map(list, zip(*matrix)))

matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
result = []
for i in range(len(matrix[0])):
	temp = []
	for row in matrix:
		temp.append(row[i])
	result.append(temp)

切片的强大功能

截取列表中的任意部分得到一个新列表，也可修改和删除列表中的部分元素，或作为列表对象增加元素
形式为
[start: end: step]
其中start默认为0，end表示切片截止的位置，step表步长，默认为1，而若step为负整数时，表反向切片，start应该在end右侧
e.g.
利用切片获取列表部分元素

aList = [3,4,5,6,7,9,11,13,15,17]
aList = [::] #返回包含原列表中的所有元素的新列表

aList[::-1] #返回包含原列表中的所有元素的逆序列表

aList[::2] #隔一个取一个，获取偶数元素位置的元素

aList[1::2] #隔一个取一个，获取奇数元素位置的元素

aList[3:6] #指定开始和结束位置

aList[100] #异常，不允许越界访问

aList[100:] #切片开始位置大于列表长度，返回空列表

aList[-15:3] #做必要截断处理，输出[3,4,5]

aList[3: -10: -1] #输出[6,5,4]

使用切片为列表增加元素
可再任意位置插入新元素，不影响列表对象的内存地址，属于原地操作

aList = [3,5,7]
aList[len(aList):]
#输出[]
aList[len(aList):] = [9]
#在列表尾部增加元素
aList[:0] = [1,2] #在列表头部插入多个元素
aList[3:3] = [4] #在列表中间位置插入元素
aList输出
#[1,2,3,4,5,7,9]

使用切片替换和修改列表中的元素

aList = [3,5,7,9]
aList[:3] = [1,2,3] #替换列表中的元素，等号两边的列表长度一致
#输出为[1,2,3,9]

aList[3:] = [4,,5,6] #切片连续，等号两边的长度可不一致
#输出[1,2,3,4,5,6]

aList[::2] = [0]*3 #隔一个修改一个
#[0,2,0,4,0,6]

切片删除列表中的元素

aList = [3,5,7,9]
aList[:3] = [] #删除列表中前三个元素

也可使用del命令，并且可以不连续

aList = [3,5,7,9,11]
del aList[:3] #切片元素连续
#输出为[9,11]

aList = [3,5,7,9,11]
del aList[::2] #隔一个删一个
#输出为[5,9]

切片得到列表的浅复制

aList = [3,5,7]
bList = aList[::]
aList = bList #输出True，两个列表值相等
aList is bList #输出False，不是同一对象

修改bList的值不会影响aList