Python--数据类型（中）

1. 列表（list）

1.1 定义与特性

• 定义：有序、可变的容器，支持多种数据类型混合存储。

  user_list = ["奥力给", 98, True]
  empty_list = []  # 空列表
  

• 可变性：列表内部元素可修改，区别于字符串和元组。

  user_list[0] = "新元素"  # 直接修改
  

1.2 独有功能

示例：动态抽奖程序

import random
prizes = ["iPhone", "耳机", "现金"]
while prizes:
    winner = random.choice(prizes)
    print(f"恭喜抽中：{winner}")
    prizes.remove(winner)

1.3 公共功能

基础操作

1. 索引与切片

   my_list = ["a", "b", "c", "d"]
   print(my_list[0])      # 输出："a"
   print(my_list[1:3])    # 输出：["b", "c"]
   print(my_list[::-1])   # 输出：["d", "c", "b", "a"]
   

2. 遍历

   for item in my_list:
       print(item)
   
   # 带索引遍历
   for idx, item in enumerate(my_list):
       print(f"索引{idx} → 值{item}")
   

3. 成员检查

   if "a" in my_list:
       print("存在")
   

进阶操作

• 列表生成式：快速生成列表

  squares = [x**2 for x in range(10)]  # [0, 1, 4, ..., 81]
  

• 过滤元素：结合条件语句

  even_numbers = [x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]
  

1.4 类型转换

• 字符串/元组→列表：list()​ 转换

  s = "hello"
  list_s = list(s)  # ["h", "e", "l", "l", "o"]
  

• 其他容器→列表：

  tuple_data = (1, 2, 3)
  list_from_tuple = list(tuple_data)  # [1, 2, 3]
  

1.5 嵌套与复杂操作

• 嵌套列表：列表元素可以是任意类型，包括其他列表

  matrix = [
      [1, 2, 3],
      [4, 5, 6],
      [7, 8, 9]
  ]
  print(matrix[1][2])  # 输出：6
  

• 多维操作：修改嵌套列表中的值

  matrix[0][1] = 99  # 修改第一行第二列
  

1.6 阶段作业

基础操作题

my_list = ["alex", "WuSir", "ritian", "barry", "武沛齐"]
# 1. 追加元素
my_list.append("seven")
# 2. 插入元素
my_list.insert(1, "Tony")
# 3. 切片操作
new_my_list = my_list[0:3]

进阶操作题

# 将多维列表中的字符串元素转为大写
data = ["a", ["b", "c"], ("d", "e")]
data[1][0] = data[1][0].upper()

2. 元组（tuple）

2.1 定义与特性

• 定义：有序、不可变的容器，元素类型可混合。

  t1 = (1, "a", True)
  t2 = (1,)  # 单元素元组（必须加逗号）
  

• 不可变性：元组本身不可修改，但若元素为可变类型（如列表），其内部可修改。

  t = (1, [2, 3])
  t[1].append(4)  # 合法 → t = (1, [2, 3, 4])
  

2.2 公共功能

1. 索引与切片：类似列表

   t = ("a", "b", "c")
   print(t[1])     # "b"
   print(t[0:2])   # ("a", "b")
   

2. 遍历：

   for item in t:
       print(item)
   

3. 运算符操作：

   t1 = (1, 2) + (3, 4)  # (1, 2, 3, 4)
   t2 = ("a",) * 3        # ("a", "a", "a")
   

2.3 类型转换

• 字符串/列表→元组：tuple()​ 转换

  s = "hello"
  tuple_s = tuple(s)  # ('h', 'e', 'l', 'l', 'o')
  

2.4 嵌套与特殊场景

• 嵌套元组：元素可为其他容器

  nested = (1, [2, 3], ("a", "b"))
  nested[1][0] = 99  # 合法 → (1, [99, 3], ("a", "b"))
  

2.5 练习题与总结

核心区别

• 列表 vs 元组：

  • 列表：可变，适用于需要动态增删的场景。
  • 元组：不可变，适用于数据保护或作为字典键。

练习题

# 将字符串分割为元组
text = "qyiao|alex|eric"
parts = tuple(text.split("|"))  # ('qyiao', 'alex', 'eric')

3. 总结与作业

总结

• 可变类型：列表、字典、集合（内部可修改）。
• 不可变类型：字符串、元组、数值类型（值不可修改）。

作业答案

1. 布尔值为False的类型：

   ""      # 空字符串
   []      # 空列表
   ()      # 空元组
   

2. 运算符操作结果：

   v1 = [] or "qyiao"    # "qyiao"（空列表为False）
   v2 = [11,22] and (1,2)  # (1,2)（非空列表为True，返回最后一个值）