• Python之第六章 内置容器 --- 列表（2）

    目录

    Python之第六章 内置容器 --- 列表（2）

    1.列表元素的添加和删除

    2.列表元素统计

    3.列表的排序

    排序归类

    4.列表的查找

    5.列表逆置（颠倒顺序）

    6.列表的元素组合

    7.列表的浅拷贝与深拷贝

            列表之间的赋值

    浅拷贝

    深拷贝

    8.列表的推导式

    根据就列表生成指定新列表

    从旧列表中选择符合条件的元素组成新列表

    9.程序实例

    Python之第六章 内置容器 --- 列表（2）

    1.列表元素的添加和删除

            添加元素 --- listname.append(obj)

            例1 将值为奇数、索引为偶数的元素存储到另一个列表中

    1. # 例1 将值为奇数、索引为偶数的元素存储到另一个列表中
    2. import random
    3. ​
    4. t1 = random.sample(range(10, 30), 10)
    5. t2 = []
    6. print(t1)
    7. for index, item in enumerate(t1):
    8.     if item % 2 == 0 and index % 2 == 1:
    9.         t2.append(item)
    10. print(t2)
    11. ​
    12. 结果
    13. [14, 24, 18, 15, 17, 25, 19, 21, 13, 12]
    14. [24, 12]

            删除元素 --- 根据索引删除 --- del listnname[index]

                           --- 根据内容删除 --- listname.remove(下标)

            例2 删除指定元素

    1. #方法一
    2. import random
    3. ​
    4. t1 = random.sample(range(10, 30), 10)
    5. print(t1)
    6. n = int(input('请输入需要删除的元素的值'))
    7. for i in t1:
    8.     if i == n:
    9.         t1.remove(i)
    10. ​
    11. print(t1)
    12. ​
    13. 结果：
    14. [23, 26, 18, 21, 10, 22, 25, 15, 13, 16]
    15. 请输入需要删除的元素的值10
    16. [23, 26, 18, 21, 22, 25, 15, 13, 16]
    17. ​
    18. #方法二
    19. import random
    20. ​
    21. t1 = random.sample(range(10, 30), 10)
    22. print(t1)
    23. n = int(input('请输入需要删除的元素的值'))
    24. t1.remove(n)
    25. print(t1)
    26. ​
    27. 结果：
    28. [28, 18, 12, 25, 26, 24, 14, 23, 29, 27]
    29. 请输入需要删除的元素的值12
    30. [28, 18, 25, 26, 24, 14, 23, 29, 27]

    2.列表元素统计

            格式 --- listname.count(obj)

            作用 --- 获取元素在列表中的出现的次数，只能精确匹配

            注意 --- count（）方法一般与remove（）方法配合使用，即删除前先统计元素是否存在

            例：

    1. #完善1中的例2
    2. import random
    3. ​
    4. t1 = random.sample(range(10, 30), 10)
    5. print(t1)
    6. n = int(input('请输入需要删除的元素的值'))
    7. if t1.count(n) > 0:
    8.     t1.remove(n)
    9.     print(t1)
    10. else:
    11.     print('请输入的元素不在列表中')
    12. 结果：
    13. [13, 29, 22, 25, 15, 28, 14, 20, 11, 17]
    14. 请输入需要删除的元素的值50
    15. 请输入的元素不在列表中

    3.列表的排序

            例1 选择法排序 --- 有n个元素参与排序，一共进行n-1次比较，每次都是当前值与下一个值进行比较，比较到n之前结束，大于号为升序，小于号为降序

    1. # 例1 选择法排序 --- 有n个元素参与排序，一共进行n-1次比较，每次都是当前值与下一个值进行比较，比较到n之前结束
    2. import random
    3. ​
    4. t1 = random.sample(range(10, 30), 10)
    5. print('排序前：', t1)
    6. ​
    7. for i in range(len(t1) - 1):
    8.     for j in range(i + 1, len(t1)):
    9.         if t1[i] > t1[j]:
    10.             t1[i], t1[j] = t1[j], t1[i]
    11. print('排序后：', t1)
    12. ​
    13. 结果：
    14. 排序前： [12, 17, 15, 29, 13, 25, 27, 22, 16, 10]
    15. 排序后： [10, 12, 13, 15, 16, 17, 22, 25, 27, 29]

            例2 插入排序

    1. # 例2 插入排序
    2. import random
    3. ​
    4. t1 = random.sample(range(10, 30), 10)
    5. print('排序前：', t1)
    6. for i in range(1, 10):
    7.     t = t1[i] # t为待插入元素
    8.     j = i - 1
    9.     # while 循环作用：将比当前元素大的值向右移动
    10.     while j >= 0 and t < t1[j]:
    11.         t1[j + 1] = t1[j]
    12.         j = j - 1
    13.     t1[j + 1] = t # 插入备份的元素
    14. print('排序后:', t1)
    15. ​
    16. 结果：
    17. 排序前： [24, 16, 28, 15, 25, 17, 13, 10, 29, 18]
    18. 排序后: [10, 13, 15, 16, 17, 18, 24, 25, 28, 29]

    排序归类

    使用sort（）方法排序

            格式 --- listname.sort(key = None,reverse = False)

    key --- 元素排序时比较的关键字 --- 如：key = str.lower --- 排序时不区分大小写字母

    reverse --- 排序规则，Ture表示降序，False表示升序，默认为升序

    sort( ) --- 该方法会修改列表的内容，返回值为None

            例 对列表进行升序

    1. import random
    2. ​
    3. list1 = random.sample(range(0, 20), 20)
    4. print('排序前：', list1)
    5. list1.sort()
    6. print("升序排序为：", list1)
    7. list1.sort(reverse=True)
    8. print("降序排序为：", list1)
    9. ​
    10. 结果:
    11. 排序前： [15, 17, 14, 0, 1, 7, 13, 4, 10, 3, 2, 18, 6, 5, 16, 11, 9, 19, 8, 12]
    12. 升序排序为： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
    13. 降序排序为： [19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

    使用内置的sorted( )

            用法 --- 参照上述sort（）

            注意 --- 不改变列表的顺序，会生成副本

            例 对列表进行降序排序

    1. # 使用sorted()方法进行降序排列
    2. import random
    3. ​
    4. list1 = random.sample(range(0, 20), 20)
    5. print(list1)
    6. print(sorted(list1, reverse=True))
    7. print(list1)
    8. ​
    9. 结果：
    10. [7, 18, 5, 16, 14, 13, 4, 19, 17, 8, 1, 0, 9, 12, 3, 15, 2, 11, 6, 10]
    11. [19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
    12. [7, 18, 5, 16, 14, 13, 4, 19, 17, 8, 1, 0, 9, 12, 3, 15, 2, 11, 6, 10]

    4.列表的查找

    index( )方法

            定义 --- 用来查找某个元素在列表中第一次出现的位置（索引） --- 若果没有该元素，会导致ValueError错误 ，所以需要配合count( )方法判断是否存在该元素

            格式 --- listname.index（obj,start,end）

    listname --- 列表名

    obj --- 查找的元素对象

    start --- 起始索引

    end --- 终止索引（不包含）

    返回值 --- 索引

    1. list1 = [40, 36, 38, 89, 2, 36, 100, 7, -20, 20.5, -999]
    2. print(list1.index(2))  # 查找数据2
    3. print(list1.index(100, 3, 7))  # 在[3,7)索引中查找100
    4. print(list1.index(7, 4))  # 从4索引开始到结束查找7
    5. print(list1.index(89, 0, 2))  # 0索引到1索引查找89，未找到报错
    6. ​
    7. 结果：
    8. Traceback (most recent call last):
    9.   File "E:\pythontext\test3.py", line 1381, in 
    10.     print(list1.index(89, 0, 2))  # 0索引到1索引查找89，未找到报错
    11. ValueError: 89 is not in list
    12. 4
    13. 6
    14. 7

            例 有列表andy，内容包含名称和一系列的比赛的分，计算他在第几场得到最高分

    1. andy = ['andy', 23, 19, 22, 31, 18, 15]
    2. print(andy)
    3. scorce_max = max(andy[1:])
    4. i = andy.index(scorce_max)
    5. print(andy[0], "在第%d场的最高分数%d" % (i - 1, scorce_max))
    6. ​
    7. 结果：
    8. ['andy', 23, 19, 22, 31, 18, 15]
    9. andy 在第3场的最高分数31

            使用 in 和not in查找列表元素

    1. list1 = [40, 36, 89, 2, 36]
    2. print(2 in list1)
    3. print(100 not in list1)
    4. ​
    5. 结果：
    6. True
    7. True

            二分法查找（折半查找）--- 要求必须是有序（升序）序列，若为无序序列则应该先排序

    1. # 二分查找法
    2. import random
    3. ​
    4. list1 = random.sample(range(0, 20), 20)
    5. list1.sort()
    6. print(list1)
    7. ​
    8. n = int(input('请输入要查找的值：'))
    9. i = 0
    10. j = 20 - 1
    11. while i <= j:
    12.     mid = (i + j) // 2 #计算中间数索引
    13.     if list1[mid] == n:
    14.         print('找到了')
    15.         break
    16.     else:
    17.         if n < list1[mid]:
    18.             j = mid - 1 #向左折半
    19.         else:
    20.             i = mid + 1 #向右折半
    21. if i > j:
    22.     print('未找到')
    23.     
    24. 结果：
    25. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
    26. 请输入要查找的值：9
    27. 找到了

    5.列表逆置（颠倒顺序）

            格式 --- listname.reverse

            例

    1. import random
    2. ​
    3. list1 = random.sample(range(0, 20), 10)
    4. print(list1)
    5. list1.reverse()
    6. print(list1)
    7. ​
    8. 结果：
    9. [13, 4, 9, 1, 14, 17, 10, 11, 5, 0]
    10. [0, 5, 11, 10, 17, 14, 1, 9, 4, 13]

    注意：

            永久性的改变，若需要使用原始数据则只需要再执行一次

    6.列表的元素组合

            作用 --- 将列表的元素组成一个字符串

            格式 --- char.join(seq)

    char --- 组合后元素的分隔符

    seq --- 表示处理的对象，必须为列表、元组等序列数据

            例

    1. char = '-'
    2. list1 = ['silicon', 'stone', 'education']
    3. print(char.join(list1))
    4. print('=='.join(list1))
    5. print('\n'.join(list1))
    6. ​
    7. 结果：
    8. silicon-stone-education
    9. silicon==stone==education
    10. silicon
    11. stone
    12. education

    7.列表的浅拷贝与深拷贝

            列表之间的赋值

    1. list1 = [1, 2, 3, 4]
    2. list2 = list1
    3. print(id(list1), id(list2))
    4. for i in range(len(list1)):
    5.     list1[i] += 1  # list1中所有元素值加1
    6. print(list1)
    7. print(list2)
    8. ​
    9. 结果：
    10. 1132680788160 1132680788160
    11. [2, 3, 4, 5]
    12. [2, 3, 4, 5]

    注意：

            列表复制相当于取别名，即两者都指向同一个堆栈区的地址列表对象，操作任意一个，另一个同步变化

    浅拷贝

    1. list1 = [1, 2, 3, 4]
    2. list2 = list1.copy()  # list2是list1的浅拷贝结果
    3. print(id(list1), id(list2))
    4. for i in range(len(list1)):
    5.     list1[i] += 1  # list1中所有元素值加1
    6. print(list1)
    7. print(list2)
    8. ​
    9. 结果：
    10. 1799131117824 1799131118080
    11. [2, 3, 4, 5]
    12. [1, 2, 3, 4]
    13. ​

    分析：

             list2是list1列表的浅拷贝，id与list1不同，这是因为通过浅拷贝，产生的一段新的内存地址空间，与list2绑定，虽然内容相同但地址不同，相互隔离，互补影响，--- 列表中出现可变类型时则浅拷贝无效

            例

    1. list1 = [1, 2, [3, 4]]
    2. list2 = list1.copy()  # list2是list1的浅拷贝结果
    3. print(id(list1), id(list2))
    4. list1[0] += 1
    5. list1[1] += 1
    6. list1[2][0] += 1
    7. list1[2][1] += 1
    8. ​
    9. print(list1)
    10. print(list2)
    11. print(id(list1[2]), id(list2[2]))
    12. ​
    13. 结果：
    14. 2688355350976 2688355364736
    15. [2, 3, [4, 5]]
    16. [1, 2, [4, 5]]
    17. 2688355350784 268835535078

    分析

            list1列表两个不可变元素1和2没有改变，并且没有影响list2，但list1的可变类型元素[3,4]改为[4,5]list2列表中的字列表也一同改变，说明list1与list2并没有完全隔离开来，虽然list1和list2的内存地址相互独立，但列表第三项绑定的是同一个子列表地址，如果原列表包含了可变类型元素，通过浅拷贝得到的新列表，不能实现与原列表完全各路，若完全隔离需要使用深拷贝

    深拷贝

    1. import copy
    2. ​
    3. list1 = [1, 2, [3, 4]]
    4. list2 = copy.deepcopy(list1)  # list2是list1的深拷贝结果
    5. print(id(list1), id(list2))
    6. list1[0] += 1
    7. list1[1] += 1
    8. list1[2][0] += 1
    9. list1[2][1] += 1
    10. ​
    11. print(list1)
    12. print(list2)
    13. print(id(list1[2]), id(list2[2]))
    14. ​
    15. 结果：
    16. 2239442863744 2239442464000
    17. [2, 3, [4, 5]]
    18. [1, 2, [3, 4]]
    19. 2239443485760 2239442463680

    分析

            通过深拷贝，子列表完全隔离，从而实现了与原列表真正的完全区分隔离

    8.列表的推导式

            作用 --- 可以疏通推导式生成新列表

            格式 --- listname = [表达式，for，循环变量，in range()]

            例1 创建数值为0-19的列表

    1. list1 = [x for x in range(20)]
    2. print(list1)
    3. ​
    4. #相当于：
    5. ​
    6. list1 = []
    7. for x in range(20):
    8.     list1.append(x)
    9. print(list1)
    10. ​
    11. 结果：
    12. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

            例2 创建100-200间30个数的随机数列表

    1. # 创建100-200间30个数的随机数列表
    2. import random
    3. ​
    4. list1 = [random.randint(100, 200) for i in range(30)]
    5. print(list1)
    6. ​
    7. 结果：
    8. [158, 105, 170, 101, 158, 144, 118, 141, 133, 148, 185, 120, 134, 115, 146, 189, 150, 194, 187, 131, 142, 181, 167, 148, 144, 141, 108, 136, 125, 168]

            randint(x,y) 表示产生一个随机数，范围在x与y之间

    根据就列表生成指定新列表

            格式 --- newlistname = [表达式，for 循环变量 in 旧列表]

            例 根据原列表生成数值折半列表

    1. # 例 根据原列表生成数值折半列表
    2. import random
    3. ​
    4. list1 = [random.randint(0, 100) for i in range(20)]
    5. print(list1)
    6. list2 = [x / 2 for x in list1]
    7. print(list2)
    8. ​
    9. 结果：
    10. [59, 85, 12, 1, 23, 85, 38, 8, 59, 88, 29, 50, 100, 18, 42, 29, 67, 84, 34, 38]
    11. [29.5, 42.5, 6.0, 0.5, 11.5, 42.5, 19.0, 4.0, 29.5, 44.0, 14.5, 25.0, 50.0, 9.0, 21.0, 14.5, 33.5, 42.0, 17.0, 19.0]
    12. ​

    从旧列表中选择符合条件的元素组成新列表

            格式 --- newlistname = [表达式，for 循环变量 in 旧列表名 if 条件表达式 ]

            例 创建1-10之间的偶数列表

    1. # 例 创建1-10之间的偶数列表
    2. import random
    3. ​
    4. list1 = [random.randint(0, 100) for i in range(10)]
    5. print(list1)
    6. list2 = [x for x in list1 if x % 2 == 0]
    7. print(list2)
    8. ​
    9. 结果：
    10. [21, 22, 49, 77, 56, 44, 30, 48, 37, 55]
    11. [22, 56, 44, 30, 48]
    12. ​

    注意

            只用列表推导式来创建新列表，并且竟可能保持简短

            如果列表推导式的代码超过2行，则代码可读性大大降低，应考虑写成循环

    9.程序实例

            例1 将20个十进制整数存储在xx列表中，计算系列表的奇数平均值，偶数平均值、偶数的方差

    1. # 例1 将20个十进制整数存储在xx列表中，计算系列表的奇数平均值，偶数平均值、偶数的方差
    2. # 方法一
    3. import numpy
    4. import random
    5. ​
    6. xx = random.sample(range(0, 30), 20)
    7. ave1 = []
    8. ave2 = []
    9. for i in xx:
    10.     if i % 2 == 1:
    11.         ave1.append(i)
    12.     else:
    13.         ave2.append(i)
    14. print('奇数平均值：', numpy.mean(ave1))
    15. print('偶数平均值：', numpy.mean(ave2))
    16. print('偶数方差：', numpy.var(ave2))
    17. ​
    18. # 方法二
    19. import numpy
    20. import random
    21. ​
    22. xx = random.sample(range(0, 30), 20)
    23. ave1 = [i for i in xx if i % 2 == 1]
    24. ave2 = [i for i in xx if i % 2 == 0]
    25. print('奇数平均值：', numpy.mean(ave1))
    26. print('偶数平均值：', numpy.mean(ave2))
    27. print('偶数方差：', numpy.var(ave2))
    28. ​
    29. 结果：
    30. 奇数平均值： 14.6
    31. 偶数平均值： 13.8
    32. 偶数方差： 77.16

            例2 将输入一行空格作为分隔符的数字去重后输出

    1. # 例2 将输入一行空格作为分隔符的数字去重后输出
    2. # split() 将空格分隔的字符串切片后转化为字符串列表
    3. list1 = input('请输入空格分隔的数字内容：').split()
    4. for i in range(len(list1)):
    5.     list1[i] = int(list1[i])
    6. print(list1)
    7. list2 = []
    8. for i in list1:
    9.     if list2.count(i) == 0:  # 统计接收列表 若为0表示唯一，则追加
    10.         list2.append(i)
    11. print(list2)
    12. ​
    13. 结果：
    14. 请输入空格分隔的数字内容：6 1 0 6 0 2 85 1 89 22 6 5
    15. [6, 1, 0,   6, 0, 2, 85, 1, 89, 22, 6, 5]
    16. [6, 1, 0, 2, 85, 89, 22, 5]
    17. ​

            例3 合并2个有序列表构成一个新的有序列表

    1. #   例3 合并2个有序列表构成一个新的有序列表
    2. list1 = list(eval(input("请输入第一个列表：")))
    3. list2 = list(eval(input("请输入第二个列表：")))
    4. # extend()在列表尾部，追加一个完整列表
    5. list1.extend(list2)
    6. list1.sort()
    7. print(list1)
    8. ​
    9. 结果：
    10. 请输入第一个列表：1,5,5,8,9,5,6,25,16,51
    11. 请输入第二个列表：6,5,4,8,1,2,3,4,8
    12. [1, 1, 2, 3, 4, 4, 5, 5, 5, 5, 6, 6, 8, 8, 8, 9, 16, 25, 51]
    13. ​
    14. ​

            例4 编写程序实现判断 列表是否为升序

    1. # 例4 编写程序实现判断列表是否为升序
    2. list1 = list(eval(input("请输入第一个列表：")))
    3. f = 1  # 默认认为为升序，标志位 --- 表示程序的可能性
    4. for i in range(len(list1) - 1):
    5.     if list1[i] > list1[i + 1]:
    6.         f = 0
    7.         break
    8. if f == 1:
    9.     print('该列表为升序')
    10. else:
    11.     print('该列表无序')
    12.     
    13. 结果：
    14. 请输入第一个列表：1,2,3,4,5,6
    15. 该列表为升序

            例5 输入一个十进制数转换为二进制数输出

    1. # 例5 输入一个十进制数转换为二进制数输出
    2. # 方法一
    3. list1 = []
    4. num = int(input('请输入一个十进制整数：'))
    5. if num == 0:
    6.     print('0000')
    7. else:
    8.     while num != 0:
    9.         list1.append(num % 2)
    10.         num = num // 2
    11. list1.reverse()
    12. print(list1)
    13. ​
    14. # 方法二
    15. list1 = []
    16. num = int(input('请输入一个十进制整数：'))
    17. if num == 0:
    18.     print('0000')
    19. else:
    20.     while num != 0:
    21.         num, r = divmod(num, 2)  # 计算num%2得到的商和余数
    22.         list1.append(r)
    23. list1.reverse()  # reverse()内置方法将列表颠倒
    24. print(list1)
    25. ​
    26. 结果：
    27. 请输入一个十进制整数：6
    28. [1, 1, 0]

            例6 将列表的前p的元素平移到列表尾部后输出

    1. # 例6 将列表的前p的元素平移到列表尾部后输出
    2. import random
    3. ​
    4. list1 = random.sample(range(0, 50), 10)
    5. print('随机的列表为：', list1)
    6. p = int(input('请输入移动元素个数：'))
    7. for i in range(p):
    8.     list1.append(list1[i])
    9. list1 = list1[p:]
    10. print(list1)
    11. ​
    12. 结果：
    13. 随机的列表为： [22, 19, 11, 23, 7, 8, 46, 48, 17, 40]
    14. 请输入移动元素个数：2
    15. [11, 23, 7, 8, 46, 48, 17, 40, 22, 19]
    16. ​ 

  • 相关阅读:
    剑指 Offer 06. 从尾到头打印链表
    李沐d2l(十)--卷积层Ⅱ
    【数字IC设计/FPGA】FIFO与流控机制
    客服快捷短语
    什么是数据泄露？泄露途径有哪些？企业如何免遭数据泄露？
    设计模式Java实战
    Windows下Redis的安装和配置
    linux 性能优化
    【力扣每日一题】2023.9.5 从两个数字数组里生成最小数字
    简述Spring Bean生命周期
  • 原文地址：https://blog.csdn.net/qq_57289939/article/details/127575620