Python基础（四）

今日主要内容

• 列表
  • 增
  • 删
  • 改
  • 查
  • 列表嵌套
• 元组
• range

一、列表（list）

（一）什么是列表

• 列表是一个容器，可以存储大量不同数据类型的数据
• 列表中以逗号分隔的称为元素
• 列表是可变类型数据，可迭代数据类型，有序的数据结构
• 列表用[]表示

（二）列表的增

• 列表添加元素时，内存的变化

  

• list.append()	末尾添加
  list.insert()	指定位置插入
  list.extend()	迭代添加

1. list.append()

   • 在列表的末端添加元素

   lst = ["炭烧鸡肉", "咖喱鸡排", "黄焖鸡"]
   lst.append("浓香面")
   print(lst)  # ['炭烧鸡肉', '咖喱鸡排', '黄焖鸡', '浓香面']
   

2. list.insert()

   • 在指定位置插入元素
   • 尽量少用——元素的插入会影响整个列表，造成不必要的损耗

   lst = ["炭烧鸡肉", "咖喱鸡排", "黄焖鸡"]
   lst.insert(1, "浓香面")
   print(lst)  # ['炭烧鸡肉', '浓香面', '咖喱鸡排', '黄焖鸡']
   

3. list.extend()

   • 迭代添加元素

   lst = ["炭烧鸡肉", "咖喱鸡排", "黄焖鸡"]
   lst.extend(["浓香面", "卤肉饭"])
   print(lst)  # ['炭烧鸡肉', '咖喱鸡排', '黄焖鸡', '浓香面', '卤肉饭']
   

（三）列表的删

• 列表删除元素的时候，内存的变化

  

• list.pop()	从末尾弹出元素
  list.remove()	删除指定元素
  list.clear()	清空列表
  del	各种删除

1. list.pop()

   • 从列表末尾弹出元素，此方法有返回值，可以用变量接收
   • 还可以给入参数，索引删除

   lst = ["炭烧鸡肉", "咖喱鸡排", "黄焖鸡", "浓香面"]
   det = lst.pop()
   print(det)  # 浓香面
   print(lst)  # ['炭烧鸡肉', '咖喱鸡排', '黄焖鸡']
   

2. list.remove()

   • 删除指定元素，若指定元素不在列表中则会报错

   lst = ["炭烧鸡肉", "咖喱鸡排", "黄焖鸡", "浓香面"]
   lst.remove("黄焖鸡")
   print(lst)  # ['炭烧鸡肉', '咖喱鸡排', '浓香面']
   lst.remove("卤肉饭")
   print(lst)  # ValueError: list.remove(x): x not in list
   

3. list.clear()

   • 清空列表

   lst = ["炭烧鸡肉", "咖喱鸡排", "黄焖鸡", "浓香面"]
   lst.clear()
   print(lst)  # []
   

4. del

   • 各种删除

   lst = ["炭烧鸡肉", "咖喱鸡排", "黄焖鸡", "浓香面"]
   del lst[2]
   print(lst)  # ['炭烧鸡肉', '咖喱鸡排', '浓香面']
   
   del lst[:2]
   print(lst)  # ['浓香面']
   
   del lst
   print(lst)  # NameError: name 'lst' is not defined  # 直接删除列表
   

（四）列表的改

• 列表修改元素的时候，内存的变化

  

1. 通过下标索引修改列表

   lst = ["炭烧鸡肉", "咖喱鸡排", "黄焖鸡", "浓香面"]
   lst[2] = "卤肉饭"
   print(lst)  # ['炭烧鸡肉', '咖喱鸡排', '卤肉饭', '浓香面']
   

2. 通过切片修改列表

   • 注意：使用切片时，获取的就是原数据本身
   • 切片获取的部分是连续的时候，修改的内容可多可少

   lst = ["炭烧鸡肉", "咖喱鸡排", "黄焖鸡", "浓香面"]
   lst[1:3] = ["卤肉饭"]
   print(lst)  # ['炭烧鸡肉', '卤肉饭', '浓香面']
   

   • 切片获取的部分是不连续的时候，修改的内容必须一一对应，不然会报错

   lst = ["炭烧鸡肉", "咖喱鸡排", "黄焖鸡", "浓香面"]
   lst[1::2] = ["卤肉饭", "梅菜扣肉"]
   print(lst)  # ['炭烧鸡肉', '卤肉饭', '黄焖鸡', '梅菜扣肉']
   
   lst[1::2] = ["卤肉饭"]
   print(lst)
   # ValueError: attempt to assign sequence of size 1 to extended slice of size 2
   

（五）列表的查

1. 通过for循环遍历查看

   lst = ["炭烧鸡肉", "咖喱鸡排", "黄焖鸡", "浓香面"]
   for el in lst:
   	print(el, end=" ")  # 炭烧鸡肉 咖喱鸡排 黄焖鸡 浓香面 
   

2. 通过列表索引查看

   lst = ["炭烧鸡肉", "咖喱鸡排", "黄焖鸡", "浓香面"]
   print(lst[0])  # 炭烧鸡肉
   print(lst[1])  # 咖喱鸡排
   print(lst[2])  # 黄焖鸡
   print(lst[3])  # 浓香面
   

3. list.index(n)

   • 查找列表中元素的索引值，如果列表中没有此元素，会报错

   lst = ["炭烧鸡肉", "咖喱鸡排", "黄焖鸡", "浓香面"]
   index = lst.index("浓香面")
   print(index)  # 3
   
   index = lst.index("卤肉饭")
   print(index)  # ValueError: '卤肉饭' is not in list
   

（六）列表嵌套

• 核心思想：利用降维，一层一层的看

  lst = ["睡觉", "学习", ["吃饭", ["炭烧鸡肉", "酸梅汤"]], "运动"]
  # 获取"炭烧鸡肉"
  lst1 = lst[2]
  lst2 = lst1[1]
  lst3 = lst2[0]
  print(lst3)  # 炭烧鸡肉
  
  print(lst[2][1][0])  # 炭烧鸡肉  # 利用降维，一层一层的看
  

二、元组（tuple）

（一）什么是元组

• 元组就是一个不可变的列表
• 元组是不可变类型数据，可迭代数据类型，有序的数据结构
• 元组用()表示

（二）元组的不可变

• 元组的不可变不是绝对的

• 元组的不可变只得是元组本身和元素的数据类型不可变，而元素可不可变取决于元素是否是可变数据类型

  tu = (123, "123", [1,2,3])
  tu[2].append(4)
  print(tu)  # (123, '123', [1, 2, 3, 4])
  

（三）元组的方法

• 因为元组是不可变数据类型，不支持增删改，所以元组的方法并不多

• tu.count()	计算元素在元组中出现的次数
  tu.index()	查询元素的索引位置

1. tu.count(n)

   • 返回元素n在元组中出现的次数

   tu = (1, 2, 3, 2, 3)
   c = tu.count(2)
   print(c)  # 2
   

2. tu.index()

   • 查询元素的索引位置，如果没有该元素会报错

   tu = ("炭烧鸡肉", "咖喱鸡排", "卤肉饭", "浓香面")
   i = tu.index("卤肉饭")
   print(i)  # 2
   
   e = tu.index("炸酱面")
   print(e)  # ValueError: tuple.index(x): x not in tuple
   

（四）元组的索引和切片

• 元组是有序数据类型支持索引和切片

• 元组的切片得到的依然是元组

  tu = ("炭烧鸡肉", "咖喱鸡排", "卤肉饭", "浓香面")
  print(tu[:2])  3 ('炭烧鸡肉', '咖喱鸡排')
  

（五）元组的应用场景

1. 为了防止误操作时修改数据，元组中存放一些中重要数据
2. 配置文件中存储数据

• 来看一个面试题：

  tu = (10)  # tu是什么数据类型
  print(type(tu))  # <class 'int'>
  

  • 注意：当定义元组时，若元组中只有一个元素，一定要在元素末尾加一个逗号，否则元素为何数据类型定义的就是什么数据类型，而不是元组

  tu1 = (10)
  tu2 = ("zxdzs")
  tu3 = ("zxdzs",)
  tu4 = ()
  print(type(tu1))  # <class 'int'>
  print(type(tu2))  # <class 'str'>
  print(type(tu3))  # <class 'tuple'>
  print(type(tu4))  # <class 'tuple'>
  

三、range——范围

（一）range存在的意义

• 整型是不可迭代类型，想要循环数字怎么办？
• 可以利用range循环数字
• range是一个可迭代对象

（二）range的使用

1. 格式：

   • range(起始位置,终止位置,步长)
   • 顾头不顾腚

2. range可以直接写一个终止位置

   for el in range(5):
   	print(el, end=" ")  # 0 1 2 3 4
   

3. 若使用步长必须添加起始位置

   for el in range(0, 5, 2):
   	print(el, end=" ")  # 0 2 4
   

（三）range的方便性

• 例1：求0-50之间的所有奇数

  for i in range(1, 50, 2):
  	print(i)
  

• 例2：求0-50之间的所有偶数

  for i in range(0, 51, 2):
  	print(i)
  

• 例3：获取1-50的一个列表

  lst = list(range(51))