列表就是一组有序的数据组合，列表中的数据可以被修改

列表的定义

  • 可以使用 中括号进行定义 []
  • 也可以使用 list函数 定义
  • 在定义列表中的元素时，需要在每个元素之间使用逗号，进行分隔。[1,2,3,4]
  • 列表中的元素可以是任意类型的，通常用于存放同类项目的集合

列表的基本操作

  • 列表定义-[],list()
  • 列表相加-拼接
  • 列表相乘-重复
  • 列表的下标- 获取,更新
  • 列表元素的添加-append()
  • 列表元素的删除
    • del 列表[下标]
    • pop()函数 删除元素

列表中切片

语法==> 列表[开始索引:结束索引:步进值]

1。 列表[开始索引:] ==> 从开始索引到列表的最后
2。 列表[:结束值] ==> 从开始到指定的结束索引之前
3。 列表[开始索引:结束索引] ==> 从开始索引到指定结束索引之前
4。 列表[开始索引:结束索引:步进值] ==> 从指定索引开始到指定索引前结束，按照指定步进进行取值切片
5。 列表[:] 或 列表[::] ==> 所有列表元素的切片
6。 列表[::-1] ==> 倒着获取列表的元素

示例：

  1. varlist = ['刘德华','张学友','张国荣','黎明','郭富城','小沈阳','刘能','宋小宝','赵四']
  3. # 从开始索引到列表的最后
  4. res = varlist[2:] # ['张国荣','黎明','郭富城','小沈阳','刘能','宋小宝','赵四']
  5. # 从开始到指定的结束索引之前
  6. res = varlist[:2] # ['刘德华','张学友']
  7. # 从开始索引到指定结束索引之前
  8. res = varlist[2:6] # ['张国荣', '黎明', '郭富城', '小沈阳']
  9. # 从指定索引开始到指定索引前结束，按照指定步进进行取值切片
  10. res = varlist[2:6:2] # ['张国荣', '郭富城']
  11. # 所有列表元素的切片
  12. res = varlist[:]
  13. res = varlist[::]
  14. # 倒着输出列表的元素
  15. res = varlist[::-1]
  17. # 使用切片方法 对列表数据进行更新和删除
  18. print(varlist)
  20. # 从指定下标开始，到指定下标前结束，并替换为对应的数据(容器类型数据，会拆分成每个元素进行赋值)
  21. # varlist[2:6] = ['a','b','c',1,2,3]
  22. # varlist[2:6:2] = ['a','b'] # 需要与要更新的元素个数对应
  24. # 切片删除
  25. # del varlist[2:6]
  26. del varlist[2:6:2]

列表相关函数

  1. varlist = ['刘德华','张学友','张国荣','张学友','黎明','郭富城','小沈阳','刘能','宋小宝','赵四']
  3. # len()  检测当前列表的长度，列表中元素的个数
  4. res = len(varlist)
  6. # count() 检测当前列表中指定元素出现的次数
  7. res = varlist.count('张学友')
  9. # append() 向列表的尾部追加新的元素，返回值为 None
  10. varlist.append('川哥')
  12. # insert() 可以向列表中指定的索引位置添加新的元素，
  13. varlist.insert(20,'aa')
  16. # pop() 可以对指定索引位置上的元素做 出栈 操作，返回出栈的元素
  17. res = varlist.pop() # 默认会把列表中的最后一个元素 出栈
  18. res = varlist.pop(2) # 会在列表中把指定索引的元素进行 出栈
  20. varlist = [1,2,3,4,11,22,33,44,1,2,3,4]
  21. # remove() 可以指定列表中的元素 进行 删除,只删除第一个。如果没有找到，则报错
  22. res = varlist.remove(1)
  24. # index() 可以查找指定元素在列表中第一次出现的索引位置
  25. # res = varlist.index(1)
  26. # res = varlist.index(1,5,20) # 可以在指定索引范围内查找元素的索引位置
  28. # extend() 接收一个容器类型的数据，把容器中的元素追加到原列表中
  29. # varlist.extend('123')
  31. # s.clear() # 清空列表内容
  32. # varlist.clear()
  35. # reverse() 列表翻转
  36. varlist.reverse()
  38. # sort() 对列表进行排序
  39. res = varlist.sort() # 默认对元素进行从小到大的排序
  40. res = varlist.sort(reverse=True) # 对元素进行从大到小的排序
  41. res = varlist.sort(key=abs) # 可以传递一个函数，按照函数的处理结果进行排序

深拷贝与浅拷贝

浅拷贝

浅拷贝只能拷贝列表中的一维元素，如果列表中存在二维元素或容器，则引用而不是拷贝 使用cpoy函数或者copy模块中的copy函数拷贝的都是浅拷贝

  1. # 浅拷贝 只能拷贝当前列表，不能拷贝列表中的多维列表元素
  3. varlist = [1,2,3]
  4. # 简单的拷贝 就可以把列表复制一份
  5. newlist = varlist.copy()
  6. # 对新拷贝的列表进行操作，也是独立的
  7. del newlist[1]
  8. # print(varlist,id(varlist))
  9. # print(newlist,id(newlist))
  10. '''
  11. [1, 2, 3] 4332224992
  12. [1, 3] 4332227552
  13. '''
  15. # 多维列表
  16. varlist = [1,2,3,['a','b','c']]
  18. # 使用copy函数 拷贝一个多维列表
  19. newlist = varlist.copy()
  21. '''
  22. print(newlist,id(newlist))
  23. print(varlist,id(varlist))
  24. [1, 2, 3, ['a', 'b', 'c']] 4361085408
  25. [1, 2, 3, ['a', 'b', 'c']] 4361898496
  26. '''
  27. # 如果是一个被拷贝的列表，对它的多维列表元素进行操作时，会导致原列表中的多维列表也发生了变化
  28. del newlist[3][1]
  30. '''
  31. 通过id检测，发现列表中的多维列表是同一个元素（对象）
  32. print(newlist[3],id(newlist[3]))
  33. print(varlist[3],id(varlist[3]))
  34. ['a', 'c'] 4325397360
  35. ['a', 'c'] 4325397360
  36. '''

深拷贝

深拷贝就是不光拷贝了当前的列表，同时把列表中的多维元素或容器也拷贝了一份，而不是引用 使用copy模块中的 deepcopy 函数可以完成深拷贝

  1. # 深拷贝 就是不光拷贝了当前的列表，同时把列表中的多维元素也拷贝了一份
  2. import copy
  4. varlist = [1,2,3,['a','b','c']]
  6. # 使用 copy模块中 深拷贝方法 deepcopy
  7. newlist = copy.deepcopy(varlist)
  8. del newlist[3][1]
  10. print(varlist)
  11. print(newlist)
  13. '''
  14.     print(newlist[3],id(newlist[3]))
  15.     print(varlist[3],id(varlist[3]))
  16.     ['a', 'c'] 4483351248
  17.     ['a', 'b', 'c'] 4483003568
  18. '''

列表推导式

List-Comprehensions 列表推导式提供了一个更简单的创建列表的方法。 常见的用法是把某种操作应用于序列或可迭代对象的每个元素上，然后使用其结果来创建列表，或者通过满足某些特定条件元素来创建子序列。 采用一种表达式的当时，对数据进行过滤或处理，并且把结果组成一个新的列表

一，基本的列表推到式使用方式

结果变量 = [变量或变量的处理结果 for 变量 in 容器类型数据]

示例：

  1. # 1 假设我们想创建一个平方列表
  3. # 使用普通方法完成
  4. varlist = []
  5. for i in range(10):
  6.     varlist.append(i**2)
  7. # print(varlist)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  9. # 使用 map函数和list完成
  10. varlist = list(map(lambda x: x**2, range(10)))
  11. # print(varlist)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  13. # 使用列表推到式完成 下面这个列表推到式和第一种方式是一样的
  14. varlist = [i**2 for i in range(10)]
  15. # print(varlist)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  17. # 2。 '1234' ==> [2,4,6,8]
  18. # 常规方法完成需求
  19. varstr = '1234'
  20. newlist = []
  21. for i in varstr:
  22.     newlist.append(int(i)*2)
  23. # print(newlist)  # [2, 4, 6, 8]
  25. # 使用列表推到式完成上面的需求
  26. newlist = [int(i)*2 for i in varstr]
  27. # print(newlist)  # [2, 4, 6, 8]
  29. # 使用列表推到式+位运算完成
  30. newlist = [int(i) << 1 for i in varstr]
  31. # print(newlist)  # [2, 4, 6, 8]

二，带有判断条件的列表推到式

结果变量 = [变量或变量的处理结果 for i in 容器类型数据 条件表达式]

示例：

  1. # 0-9 求所有的偶数，==> [0, 2, 4, 6, 8]
  2. # 常规方法完成
  3. newlist = []
  4. for i in range(10):
  5.     if i % 2 == 0:
  6.         newlist.append(i)
  7. # print(newlist) # [0, 2, 4, 6, 8]
  9. # 列表推到式完成
  10. newlist = [i for i in range(10) if i % 2 == 0]
  11. # print(newlist)  # [0, 2, 4, 6, 8]

三，对于嵌套循环的列表推到式

  1. '''
  2. # 下面这个 3x4的矩阵，它由3个长度为4的列表组成，交换其行和列
  3. [
  4.  [1, 2, 3, 4],
  5.  [5, 6, 7, 8],
  6.  [9, 10, 11, 12],
  7. ]
  9. ==>
  10. [
  11.     [1, 5, 9], 
  12.     [2, 6, 10], 
  13.     [3, 7, 11], 
  14.     [4, 8, 12]
  15. ]
  16. '''
  17. arr = [
  18.  [1, 2, 3, 4],
  19.  [5, 6, 7, 8],
  20.  [9, 10, 11, 12],
  21. ]
  23. # 常规方法完成
  24. # newlist = []
  25. # for i in range(4):
  26. #     res = []
  27. #     for row in arr:
  28. #         res.append(row[i])
  29. #     newlist.append(res)
  30. # print(newlist)
  32. # 使用列表推到式完成
  33. newlist = [[row[i] for row in arr] for i in range(4)]
  34. print(newlist)