Python基础4

• 列表、列表的增删改查、列表的嵌套、元祖、range

1. 列表

   1. 列表的作用列表是容器型数据类型，可以包含任意类型的元素，列表中的元素是有序的，主要用于存储大量数据

2. 列表的操作

   1. 列表的创建

      list_name = ["v1","v2"......]
      #用方括号包含起来的元素组成了列表，每个元素使用，分割
      list_name = list("abcd")
      结果：
      ['a', 'b', 'c', 'd']
      #空列表创建
      list_name = []
      list_name = list()
      

   2. 列表的增加操作

      #向列表末尾追加元素
      list.append("追加的元素")
      #指定位置插入元素
      list.insert(index,value)
      #迭代着追加元素，可以用来合并列表
      list.extend(interable)
      举例：
      l1 = [1, 2, 3, "alex", "Jack"]
      l1.append("lucy")
      print(l1)
      ----------
      l1 = [1, 2, 3, "alex", "Jack"]
      l1.insert(0,'lisa')
      print(l1)
      ----------
      l1 = [1, 2, 3, "alex", "Jack"]
      l1.extend(l1)
      print(l1)
      结果：
      [1, 2, 3, 'alex', 'Jack', 'lucy']
      ----------
      ['lisa', 1, 2, 3, 'alex', 'Jack']
      ----------
      [1, 2, 3, 'alex', 'Jack', 1, 2, 3, 'alex', 'Jack']
      

   3. 列表的删除操作

      #根据索引删除元素
      list.pop(index) #如果不指定索引，默认删除最后一个元素，pop操作有返回值，返回删除的元素。
      #指定元素删除元素，如果有重复元素，默认删除从左数第一个元素
      list.remove(object)
      #清空列表
      list.clear()
      #按索引、切片删除，删除列表
      del list[start:end:length]
      举例：
      l1 = [1, 2, 3, "alex", "Jack"]
      l1.pop(0)
      print(l1)
      l1 = [1, 2, 3, "alex", "Jack"]
      l1.pop()
      print(l1)
      ----------
      l1 = [1, 2, 3, "alex", "Jack"]
      l1.remove("alex")
      print(l1)
      ----------
      l1 = [1, 2, 3, "alex", "Jack"]
      l1.clear()
      print(l1)
      ----------
      l1 = [1, 2, 3, "alex", "Jack"]
      del l1[0:3:2]
      print(l1)
      l1 = [1, 2, 3, "alex", "Jack"]
      del l1[-1:2:-1]
      print(l1)
      结果：
      [2, 3, 'alex', 'Jack']
      [1, 2, 3, 'alex']
      ----------
      [1, 2, 3, 'Jack']
      ----------
      []
      ----------
      [2, 'alex', 'jack']
      [1, 2, 3]
      

   4. 列表的修改

      #按照索引、切片修改
      list[index] = new_value
      list[start:end:length] = interable
      举例：
      l1 = [1, 2, 3, "alex", "jack"]
      l1[0] = 33
      print(l1)
      ----------
      l1 = [1, 2, 3, "alex", "jack"]
      l1[0:2] = 66, 333
      print(l1)
      ----------
      l1 = [1, 2, 3, "alex", "jack"]
      l1[::2] = 66, 333, "lucy"
      print(l1)
      结果：
      [33, 2, 3, 'alex', 'jack']
      ----------
      [66, 333, 3, 'alex', 'jack']
      ----------
      [66, 2, 333, 'alex', 'lucy']
      

   5. 列表的查询

      #按照索引、切片查询
      #for循环查询
      举例：
      l1 = [1, 2, 3, "alex", "jack"]
      for i in l1:
           print(i)
      结果：
      1
      2
      3
      alex
      jack
      

   6. 列表的嵌套

      #列表的嵌套，大列表里套小列表，其操作同正常的列表一致
      lis = [2, 30, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
      #将"tt"修改为大写"TT"
      lis[3][2][1][0] = lis[3][2][1][0].upper()
      print(lis)
      结果：
      [2, 30, 'k', ['qwe', 20, ['k1', ['TT', 3, '1']], 89], 'ab', 'adv']
      

3. 元组

   1. 元组是只读列表，也是容器类型，可存储大量数据，但是如果元组中包含可变的容器类型数据，该数据内部的元素也是可以被修改的。

      tuple = (v1,v2,.....)
      #元组是不可变列表，不能被修改，只能查看，查看方式同列表一样
      举例：
      t = (1, 2, 3, [1, 2, 3])
      -------
      t = (1, 2, 3, [1, 2, 3])
      t[-1][0] = 66
      print(t)
      结果：
      (1, 2, 3, [66, 2, 3])            
      

   2. 元组拆包

      #元组拆包，分别赋值
      a, b = (1, 3)
      print(a, b)
      结果：
      a, b = (1, 3)
      print(a, b)
      

4. range

   1. range类似于一个可自定义数字范围的数字列表(只能由数字组成),通常与for循环结合使用

      #可以指定起始结束以及步长
      range(start:end:length)
      #指定数字长度
      range(len)
      举例：
      for i in range(10):
           print(i)
      ---------
      for i in range(1, 10):
           print(i)
      结果：
      0
      1
      2
      3
      4
      5
      6
      7
      8
      9
      ---------
      1
      2
      3
      4
      5
      6
      7
      8
      9