列表 LIST
定义：
由一系列按特定顺序排列的元素组成的有序集合。
创建：
1.list_1 = [] 方括号[] 来表示列表，并用逗号来分隔其中的元素
2.list_1 = list() 小括号()中的元素必须可以迭代。
3.列表推导式：https://www.cnblogs.com/qianslup/p/12160801.html
list_1 = [1,2,3] #结果：[1, 2, 3] list_2 = ['123'] #结果：['123'] list_3 = list(range(6)) #结果：[0, 1, 2, 3, 4, 5] list_4 = list('123') #结果:['1', '2', '3'] list_5 = list('hello') #结果:['h', 'e', 'l', 'l', 'o'] list_6 = list(1) #结果:'int' object is not iterable list_7 = list(1,2) #结果：list expected at most 1 arguments, got 2 list_8 = list((1)) #结果:'int' object is not iterable list_9 = list((1,2)) #结果：[1, 2] list_10 = list[1,'2'] #结果：'type' object is not subscriptable list_10 = [1,'2'] #结果：[1, '2']
切片：
list[start:end:stride]
list_p = list('hello python') #结果:['h', 'e', 'l', 'l', 'o', ' ', 'p', 'y', 't', 'h', 'o', 'n'] #list_p[x:y]从0开始，左闭右开;x可以省略，默认为0，y可以省略，默认为-1 list_p[:4] #结果：['h', 'e', 'l', 'l'] list_p[:] #结果:['h', 'e', 'l', 'l', 'o', ' ', 'p', 'y', 't', 'h', 'o', 'n'] #list_p[x:y:z]，z不为负数 #x>=y, 则返回空列表. list_p[0:-1:2] #结果:['h', 'l', 'o', 'p', 't', 'o'] #倒序排列 print(list_p[::-1]) #结果:['n', 'o', 'h', 't', 'y', 'p', ' ', 'o', 'l', 'l', 'e', 'h'] print(list_p[::-2]) #结果:['n', 'h', 'y', ' ', 'l', 'e']
a = list('python') print(a[2::2]) # ['t', 'o'] print(a[-2::-2]) # ['o', 't', 'p'] print(a[-2:2:-2]) # ['o'] print(a[2:2:2]) # []
说明：
- 切片操作不会计较start与end是否越界
- 在单词切片中，不要同时指定start、end、stride；同时指定会让人费解
- 尽量使用stride为正数，且不带start或end的切割操作，尽量避免stride为负数
- 如果需要指定start、end、stride；拆解成两条语句，一条做范围切割，一条做步进切割，或者考虑内置的itertool模块中的islice（数据量较大时）。
索引：
list_p = list('hello python') #要么是整数： list_p[4] #结果：['0'] #要么是切片： list_p[:4] #结果：['h', 'e', 'l', 'l']
增：
一次只能增加一个元素
list_i = list('hello') #append: 在最后未知增加元素 list_i.append('a') #结果：['h', 'e', 'l', 'l', 'o', 'a'] #在任意未知增加元素,注意不是最后未知 list_i.insert(-1,'c') #结果：['h', 'e', 'l', 'l', 'o', 'c', 'a'] #原来元素后移 list_i.insert(1,'b') #结果：['h', 'b', 'e', 'l', 'l', 'o', 'a', 'a'] list_i
批量增加一个元素
list_i = list('hello') list_p = list('python') list_i.extend(list_p) #结果：['h', 'e', 'l', 'l', 'o', 'p', 'y', 't', 'h', 'o', 'n'] list_i + list_p #结果：['h', 'e', 'l', 'l', 'o', 'p', 'y', 't', 'h', 'o', 'n', 'p', 'y', 't', 'h', 'o', 'n']
注意：extend执行速度更快。
复制列表中的元素
list_i = list('he') list_i * 3 #结果：['h', 'e', 'h', 'e', 'h', 'e']
删：
通过索引删除
不可以在删除时赋值给变量，若无提前赋值，一旦删除，无法使用。
list_i = list('hello') char = list_i[-1] del list_i[-1] print(char) #输出：o print(list_i) #输出：['h', 'e', 'l', 'l']
可以在删除时赋值给给变量，删除之后还能使用。若pop()中未输入参数，则默认为最后一位
list_i = list('hello') del list_i[2] #输出：['h', 'e', 'l', 'o'] cha = list_i.pop(2) #输出：'l'
通过元素删除
无需知道索引，如果有多个相同元素，删除的是第一次出现的元素。删除的元素提前赋值则可以继续使用。
list_i = list('SOS') char = 'S' list_i.remove(char) print(char) #输出：S print(list_i) #输出：['O', 'S']
改：
列表名[索引] = 新值 或者列表名[索引] = 列表
a = list('python') a[4:6] = list('1234') # 切片操作可以越界。a的最大索引为5 print(a) # out:['p', 'y', 't', 'h', '1', '2', '3', '4']
查：
print（列表名[索引] ）
列表表达式：
[表达式 for 变量 in 列表 if 条件]
或者 [表达式 for 变量 in 列表 ]
List_e = [ x ** 2 for x in range(10) ] List_e #结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] List_f = [] for x in range(10): List_f.append( x ** 2 ) List_f #结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] List_g = list(map(lambda x:x ** 2,range(10))) List_g #结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
嵌套列表表达式：
使用列表推导式嵌套时，需要注意前后调用关系。前推导式的值需要在后面书写才能生效。
需要输出的值放到推导式的最前面，生成输出值的推导式在最后面
list_1 = [[1, 2, 3], [4, 5, 6]] list_2 = [i*2 for list_inside in list_1 for i in list_inside*2] print(list_2)
方法：
函数：
| 序号 | 函数 | 描述 |
| 1 | len(list) | 统计list中有多少个元素 |
| 2 | max(list) | 返回list中的最大值 |
| 3 | min(list) | 返回list中的最小值 |
| 4 | list(seq) | 将其他序列转化为列表 |
| 5 | sorted(list) | 将list中的元素进行排序 |
排序：
临时排序
排序之后原列表不变
list_n = [2,7,5,8,1] print(sorted(list_n)) #输出：[1, 2, 5, 7, 8] print(sorted(list_n,reverse = True)) #输出：[8, 7, 5, 2, 1] print(list_n) #输出：[2, 7, 5, 8, 1] list_c = ['a','abc','ab','acb','cb'] print(sorted(list_c,key = len)) #输出：['a', 'ab', 'cb', 'abc', 'acb']
永久排序
排序之后列表顺序发生改变
list_n = [2,7,5,8,1] list_n.sort() print(list_n) #输出：[1, 2, 5, 7, 8] list_n.sort(reverse = True) print(list_n) #输出：[8, 7, 5, 2, 1] list_c = ['a','abc','ab'] list_c.sort(key = len) print(list_c) #输出：['a', 'ab', 'abc']
复制列表：
参考：https://blog.csdn.net/u011630575/article/details/78604226
—–深复制，即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经复制出来的新对象产生影响。 使用切片或者deepcopy()
—–而等于赋值，并不会产生一个独立的对象单独存在，他只是将原有的数据块打上一个新标签，所以当其中一个标签被改变的时候，数据块就会发生变化，另一个标签也会随之改变。 list_1 = list_2
—–而浅复制要分两种情况进行讨论：
1）当浅复制的值是不可变对象（数值，字符串，元组）时和“等于赋值”的情况一样，对象的id值与浅复制原来的值相同。
2）当浅复制的值是可变对象（列表和元组）时会产生一个“不是那么独立的对象”存在。有两种情况：
第一种情况：复制的 对象中无 复杂 子对象，原来值的改变并不会影响浅复制的值，同时浅复制的值改变也并不会影响原来的值。原来值的id值与浅复制原来的值不同。
第二种情况：复制的对象中有 复杂 子对象 （例如列表中的一个子元素是一个列表），如果不改变其中复杂子对象，浅复制的值改变并不会影响原来的值。 但是改变原来的值 中的复杂子对象的值 会影响浅复制的值。
对于简单的 object，例如不可变对象（数值，字符串，元组），用 shallow copy 和 deep copy 没区别
复杂的 object， 如 list 中套着 list 的情况，shallow copy 中的 子list，并未从原 object 真的「独立」出来。也就是说，如果你改变原 object 的子 list 中的一个元素，你的 copy 就会跟着一起变。这跟我们直觉上对「复制」的理解不同。
改变复制后的表，原表不变
list_n = [2,7,5,8,1,'a'] list_m = list_n[:] list_m.insert(-1,'b') print(list_n) #输出：[2, 7, 5, 8, 1, 'a'] print(list_m) #输出：[2, 7, 5, 8, 1, 'b', 'a'] list_v = list_n.copy() list_v.insert(-1,'b') print(list_n) #输出：[2, 7, 5, 8, 1, 'a'] print(list_v) #输出：[2, 7, 5, 8, 1, 'b', 'a']
改变复制后的表，原表随之改变。
list_21 = ['h', 'e', 'l', 'l', 'o',[1,2]] list_22 = list_21 list_21.insert(-1,'b') print(list_21) #输出：['h', 'e', 'l', 'l', 'b', 'o'] print(list_22) #输出：['h', 'e', 'l', 'l', 'b', 'o'] list_23 = list_21.copy() list_21[-1][-1] = 10 print(list_21) #输出：['h', 'e', 'l', 'l', 'o', 'b', [1, 10]] print(list_23) #输出：['h', 'e', 'l', 'l', 'o', 'b', [1, 10]] #如果改变的是一个简单子对象，则仍相对独立 list_21.insert(-1,'d') print(list_21) #输出：['h', 'e', 'l', 'l', 'o', 'b', 'd', [1, 10]] print(list_23) #输出：['h', 'e', 'l', 'l', 'o', 'b', [1, 10]]
遍历列表
