常用数据类型操作（三）

列表

---

• 概念：有序的 可变的 元素集合
• 定义

  1. [元素1, 元素2, 元素3, ...]
     names = ["奥特曼", "superman", "小怪兽"]
  
  2. 列表生成式
    2.1 range(stop)：[0, 1, 2, ..., stop - 1]
        nums = range(100)
        print(type(nums), nums)
  
    2.2 range(start, stop[, step])：[start, start + step, start + 2 * step, ..., < stop], step 默认值是 1
        nums = range(1, 101, 3)
        print(type(nums), nums)
  
    2.3 注意：为了防止生成的列表没有被使用, python3 做了一些改变, 不会立即生成列表
  
  3. 列表推导式
    3.1 概念：从一个 list , 推导出另外一个 list
        流程：映射解析, 一对一变更; 过滤, 从多到少
  
    3.2 语法
        (1)[表达式 for 变量 in 列表]  
           nums = [1, 3, 5, 7, 9] 
           resultList = [num ** 2 for num in nums]
           print(type(resultList), resultList)
  
        (2)[表达式 for 变量 in 列表 if 条件]
           nums = [1, 2, 3, 4, 5, 7, 8]
           resultList = [num ** 2 for num in nums if num % 2 == 0]
           print(type(resultList), resultList)
  
  4. 列表的嵌套：列表中的元素, 还可以是列表
  
  5. 注意和 C 语言数组的区别
    5.1 list 可以存放不同的数据类型
  
    5.2 int nums[] = {1, 2, 3, 4, 5}
  

• 操作
  • 增
    • append

      """
      作用：往列表中, 追加一个新的元素, 在列表的最后
      语法：l.append(object)
      参数：object, 想要添加的元素
      返回值：None
      注意：会直接修改原列表
      """
      nums = [1, 3, 5, 7, 9]
      nums.append(11)
      print(nums)
      

    • insert

      """
      作用：往列表中, 追加一个新的元素, 在指定索引前面
      语法：l.insert(index, object)
      参数：index, 索引, 到时会插入到这个索引之前; 
           object, 想要添加的元素
      返回值：None
      注意：会直接修改原列表
      """
      nums = [1, 2, 3, 4, 5]
      nums.insert(1, 8)
      print(nums)
      

    • extend

      """
      作用：往列表中, 扩展另外一个可迭代序列
      语法：l.extend(iterable)
      参数：iterable, 可迭代集合, 例如字符串, 列表, 元组, ... 
      返回值：None  
      注意：会直接修改原列表; 
      """
      numList = [1, 2, 3, 4, 5]
      strList = ["a", "b", "c"]
      charStr = "defgh"
      numList.extend(strList)
      numList.extend(charStr)
      print(numList)
      

    • 乘法运算

      nums = [1, 2, 3]
      print(nums * 3)
      

    • 加法运算

      1. 列表和列表相加
         nums = [1, 2, 3]
         numList = ["a", "b", "c"]
         print(nums + numList)
      2. 列表和元组相加
         nums = [1, 2, 3]
         num_tuple = (2, 3)
         nums += num_tuple
         print(nums)
      3. 列表和集合相加
         nums = [1, 2, 3]
         num_set = {2, 3}
         nums += num_set
         print(nums)
      

  • 删
    • del 语句

      """
      作用：可以删除一个指定元素
      语法：del 指定元素
      注意：会直接修改原列表；
           可以删除一个变量
      """
      nums = [1, 2, 3, 4, 5]
      del nums[1]
      print(nums)
      del nums
      print(nums)
      

    • pop

      """
      作用：移除并返回列表中指定索引对应元素
      语法：l.pop(index)
      参数：index, 需要被删除返回的元素索引, 默认是 -1
      返回值：被删除的元素
      注意：会直接修改原列表；
           注意索引越界
      """
      nums = [1, 2, 3, 4, 5]
      result = nums.pop(1)
      print(result, nums)
      

    • remove

      """
      作用：移除列表中指定元素
      语法：l.remove(object)
      参数：object, 需要被删除的元素
      返回值：None
      注意：会直接修改原列表; 
           如果元素不存在, 会报错; 
           如果存在多个元素, 则只会删除最左边一个; 
           注意循环内删除列表元素会导致数据异常
      """
      nums = [1, 2, 3, 4, 5]
      result = nums.remove(3)
      print(result, nums)
      

    • clear

      """
      作用：删除列表内所有元素
      语法：l.clear()
      返回值：None
      注意：列表对象本身还存在，只不过内容被清空
      """
      num_list = [1, 3, 5, 7, 9]
      remove_item = num_list.clear()
      print(remove_item, num_list)
      

  • 改

    """
    注意：当想要操作一个列表当中的某个元素时, 一定是通过这个索引, 来操作指定元素
    """
    nums = [1, 2, 3, 4, 5]
    nums[3] = 5
    print(nums) 
    

  • 查
    • 获取单个元素

      """
      items[index], 注意负索引
      """
      nums = [1, 3, 5, 7, 9]
      print(nums[2])
      print(nums[-1])
      

    • 获取指定元素索引

      """
      index(value, [start, [stop]])
      """
      nums = [1, 2, 3, 4, 5, 7, 5, 6, 6]
      idx = nums.index(5, 5)
      print(idx)
      

    • 获取指定元素个数

      """
      count(object)
      """
      nums = [1, 2, 3, 4, 5, 7, 5, 6, 6]
      c = nums.count(5)
      print(c)
      

    • 获取多个元素

      """
      items[start:end:step]
      """
      nums = [3, 4, 5, 6, 5, 7, 55, 5, 8, 9]
      pic = nums[1:7:2]
      pic = nums[::-1]
      print(pic)
      

    • 遍历操作

      1. 根据元素进行遍历
         values = ["a", "b", "c", "d", "e"]
         for item in list:
             print(item)
      
      2. 根据索引进行遍历
         values = ["a", "b", "c", "d", "e"]
         for index in range(len(values)):
             print(index, values[index])
      
      3. 遍历枚举对象
         # enumerate(sequence, [start=0]); sequence：可迭代对象; start：下标起始位置
         values = ["a", "b", "c", "d", "e"]
         print(list(enumerate(values)))
         for index, value in enumerate(values):
             print(index, value)
      
      4. 迭代器
         values = ["a", "b", "c", "d", "e"]
         for item in iter(values):
             print(item)
      

  • 判定

    1. 元素 in 列表
    2. 元素 not in 列表
    values = [1, 2, 3, 4, 5]
    print(15 in values)
    print(2 not in values)
    

  • 比较
    • cmp

      """
      Python2.x：针对每个元素，从左到右逐一比较
      list1 < list2 ：-1
      list1 == list2：0
      list1 > list2：1
      """
      result = cmp("1ab", "1ac")
      result = cmp([1, 2, 4], [1, 2, 2])
      print result
      

    • 运算符

      """
      Python3.x：针对每个元素，从左到右逐一比较
      <
      ==
      >
      """
      result = [2, 3, 3] < [2, 3, 4]
      print(result)
      

  • 排序
    • sorted

      """
      内建函数：可以对所有可迭代对象进行排序
      语法：sorted(iterable, key=None, reverse=False)
      参数：iterable, 可迭代对象; 
           key, 排序关键字, 值为一个函数，此函数只有一个参数且返回一个值用来进行比较; 
           reverse, 控制升序和降序, 默认 False, 升序
      返回值：一个已经排好序的列表, 列表类型
      """
      def getKey(x):
          return x[1]
      numList = [1, 4, 3, 2, 5, 6]
      result = sorted(numList)
      result = sorted(numList, reverse=True)
      tupleList = [("wx", 18), ("wx2", 16), ("wx1", 17), ("wx3", 15)]
      resultList = sorted(tupleList)
      resultList = sorted(tupleList, key=getKey)
      resultList = sorted(tupleList, key=getKey, reverse=True)
      print(resultList)
      

    • 列表对象方法

      """
      使用作用：同 sorted() 一样
      """
      def getKey(x):
          return x[1]
      l = [1, 3, 2, 5, 6, 4, 8, 7]
      res = l.sort(reverse=True)
      print(res, l)
      tupleList = [("wx", 18), ("wx2", 16), ("wx1", 17), ("wx3", 15)]
      res = tupleList.sort(key=getKey)
      print(res, tupleList)
      

  • 乱序

    """
    作用：可以随机打乱一个列表
    """
    import random
    l = [1, 2, 3, 4, 5]
    res = random.shuffle(l)
    print(res, l)
    

  • 反转

    l = ["a", "c", "d", "b", "f", "e"]
    res = l.reverse()
    # 切片反转
    res = l[::-1]
    print(res, l)
    

  • 拆包

    a = 66
    b = 88
    l = [a, b]
    b, a = l
    print(a, b)
    

---