013.Python基础语法_列表操作

我 的 个 人 主 页： 失心疯的个人主页
入 门 教 程 推 荐 ： Python零基础入门教程合集
虚 拟 环 境 搭 建 ： Python项目虚拟环境(超详细讲解)
PyQt5 系 列 教 程： Python GUI(PyQt5)文章合集
Oracle数据库教程： Oracle数据库文章合集
优 质 资 源 下 载 ： 资源下载合集

列表操作

概念

• 有序的可变的元素集合

定义

• 方式一

  变量 = [元素1, 元素2, ...]
  变量 = list()
  

• 方式二
• 列表生成式

  变量 = range(start, end, step)
  
  nums = range(1, 99999)
  # 在python2中会直接生成一个[1, 2,...99998]的列表，耗费内存
  # 在python3中只会直接生成一个range(1, 99999)的生成器，节约内存。用一个生成一个
  

• 列表推导式（从一个列表list推到出另一个列表list）

  映射解析（两个列表中元素个数一对一变更）
  变量 = [表达式 for 变量1 in 原列表]
  
  # 示例
  nums = [1, 2, 3, 4, 5]
  # 列表推导式生成一个nums元素乘方的新列表
  resultlist = [num ** 2 for num in nums]
  
  
  过滤（推导出来的列表元素个数不等于原列表的元素个数）
  变量 = [表达式 for 变量1 in 原列表 if 条件]
  
  # 示例
  nums  = [1, 2, 3, 4, 5]
  # 利用列表推导式生成一个nums中奇数的乘方的新列表
  resultlist1 = [num ** 2 for num in nums if num % 2 != 0]
  # 上面推导式相当于下面
  for num in nums:
  	if num % 2 !=0:
  		resultlist1 = num ** 2
  
  resultlist2 = [num ** 2 for num in nums for num2 in nums]
  # 上面推导式相当于下面
  for num in nums:
  	for num2 in nums:
  		resultlist2 = num ** 2
  

• 列表的嵌套
  • 列表作为元素添加到另一个列表中
  • 变量 = [[‘张三’, ‘李四’, ‘王五’, ‘赵六’], [28, 32, 44, 65],…]

列表常规操作

增

• 增：列表增加（添加）元素
• append()

  分类
      对象方法
  作用
      在列表的最后追加一个新的元素
  语法
      list.append(object)
  参数
      object：想要追加的元素
  返回值
      返回None，直接修改原列表
  

• insert()

  分类
      对象方法
  作用
      在列表指定索引的前面插入一个新的元素
  语法
      list.insert(index, object)
  参数
      index：指定索引
      object：想要插入的元素
  返回值
      返回None，直接修改原列表
  

• extend()

  分类
      对象方法
  作用
      将一个可迭代序列中的元素全部追加到原列表中
  语法
      list.extend(iterable)
  参数
      iterable：可迭代序列（集合、字符串、列表、元组等）
  返回值
      返回None，直接修改原列表
  

• 乘法运算

  作用
      使列表中的元素重复指定
  语法
      list * n
  返回值
      返回一个新列表,新列表元素是原列表元素重复n次
  

• 加法运算

  作用
      将一个列表中的元素与原列表中的元素组合在一起，生成一个新列表
  语法
      list1 + list2
  参数
      
  返回值
      返回一个新列表，新列表的元素是两个相加列表的所有元素
  

删

• del 语句

  分类
      del语句，并非方法
  作用
      删除列表中指定索引的元素
  语法
      del list[index]		# 删除指定索引位置的元素
      del list			# 删除整个列表对象
  参数
      index：索引号
  返回值
      返回None，直接修改原列表
  

• pop()

  分类
      对象方法
  作用
      移除并返回列表中指定索引位置的元素,默认移除最后一个元素
  语法
      list.pop(index=-1)
  参数
      index：索引号，默认是-1
  返回值
      返回被移除的元素，直接修改原列表
      注意索引越界，程序会报错
  

• renove()

  分类
      对象方法
  作用
      移除列表中最左侧指定元素
  语法
      list.remove(object)
  参数
      object：指定要移除的元素
  返回值
      返回None，直接修改原列表
      移除不存在的元素时，程序会报错
  

• 注意错误代码案例
  

改

• 直接通过索引号进行修改

  list[index] = new_value
  

查

• 根据索引获取元素

  list[index]
  

• 根据元素获取索引

  list.index(value, start, stop)
  

• 获取指定元素的个数

  list.count(values)
  

• 获取元素总个数

  len(list)
  

• 获取多个元素(切片)

  list[start: end: step]
  

• 枚举函数

  概念
      通过枚举函数，生成一个新的对象
  作用
      函数用于将一个可遍历的对象（列表、元组、字符串等）组合为一个索引序列，同时列出数据的索引和数据本身
  语法
      enumerate(seq, start)
  参数
      seq：可迭代对象
      start：起始索引位置
  返回值
      返回一个包含数据的索引和数据本身的序列对象
  示例
      nums = ['a', 'b', 'c', 'd', 'e', 'f']
      print(enumerate(nums))
      print(list(enumerate(nums))
      
      # ----输出结果----
      # enumerate(nums)
      <enumerate object at 0x0000014CED186840>
      
      # list(enumerate(nums) 将enumerate转换成列表
      [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (4, 'e'), (5, 'f')]
      
  

• 遍历查询
  • 根据元素进行遍历

  for 变量 in list:
      循环操作执行代码
  

  • 根据索引进行遍历

  for 变量 in range(len(list)):
      循环操作执行代码
  

  • 遍历枚举对象

  for 变量1, 变量2 in enumerate(list, start):
      循环操作执行代码
      
  # 变量1存储的是列表的索引
  # 变量2存储的是列表的元素
  

  • 使用迭代器进行遍历

  for 变量 in iter(list):
      循环操作执行代码
  

补充：迭代器

• 迭代
  • 访问集合元素的一种方式，按照某种顺序逐个访问集合中的每一项
• 可迭代对象
  • 能够被迭代的对象
• 可迭代对象判定依据
  • 能作用于 for…in 的对象
• 可迭代对象判定方法

  import collections
  
  isinstance(obj, collections.Iterable)
  
  # 判断obj对象是否有collections.Iterable（可迭代）特性
  

• 迭代器
  • 是可以记录遍历位置的对象，从第一个元素开始，往后通过next()函数进行遍历
  • 只能往后，不能往前
• 迭代器判定依据
  • 能作用于next()函数
• 迭代器判断方法

  import collections
  
  isinstance(obj, collections.Iterator)
  
  # 判断obj对象是否有collections.Iterator特性
  

• 迭代器也是可迭代对象，所以也可以作用于for…in
• 为什么会产生迭代器
  • 仅仅在迭代到某个元素时，才处理该元素(节约内存空间)
    • 在此之前，元素可以不存在
    • 在此之后，元素可以被销毁
    • 特别适合用于遍历一些巨大的或是无线的结合（如：斐波那契数列）
  • 提供了一个统一的访问集合的接口
    • 可以把所有的可迭代对象转换成迭代器使用

    iter(Iterable)
    
    iter(str)
    iter(list)
    iter(tuple)
    iter(dict)
    .
    .
    .
    

• 迭代器的简单使用
  • 使用next()函数移动指针，从迭代器中取出下一个对象，从第一个元素开始
    • 如果取出完毕了，再继续next()取，会报错StopIteration
  • 迭代器比较常用，在python中，可以直接作用于for…in
    • 内部会自动调用迭代器对象的next()
    • 会自动处理迭代完毕的错误
  • 注意事项
    • 迭代器的原始如果取出完毕了，再继续next()取，会报错StopIteration
    • 迭代器一般不能多次迭代（迭代完了，指针则指向了末尾，指针并不会回到开始位置，所以无法再次迭代）
• 示例

  # 迭代器
  nums = ['a', 'b', 'c', 'd', 'e', 'f']
  
  # 生成一个迭代器
  it = iter(nums)
  
  # print(next(it))  # ---> a
  # print(next(it))  # ---> b
  # print(next(it))  # ---> c
  # print(next(it))  # ---> d
  # print(next(it))  # ---> e
  
  for v in it:
      print(v)
  
  # 输出所有元素
  print('=============')
  
  for v in it:
      print(v)
  
  # 没有输入任何内容，因为迭代器不会被多次迭代
  # 迭代完毕后指针已经指向迭代器末尾
  

判定

• 判定某个对象是否在列表中

  # 判定原始是否在列表中
  元素 in 列表
  
  # 示例
  nums = ['a', 'b', 'c']
  print('b' in nums)    # ---> True
  print('e' in nums)    # ---> False
  
  # 判断元素是否不在列表中
  元素 not in 列表
  
  # 示例
  nums = ['a', 'b', 'c']
  print('b' not in nums)    # ---> False
  print('e' not in nums)    # ---> True
  

比较

• 在python2中使用 cmp() 函数

  作用
      针对每个元素，从左到右逐一比较，实际比较的是元素的ASCII码
  语法
      cmp(value1, value2)
  返回值
      当左边值 > 右边值，返回1
      当左边值 = 右边值，返回0
      当左边值 < 右边值，返回-1
  示例
      cmp(1, 2)   # ---> -1
      cmp(5, 3)   # ---> 1
      
      cmp([1, 2, 3], [2, 3])  # ---> -1
      # 分析：两个列表元素从左往右进行逐一比较：第一个元素1 < 2，后面的元素则不再比较，直接返回 -1
      
      cmp([1, 2, 3], [1, 1, 5])   # ---> 1
      # 分析：两个列表元素从左往右进行逐一比较：
      第一个元素1 = 1，继续比较第二个元素 2 > 1，后面的元素则不再比较，直接返回 1
  

  • cmp()函数在python3已经不再使用
• python3中，直接使用运算符（==、>、<）进行比较

  [1, 2, 3] > [2, 3]  # ---> False
  # 分析：两个列表元素从左往右进行逐一比较：第一个元素1 < 2，后面元素不再比较，直接返回False
  
  [1, 2, 3] == [1, 2, 3]  # ---> True
  # 分析：两个列表元素从左往右进行逐一比较：全部相等，返回True
  
  

排序

• 方法一：sorted() 函数

  分类
      内置函数
  作用
      可以对所有可迭代对象进行排序
  语法
      sorted(itrearble, key=None, reverse=False)
  参数
      itrearble：可迭代对象
      key：排序关键字，值为一个函数，此函数只有一个参数且返回一个值用来进行比较
      reverse：控制升序/降序，默认False，升序
  返回值
      一个按照需求排好序的列表
  
  示例1：不带key参数，直接排序
      ls = [('失心疯1', 14), ('失心疯4', 13), ('失心疯3', 15), ('失心疯5', 12), ('失心疯2', 11)]
  
      result = sorted(ls)
      print(result)
      
      # -----输出结果-----
      [('失心疯1', 14), ('失心疯2', 11), ('失心疯3', 15), ('失心疯4', 13), ('失心疯5', 12)]
      
      # 默认按第一个元素进行排序
      
  示例2：通过key参数，进行排序
      ls = [('失心疯1', 14), ('失心疯4', 13), ('失心疯3', 15), ('失心疯5', 12), ('失心疯2', 11)]
  
      def getkey(x):
          """返回可迭代对象的第二个元素"""
          return x[1]
      
      result1 = sorted(ls, key=getkey, reverse=True)
      result2 = sorted(ls, key=getkey, reverse=False)
      
      print(result1)
      print(result2)
      
      # -----输出结果-----
      [('失心疯3', 15), ('失心疯1', 14), ('失心疯4', 13), ('失心疯5', 12), ('失心疯2', 11)]
      [('失心疯2', 11), ('失心疯5', 12), ('失心疯4', 13), ('失心疯1', 14), ('失心疯3', 15)]
      
      # 指定key参数，是通过getkey函数获取列表元素的第二个值进行排序，一个降序，一个升序
  

• 方法二：sort() 列表对象方法

  分类
      列表对象方法
  作用
      对列表元素进行排序
  语法
      list.sort(key=None, reverse=False)
  参数
      key：排序关键字，值为一个函数，此函数只有一个参数且返回一个值用来进行比较
      reverse：控制升序/降序，默认False升序
  返回值
      返回None，直接修改原列表对象
  
  示例
  
  l = [1, 4, 7, 2, 6, 3, 5]
  
  r = l.sort()
  print('r：', r)
  print('l：', l)
  
  # -----输出结果----
  r： None
  l： [1, 2, 3, 4, 5, 6, 7]
  
  
  l = [('失心疯1', 14), ('失心疯4', 13), ('失心疯3', 15), ('失心疯5', 12), ('失心疯2', 11)]
  
  def getkey2(x):
      return [1]
  
  r1 = l.sort(key=getkey, reverse=True)
  
  print('r1：', r1)
  print('l：', l)
  
  r2 = l.sort(key=getkey, reverse=True)
  print('r2：', r2)
  print('l：', l)
  
  # ----输出结果-----
  r： None
  l： [('失心疯3', 15), ('失心疯1', 14), ('失心疯4', 13), ('失心疯5', 12), ('失心疯2', 11)]
  
  r2： None
  l： [('失心疯3', 15), ('失心疯1', 14), ('失心疯4', 13), ('失心疯5', 12), ('失心疯2', 11)]
  

• sorted()与sort()的区别
  • 1、sorted()是内置函数，sort()是列表对象方法
  • 2、sorted()可以对所有可迭代对象进行排序，sort()只能对列表元素进行排序
  • 3、sorted()有返回值，不改变原对象，sort()没有返回值，直接修改原列表

乱序

• 通过random模块中的shuffle()方法，把列表内的所有元素位置随机打乱
• 注意：没有返回值，是直接修改原列表对象

  import random
  
  random.shuffle(list)
  

反转

• 方法一：reverse()

  分类
      列表对象方法
  作用
      将列表中所有元素按原顺序进行倒序排列
  语法
      list.reverse()
  参数
  
  返回值
      返回None，直接修改原列表对象
      
  示例
      l = [1, 2, 4, 5, 7, 3, 9]
      r = l.reverse()
      
      print('r：', r)
      print('l：', l)
      
      # -----输出结果-----
      r： None
      l： [9, 3, 7, 5, 4, 2, 1]
  

• 方法二：list[::-1]切片
  • 不改变原列表，返回倒序后的新列表

  l = [1, 2, 4, 5, 7, 3, 9]
  r = l[::-1]
  
  print('r：', r)
  print('l：', l)
  
  # -----输出结果-----
  r： [9, 3, 7, 5, 4, 2, 1]
  l： [1, 2, 4, 5, 7, 3, 9]