什么是列表？
--一种数据类型
-- 形式：[值1，值2，[值a，值b]，值3] --可以嵌套
#!/usr/bin/python3 list_a = [1, 2, [3, 'a']]
对于列表有哪些操作？
--取值 -- list[index] -- list[-1] 取最后一个值
--知元素，查位置：列表名.index(‘元素名’)
#!/usr/bin/python3
list_a = [1, 2, [3, 'a']]
print(list_a[0]) # 索引从0开始
print(list_a[2][1]) # 嵌套循环，需要嵌套查询
try:
print(list_a.index('a'))
except Exception as e:
print(e)
print('why?')
print('因为index()和for 遍历一样，只能遍历一层，[3, a]，被当做一个元素')
--插入 -- .insert(位置,一个元素) -- .append(‘元素’) - 最后追加一个元素
#!/usr/bin/python3
list_a = [1, 2, [3, 'a']]
try:
list_a.insert(5, 'b') # 当索引位置大于原来列表索引，默认最后添加'b'
print(list_a)
list_a.insert(1, 4) # 在索引 = 1的位置添加4，原来在1位置的往后退一位
print(list_a)
list_a.append('c') # 在最后添加'c'
except Exception as e:
print(e)
--切片
--[start：end：step] 顾头不顾尾，前面从0开始，0可省去，后面从-1开始，降序
-- 取前面2个值： 列表[0：2] 或 列表[：2]
-- 取后面2个值： 列表[-3：-1] 或 列表[-2：]
-- 取到倒数第2个值： 列表[0：-2]
-- 取从索引2到最后的值： 列表[2：]
#!/usr/bin/python3
list_a = [1, 2, [3, 'a'], 4, 5]
try:
# 切片也是顾头不顾尾
slice_1 = list_a[:2] # 取前面两个值
slice_2 = list_a[:-2] # 取到倒数第2个值,不包括倒数第2个值
slice_3 = list_a[2:] # 从第2个值取到最后
slice_4 = list_a[-2:] # 取倒数2个值
print(slice_1)
print(slice_2)
print(slice_3)
print(slice_4)
except Exception as e:
print(e)
-- 删除
-- .remove(“元素”) <=> del 列表[ index ]
#!/usr/bin/python3
list_a = [1, 2, [3, 'a'], 4, 5]
try:
list_a.remove(1) # 移除已知元素值
print(list_a)
del list_a[2] # 知道索引，删除值
print(list_a)
except Exception as e:
print(e)
-- .pop(index) - 不填index删除最后一个 -唯一删除有返回值 = 删除元素
#!/usr/bin/python3
list_a = [1, 2, [3, 'a'], 4, 5]
try:
result_1 = list_a.remove(1) # 尝试接收删除的值
print(result_1)
result_2 = list_a.pop(1) # 尝试接收删除的值，唯一有返回值，写索引，按索引删，不写，从最后一个删除
print(result_2)
except Exception as e:
print(e)
-- .clear - 清空列表
-- .del 列表 - 删除列表
#!/usr/bin/python3
list_a = [1, 2, [3, 'a'], 4, 5]
try:
list_a.clear() # 置空列表
print(list_a)
del list_a # 删除列表
print(list_a) # 尝试打印已经删除的列表，触发异常
except Exception as e:
print(e) # 打印异常
-- 统计
-- .count(“元素”) - 统计列表中有多少个同样的元素
-- len(列表) - 统计列表中有多少个同样的元素
-- 反转 -- .reverser() - 原列表翻转过来
-- 排序 -- .sort() - 数字小到大，母A-Z-a-z
#!/usr/bin/python3
list_a = [1, 2, [3, 'a'], 4, 5, 6, 6, 5]
try:
count = list_a.count(6) # 计算列表中6个个数
print(count)
len_a = len(list_a) # 计算列表的长度，每个嵌套的都看作一个元素，对于一层
print(len_a)
list_a.reverse() # 把列表反转过来，改变原来的列表
print(list_a)
list_a.sort() # sort只能对普通列表排序，不能排序嵌套列表
print(list_a)
except Exception as e:
print(e) # 打印异常
-- 扩展 -- .extent(列表2) - 列表2还存在
-- 复制 -- .copy() - 浅浅拷贝 ，大坑，只针对一层，列表机制决定
#!/usr/bin/python3
list_a = [1, 2, [3, 'a'], 4, 5, 6, 6, 5]
list_b = [88, 99, 100]
try:
list_a.extend(list_b) # 用list_b扩展list_a，list_b并没有改变
print('list_a:', list_a)
print('list_b:', list_b)
list_c = list_a.copy() # 进行list_a的拷贝，浅浅拷贝
print('list_c:', list_c)
list_c[1] = 'c' # 对list_c进行一层修改
list_c[2][1] = 'b' # 对list_c进行嵌套层修改
print('list_a:', list_a)
print('list_c:', list_c)
print('突然发现，嵌套层也会跟着修改，copy只是拷贝一层')
print('那如何解决呢？')
except Exception as e:
print(e) # 打印异常
-- import copy ist_deep =copy.deepcopy(list_a)
- 完全拷贝一份，深深拷贝
#!/usr/bin/python3
import copy
list_a = [1, 2, [3, 'a'], 4, 5, 6, 6, 5]
list_b = [88, 99, 100]
try:
list_c = copy.deepcopy(list_a) # 进行list_a的拷贝，深深拷贝
print('list_c:', list_c)
list_c[1] = 'c' # 对list_c进行一层修改
list_c[2][1] = 'b' # 对list_c进行嵌套层修改
print('list_a:', list_a)
print('list_c:', list_c)
print('突然发现，嵌套层不会跟着修改，deepcopy会完全拷贝')
print('真是大天坑，少侠，踩坑了木有')
except Exception as e:
print(e) # 打印异常
什么是元组？
--上了枷锁的列表，一旦定义，无法修改，但可以切片
-- 形式（元素1，元素2，......） --声明此数据不要更改
#!/usr/bin/python3
tuple_1 = (1, 2, 4, 'a')
try:
print(tuple_1.count(1)) # 统计 1 的个数
print(tuple_1.index(4)) # 打印 4 的索引
print(tuple_1[:2]) # 取前面2个值，切片出来的值还是元组
except Exception as e:
print(e) # 打印异常
如何把[1, 5, 6, [2, 7, [3, [4, 5, 6]]]]变成[1, 5, 6, 2, 7, 3, 4, 5, 6]？
思考：
-- for循环每次都遍历列表一层
-- 把取出的单个值加入到新的列表中
-- 把取出来的嵌套列表变成新的遍历列表，就需要在for循环外嵌套一个while循环
-- 当取到最里面的列表嵌套时候，对最后一个值进行处理
#!/usr/bin/python3
import time
list_1 = [1, 5, 6, [2, 7, 7, [3, [4, 5, 6]]]] # 定义一个嵌套列表
list_1_new = list_1 # 定义递归接收嵌套列表
list_2 = [] # 定义接收取出数据的空列表
count = 0 # 循环计数，用于循环列表长度计数
while True: # 开始循环
try:
for i in list_1_new: # 每次循环都打印一层
count += 1
if count < len(list_1_new): # 计算小于初始列表的长度，取出一层数据
list_2.append(i)
elif count == len(list_1_new): # 当计数长度等于初始列表长度，取出二层嵌套列表
list_1_new = i # 把初始列表变成取出的上面取出的嵌套列表，变成变成遍历初始列表的二层嵌套
count = 0 # 计算清零
except Exception as e: # 出现异常打印异常
print(e)
print(list_2) # 打印每次遍历已经添加的值
print(list_1_new) # 打印每次取出的嵌套列表
try:
len(list_1_new) # 假如最后只有一个值的时候，触发len()异常
except TypeError as e:
print(e)
list_2.append(list_1_new) # 把最后一个值添加进去
break # 把最后一个值添加进去跳出循环
print(list_2) # 打印最好的值
没有解决一个问题：
-- 这个问题本身很特殊，有点递归嵌套，无法解决一层有2个以上的嵌套列表
如何解决 ['a', 'b', 1, ['c', [2, 'd'], 3, 4, 5, ['e', 6, 'f', ], 7], 8] 变成普通列表？
#!/usr/bin/python3
list_1 = ['a', 'b', 1, ['c', [2, 'd'], 3, 4, 5, ['e', 6, 'f', ], 7], 8] # 初始列表
list_1_new = list_1 # 循环映射列表
list_a = [] # 循环添加 取出的单个值
list_c = [] # 循环接收 取出来的嵌套列表，一个中间列表
while True: # 开始循环
for i in list_1_new: # 开始循环取值
try:
if len(list_1): # 判断取出是否是整数，是整数触发异常
try:
if i.isalnum(): # 判断取出是否是字符串，不是字符串触发异常
list_a.append(i) # 是字符串添加到list_a中去
except Exception as e: # 触发不是字符串异常
print(e)
list_c.extend(i) # 把取出的嵌套列表加入到list_c中
list_1_new = list_c # 循环list_1_new指向嵌套列表，指向list_c
print(list_1_new) # 打印list_1_new值
except Exception as e: # 触发整数len()方法异常
print(e)
list_a.append(i) # 是整数添加到list_a中去
count = 0 # 判断取到最后的嵌套列表中是否还有嵌套列表
for i in list_c: # 循环二层嵌套列表
try: # 尝试判断最后一层嵌套列表是否嵌套，如果嵌套，异常次数就会少于列表长度
len(i) # 整数触发异常
i.isalnum() # 不是字符串触发异常
except Exception as e:
print(e)
count += 1 # 每出现一次异常，异常次数加1
if count == len(list_c): # 判断异常次数是否等于最后循环列表长度，如果等于，就确认已经循环了最后一层列表，退出整个循环
break
list_c = [] # 置空中间列表，接收下一层嵌套列表
print(list_a)
print(list_1_new)
print(list_a)
set_a = set(list_a) # 把最后的结果去重，把列表转换成集合，集合天生去重
print(set_a, )
# 逻辑整理
# 本质上通过for循环特性，for循环只能遍历一层
# 通过遍历，把取出来的单个值进行判断，把符合要求的加入到新的列表中，把不符合的添加到中间列表中
# 最难的是，如何判断最后的循环？
# 我的想法是，通过最后中间列表的遍历，判断是否还有嵌套列表，通过异常次数和列表长度比较，
# 如果中间列表等于异常次数，说明循环到了最后的列表，退出整个循环
# 最后把结果列表变成集合，利用集合天生去重性质，进行去重
-- 以上完美解决了任何嵌套列表变成普通列表的问题