列表

我孙子叫文顿

1.1、列表的创建操作

1.1.1、创建空列表的两种方式

1. list001 = []  # 方式1：直接中括号创建，推荐使用这种方法创建
2. list001 = list()  # 方式2：函数创建

复制代码

1.1.2、初始化指定大小的列表

1. def initialize_2d_list(w, h, val=None):
2.     """
3.     根据给定的长和宽，以及初始值，返回一个二维列表。
4.     例：initialize_2d_list(2, 4) 结果：[[None, None], [None, None], [None, None], [None, None]]
5.     :param w: int类型 列表每个元素的长度
6.     :param h: int类型 列表的长度
7.     :param val: obj类型 初始值，默认为None
8.     :return: 二维列表
9.     """
10.     return [[val for _ in range(w)] for _ in range(h)]

复制代码

1.2、列表的添加操作

1.2.1、在列表的尾部添加（append方法）

1. list001 = []
2. # 将x追加至列表的尾部，不影响列表中已有元素的位置，也不影响列表在内存中的起始地址。
3. list001.append(100)

复制代码

1.2.2、在指定的位置添加（insert方法）

1. list001 = []
2. # 在列表的index位置处插入x,该位置之后的所有元素自动向后移动，索引加1。
3. list001.insert(0, 111)

复制代码

1.2.3、合并列表

1.2.3.1、用 extend() 方法进行合并

1. list001 = []
2. list002 = []
3. # 将list002中所有元素追加至list001的尾部，不影响list001列表中已有元素的位置，也不影响list001在内存中的起始地址。
4. list001.extend(list002)  # 注意：改变的是list001，list002列表没有改变，还是原来的样子

复制代码

1.2.3.2、直接相加进行合并

1. list001 = []
2. list002 = []
3. list003 = list001 + list002  # 注意：这种方法实际是得到一个新列表，原来的两个列表都没改变

复制代码

1.2.3.3、用 sum() 函数合并

1. a = [1, 2, 3]
2. b = [4, 5, 6]
3. c = [7, 8, 9]
4. d = sum((a,b,c), [])
5. print(d)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]

复制代码

1.2.3.4、两个列表合并成字典

1. def list2_to_dict(lst1, lst2):
2.     """
3.     将两个列表合并成字典,将两个长度不等的列表合并为一个字典时，服从少数原则（相当于丢弃多余的元素）
4.     例：list2_to_dict([1, 2], ['a', 'b', 'c']) 结果：{1: 'a', 2: 'b'}
5.     """
6.     return dict(zip(lst1, lst2))

复制代码

1.2.4、复制列表

1.2.4.1、浅拷贝列表

1. name = ["张三", "李四", "王五"]
2. student = ["小明", "小红", name]
3. # 生成列表的副本.注意：这实际上是浅拷贝，注意id值一样
4. student_01 = student.copy()
5. print(id(student[-1]))  # 2277330399296
6. print(id(student_01[-1]))  # 2277330399296

复制代码

1.2.4.2、深拷贝列表

1. import copy
3. name = ["张三", "李四", "王五"]
4. student = ["小明", "小红", name]
5. # 生成列表的副本.注意：这是深度拷贝，注意id值不一样
6. deep_copy = copy.deepcopy(student)
7. print(id(student[-1]))  # 2277330402176
8. print(id(deep_copy[-1]))  # 2277330399936

复制代码

1.3、列表的删除操作

1.3.1、根据索引进行删除

1.3.1.1、删除最后一个元素（pop方法）

1. students = ["张三", "李四", "王五", "赵六", "杰克", "汤姆", "小明"]
2. stu = students.pop()  # 将最后一个元素删除，变量stu会接收被删除的值，及stu = "小明"
3. # 注意：pop()方法是有返回值的，返回的就是被删除的元素，pop(-1)和pop()等价，默认删除最后一个

复制代码

1.3.1.2、删除指定索引的元素

1. students = ["张三", "李四", "王五", "赵六", "杰克", "汤姆", "小明"]
2. stu = students.pop(2)  # 将索引是2的元素删除，变量stu会接收被删除的值，及stu = "王五"

复制代码

1.3.2、根据元素进行删除

1.3.2.1、删除某一个元素（del方法）

1. students = ["张三", "李四", "王五", "赵六", "杰克", "汤姆", "小明"]
2. del students[0]

复制代码

1.3.2.2、移除某一个元素（remove方法）

1. students = ["张三", "李四", "王五", "赵六", "杰克", "汤姆", "小明", "李四"]
2. # 删除第一次出现的 “李四” ，被删除的元素不存在，会抛出异常，
3. students.remove("李四")  # 注意，此方法没有返回值，不能用变量去接收

复制代码

1.3.2.3、根据索引列表批量删除对应位置的元素

1. def del_many_line(lst, index_lst):
2.     """根据给出的索引列表，批量删除对应位置的值"""
3.     return [n for i, n in enumerate(lst) if i not in index_lst]

复制代码

1.3.2.4、清空列表

1. age = [13, 15, 21, 17, 8, 39, 27, 24, 17]
2. age.clear()

复制代码

1.4、列表的修改操作

1. students = ["张三", "李四", "王五", "赵六", "杰克", "汤姆", "小明", "李四"]
2. students[0] = "小红"  # 将第一个位置的元素改为 “小红”， “张三” 被改为了 “小红”

复制代码

1.5、列表的获取操作

1.5.1、获取元素的频率

1.5.1.1、使用 count() 方法获取元素的频率

1. students = ["张三", "李四", "王五", "赵六", "杰克", "汤姆", "小明", "李四"]
2. # 返回 “李四” 在学生列表中出现的次数
3. num = students.count("李四") # 注意：返回值是出现的次数

复制代码

1.5.1.2、使用 Counter 类获取元素的频率

1. from collections import Counter
3. def coll_list(lst):
4.     """
5.     对列表中各个元素出现的次数的统计
6.     使用 Python Counter 类。Python 计数器跟踪容器中每个元素的频数， Counter()返回字典，元素作为键，频数作为值。
7.     另外使用 most_common()函数来获取列表中的 出现次数最多的元素。
8.     """
9.     count = Counter(lst)
11.     # 返回列表中 b 元素出现的次数
12.     print(count['b'])
13.     # 返回列表中出现的次数最多的元素
14.     print(count.most_common(1))
15.     # 返回列表中出现的次数最多的头两个元素
16.     print(count.most_common(2))
17.     return count

复制代码

1.5.2、获取元素的索引

1.5.2.1、获取某元素的索引（index方法）

1. students = ["张三", "李四", "王五", "赵六", "杰克", "汤姆", "小明", "李四"]
2. # 返回列表中第一个值为 “李四” （列表中有两个李四）的元素的索引，若不存在该元素则抛出异常。
3. index = studnets.index("李四")  # 注意：返回值是索引

复制代码

1.5.2.2、获取某元素的所有索引

1. def find_all_index(lst, target):
2.     """获取某一元素在列表中的所有位置，返回结果是一个索引列表"""
3.     target_all_index = []
5.     for i in range(len(lst)):
6.         if lst[i] == target:
7.             target_all_index.append(i)
9.     return target_all_index

复制代码

1.5.3、获取出现频率最多的元素

1. lst = ["张三", "李四", "王五", "小明", "杰克", "汤姆", "小明"]
2. def demo04(lst):
3.     """获取列表中出现次数最多的元素，如果每个元素都是唯一的，则会返回第一个元素"""
4.     return max(lst, key=lst.count)
5. print(demo04(lst))  # 输出：小明

复制代码

1.6、列表的排序操作

1.6.1、排序

1.6.1.1、使用自身的 sort() 方法进行排序

1. age = [13, 15, 21, 17, 8, 39, 27, 24, 17]
2. # 对列表中的元素进行原地排序，key用来指定排序规则，reverse为False（默认）表示升序，为True表示降序
3. age.sort() # 注意：此方法是对原列表进行排序，改变的是原列表
4. age.sort(reverse=True) # 降序

复制代码

1.6.1.2、使用魔法方法 sorted() 进行排序

1. age = [13, 15, 21, 17, 8, 39, 27, 24, 17]
2. age1 = sorted(age)  # 注意：sorted()是魔法方法，返回的是一个排序后的新列表，sort()方法是列表自带的方法

复制代码

1.6.1.3、冒泡排序

1. list001 = [2, 1, 0, 4, 7, 6, 3, 8, 9, 5]
3. for i in range(len(list001) - 1):
4.     for j in range(len(list001) - i - 1):
5.         if list001[j] > list001[j + 1]:
6.             list001[j], list001[j + 1] = list001[j + 1], list001[j]
7. print(list001)

复制代码

1.6.1.4、两个列表联动排序

1. def demo01():
2.     """两个列表一一对应，将一个列表排序，要求另一个列表随之排序"""
3.     list_name01 = ['郭靖', '杨过', '张无忌', '周伯通', '杨天宝', '成是非']
4.     list_name02 = ['黄蓉', '小龙女', '赵敏', '瑛姑', '穆桂英', '云罗郡主']
5.     zipped = zip(list_name01, list_name02)  # 打包操作
6.     # 排序，以序列list_name01为准基排序，得到对应的list_name02在list_name01的排序后的序列结果
7.     # key=lambda 元素: 元素[字段索引]，x:x[]字母可以随意修改，排序方式按照中括号[]里面的维度进行排序，[0]按照第一维排序，[2]按照第三维排序
8.     variable = sorted(zipped, key=lambda x: x[0])
9.     # 根据元组第0个值升序排序，若第0个值相等则根据第1个值升序排序
10.     # variable = sorted(zipped, key=lambda x: (x[0], x[1]))
11.     # 根据元组第0个值升序排序，若第0个值相等则根据第1个值降序排序
12.     # variable = sorted(zipped, key=lambda x: (x[0], -x[1]))
13.     result = zip(*variable)  # 解包操作
14.     # list_name01和list_name02没变
15.     print(list(result))  # [('周伯通', '张无忌', '成是非', '杨天宝', '杨过', '郭靖'), ('瑛姑', '赵敏', '云罗郡主', '穆桂英', '小龙女', '蓉儿')]
16.     return list(result)

复制代码

1.6.2、倒序

1.6.2.1、使用列表自身的方法进行倒序（reverse方法）

1. age = [13, 15, 21, 17, 8, 39, 27, 24, 17]
2. age.reverse()  # 注意：此方法是对原列表进行倒序（及反转列表），改变的是原列表

复制代码

1.6.2.2、使用魔法方法进行倒序（reversed方法）

1. age = [13, 15, 21, 17, 8, 39, 27, 24, 17]
2. variable = reversed(age) # 注意：reversed()是魔法方法，返回的是一个倒序后的新列表，reverse()方法是列表自带的方法

复制代码

1.6.2.3、使用切片方法进行倒序

1. age = [13, 15, 21, 17, 8, 39, 27, 24, 17]
2. age1 = age[::-1]  # 注意：这种方法没有改变原列表，返回的是一个新列表

复制代码

1.7、列表的常见操作

1.7.1、遍历列表

1.7.1.1、使用 enumerate() 遍历列表

1. students = ["张三", "李四", "王五", "赵六", "杰克", "汤姆", "小明", "李四"]
2. for index, value in students:
3.     print(index, value)

复制代码

1.7.1.2、倒序遍历列表

1. # 倒序遍历一个List：
2. for x in reversed(array):
3.     print(x)
5. for x in range(len(array)-1,-1,-1):
6.     print(array[x])

复制代码

1.7.2、分割列表

1.7.2.1、根据需要的大小分割列表

1. from math import ceil
3. def chunk(lst, size):
4.     """
5.     对一个列表根据所需要的大小进行细分
6.     例：chunk([1, 2, 3, 4, 5, 6, 7, 8, 9, 0], 3) 结果：[[1, 2, 3], [4, 5, 6], [7, 8, 9], [0]]
7.     :param lst:
8.     :param size:
9.     :return:
10.     """
11.     return list(map(lambda x: lst[x * size:x * size + size], list(range(0, int(ceil(len(lst) / size))))))

复制代码

1.7.2.2、根据列表中的某一个元素进行分割

1. from itertools import groupby
3. def according_to_element(lst, element):
4.     """
5.     根据列表中的某一个元素进行分割列表
6.     例子：
7.     ["张三","李四", "aa", "王五", "赵六", "小明", "aa", "杰克", "汤姆", "aa", "小兰", "熊二", "熊大", "aa"]
8.     根据 aa 这个元素进行分割，得到
9.     [['张三', '李四'], ['王五', '赵六', '小明'], ['杰克', '汤姆'], ['小兰', '熊二', '熊大']]
10.     """
11.     return [list(g) for k, g in groupby(lst, lambda x: x == element) if not k]

复制代码

1.7.2.3、根据返回True或False来分割归类

1. def bifurcate_by(lst, fn):
2.     """
3.     使用一个函数应用到一个列表的每个元素上，使这个列表被切割成两部分。如果说，函数应用到元素上返回值为True，则该元素被切割到第一部分，否则分到第二部分。
4.     例：bifurcate_by(['beep', 'bop', 'foo', 'bar'], lambda x: x[0] == 'b')，结果：[['beep', 'bop', 'bar'], ['foo']]
5.     :param lst:
6.     :param fn:
7.     :return:
8.     """
9.     return [[x for x in lst if fn(x)], [x for x in lst if not fn(x)]]

复制代码

1.7.3、展开列表

1.7.3.1、嵌套深度只有一层进行展开

1. def expand_list3(lst):
2.     """展开列表清单，如果嵌套列表的深度只有1层，并且只想把所有元素放在一个普通列表中，可以通过下面的方法得到数据"""
3.     return [item for sublist in lst for item in sublist]

复制代码

1.7.3.2、不知道嵌套深度进行展开

1. from iteration_utilities import deepflatten  # pip install -i https://pypi.tuna.tsinghua.edu.cn/simple/ iteration_utilities
3. def expand_list2(lst):
4.     """展开列表清单，不知道列表嵌套深度，只想把所有元素放在一个列表中，可以通过下面的方法得到数据（使用第三方包实现）"""
5.     return list(deepflatten(lst))

复制代码

1.7.3.3、使用递归方法进行展开

1. def expand_list(lst):
2.     """展开列表清单，如果不知道列表嵌套深度，并且只想把所有元素放在一个普通列表中，可以通过下面的方法得到数据（使用递归法实现，比较通用，推荐）"""
3.     if lst is None:
4.         lst = []
5.     res = []
6.     for ys in lst:
7.         if isinstance(ys, list):
8.             res.extend(expand_list(ys))
9.         else:
10.             res.append(ys)
11.     return res

复制代码

1.7.4、清理列表

1.7.4.1、去除无用字符串、空字符串等等

1. def remove_useless_characters(lst):
2.     """
3.     去除无用字符，空字符串等等
4.     例：remove_useless_characters(['', '\t', '\n', '\r', '\v', '\f', ' n  ', 'abc  ', ' '])
5.     结果：['n', 'abc']
6.     """
7.     return [x.strip() for x in lst if x.strip() != '']

复制代码

1.7.4.2、去除错误值

1. def compact(lst):
2.     """
3.     使用 filter() 删除列表中的错误值（如：False, None, 0 和 ''）
4.     例：compact([None, 0, 1, False, '  ', 2, "", 3, 'a', 's', 34]) 结果：[1, '  ', 2, 3, 'a', 's', 34]
5.     """
6.     return list(filter(bool, lst))

复制代码

1.7.5、列表去重

1.7.5.1、推荐的去重方式

1. citys = ['上海', '广州', '上海', '成都', '上海', '上海', '北京', '上海', '广州', '北京', '上海']
3. def remove_duplication(lst):
4.     """列表去重并且不改变原来元素的位置"""
5.     format_list = list(set(lst))
6.     format_list.sort(key=lst.index)
7.     return format_list
8. print(remove_duplication(citys))  # ['上海', '广州', '成都', '北京']

复制代码

1.7.5.2、通过for循环去重

1. # 通过for循环（不会改变原列表）
2. citys = ['上海', '广州', '上海', '成都', '上海', '上海', '北京', '上海', '广州', '北京', '上海']
3. ncity = []
4. for item in citys:
5.     if item not in ncity:
6.         ncity.append(item)
7. print(ncity)  # ['上海', '广州', '成都', '北京']

复制代码

1.7.5.3、通过set方法去重

1. # set方法（改变原来顺序）
2. citys = ['上海', '广州', '上海', '成都', '上海', '上海', '北京', '上海', '广州', '北京', '上海']
3. ncitx=list(set(citys))
4. print(ncitx)  # ['成都', '上海', '广州', '北京']

复制代码

1.7.5.4、通过count()方法统计并删除进行去重

1. # count()方法统计并删除，需要先排序（改变原来顺序）
2. citys = ['上海', '广州', '上海', '成都', '上海', '上海', '北京', '上海', '广州', '北京', '上海']
3. citys.sort()
4. for x in citys:
5.      while citys.count(x)>1:
6.          del citys[citys.index(x)]
7. print(citys)  # ['上海', '北京', '广州', '成都']

复制代码

1.7.5.5、通过转成字典的方式去重

1. # 把列表转成字典，利用字典键唯一的特性去重
2. citys = ['上海', '广州', '上海', '成都', '上海', '上海', '北京', '上海', '广州', '北京', '上海']
3. mylist = list({}.fromkeys(citys).keys())
4. print(mylist)  # ['上海', '广州', '成都', '北京']

复制代码

1.8、常见使用场景

1.8.1、列表随机取样

1. import random
2. import secrets
4. def random_list1(lst, ns):
5.     """从列表中随机取样，下面代码从给定列表中生成了 n 个随机样本"""
6.     samples = random.sample(lst, ns)
7.     return samples
9. def random_list2(lst, ns):
10.     """使用secrets库生成随机样本"""
11.     s_rand = secrets.SystemRandom()
12.     samples = s_rand.sample(lst, ns)
13.     return samples

复制代码

1.8.2、将列表中的连续数据归类

1. def find_consecutive(lst):
2.     """
3.     在列表中找到连续的数据
4.     """
5.     lst01 = []
6.     lst02 = []
7.     for x in sorted(set(lst)):
8.         lst01.append(x)
9.         if x + 1 not in lst:
10.             if len(lst01) != 1:
11.                 lst02.append(lst01)
12.             else:
13.                 lst02.append(lst01)
14.             lst01 = []
15.     return lst02

复制代码

1.8.3、数字按个、十、百、千位进行分割

1. def digitize(n):
2.     """
3.     将整形数字n转化为字符串后，还自动对该字符串进行了序列化分割，最后将元素应用到map的第一个参数中，转化为整形后返回
4.     例：digitize(123) 结果：[1, 2, 3]
5.     :param n:
6.     :return:
7.     """
8.     return list(map(int, str(n)))

复制代码

1.8.4、判断数字和哪个边界值离的近

1. def clamp_number(num, a, b):
2.     """
3.     如果 num 落在 [a,b]数字范围内，则返回num，否则返回离这个范围最近的边界
4.     例：clamp_number(2, 3, 10) 结果：3
5.     例：clamp_number(7, 3, 10) 结果：7
6.     例：clamp_number(20, 3, 10) 结果：10
7.     """
8.     return max(min(num, max(a, b)), min(a, b))

复制代码

1.8.5、斐波拉契数列

[code]def fibonacci(n):     """非递归斐波那契"""     if n