python_7_列表

什么是列表？

--一种数据类型

-- 形式：[值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循环只能遍历一层
 # 通过遍历，把取出来的单个值进行判断，把符合要求的加入到新的列表中，把不符合的添加到中间列表中
 # 最难的是，如何判断最后的循环？
 # 我的想法是，通过最后中间列表的遍历，判断是否还有嵌套列表，通过异常次数和列表长度比较，
 # 如果中间列表等于异常次数，说明循环到了最后的列表，退出整个循环
 # 最后把结果列表变成集合，利用集合天生去重性质，进行去重

　　-- 以上完美解决了任何嵌套列表变成普通列表的问题