Topic 2

Topic 2 目录

1. Python 内建数据结构概览
2. List（列表）
   - 列表特性
   - 创建方法、访问方式、修改方式
   - 添加、插入、删除、排序、遍历
   - 方法总表
   - 例子逐行解释
3. Tuple（元组）
   - 特性、创建、访问
   - 不可变性质、如何绕开不可变
   - 常用方法
   - 例子解释
4. Dictionary（字典）
   - 特性、键值对访问
   - keys, values, items
   - 修改、增加、删除
   - 嵌套字典
   - 字典推导式
   - 例子解释
5. Set（集合）
   - 特性、唯一性、无序性
   - 添加、合并、更新
   - 集合的数学操作（并、交、差）
   - 例子解释
6. 四种数据结构总结对比

---

1️⃣ Python 内建数据结构概览

Python 提供四种常用数据结构，用来存储多个数据元素：

数据结构	符号	是否有序	是否可修改	是否可重复	特点
List	[]	✔ 有序	✔ 可修改	✔ 可重复	使用最广，灵活
Tuple	()	✔ 有序	✘ 不可修改	✔ 可重复	安全、快速
Dictionary	{key:value}	✔（3.7 后有序）	✔ 可修改	✘ 键不可重复	键值对存储
Set	{}	✘ 无序	✔ 可修改	✘ 不可重复	自动去重、集合操作

---

2️⃣ List（列表）

✔ 列表特性

• 使用 [] 创建
• 可以包含不同类型的元素
• 有序（保持插入顺序）
• 可修改：增删改都可以
• 可以有重复元素

---

➤ 列表的创建

fruits = ["apple", "banana", "cherry", "durian"]
mixed = ["apple", 2, "cherry"]

分析：

• fruits 是字符串列表
• mixed 是混合类型列表（Python 允许）

---

➤ 列表访问（索引）

fruits = ["apple", "banana", "cherry", "durian"]
print(fruits[0])      # apple
print(fruits[1])      # banana
print(fruits[-1])     # durian（倒数第一）
print(fruits[1:3])    # ["banana", "cherry"]
print(fruits)         # ['apple', 'banana', 'cherry', 'durian']
print(fruits[:])      # ['apple', 'banana', 'cherry', 'durian']
print(fruits[])      # 报错

解释：

• fruits[1]：第二个元素
• fruits[-1]：最后一个元素
• fruits[1:3]：切片，从 1 到 2（不含 3）

如果想打印列表的所有内容，但不要方括号 []，有几种常用方法：

方法 1：用 join()（最常用、最优雅）

join() 要求列表中是 字符串，刚好你的水果都是字符串。

fruits = ["apple", "banana", "cherry", "durian"]print(" ".join(fruits))

输出：

apple banana cherry durian

如果想用逗号：

print(", ".join(fruits))

输出：

apple, banana, cherry, durian

方法 2：用 print(*fruits)（最简单的方法）

print(*列表) 会自动把列表拆开来打印，不带括号、不带逗号。

print(*fruits)

输出：

apple banana cherry durian

你可以换分隔符：

print(*fruits, sep=", ")

输出：

apple, banana, cherry, durian

方法 3：循环打印

for f in fruits:print(f)

输出（每行一个）：

apple
banana
cherry
durian

---

➤ 检查元素是否存在

if "cherry" in fruits:print("'cherry' is in the fruits list")

---

➤ 添加与插入

fruits.append("orange")     # 末尾添加
fruits.insert(1, "pineapple")  # 在位置 1 插入

第一行：创建列表

fruits = ["apple", "banana", "cherry", "durian"]

含义：
创建一个名为 fruits 的列表，里面有 4 个字符串：

["apple", "banana", "cherry", "durian"]

第二行：fruits.append("orange")

fruits.append("orange")

含义：
append() 会 把元素添加到列表的最末尾。

执行后，列表变为：

["apple", "banana", "cherry", "durian", "orange"]

特点：

• append() 只能添加一个元素
• 永远添加到最后

第三行：fruits.insert(1, "pineapple")

fruits.insert(1, "pineapple")

含义：
insert(索引, 元素) → 把 "pineapple" 插入到 索引 1（第二个位置）。

执行所有代码后 fruits列表等于：

['apple', 'pineapple', 'banana', 'cherry', 'durian', 'orange']

原来索引 1 的 "banana" 会自动往后移动。

---

➤ 修改元素

fruits[1] = "orange"   # 替换一个
fruits[1:3] = ["pineapple", "orange"]  # 替换两个
fruits[1:2] = ["mango", "peach"] # 用两个替换一个

1. fruits[1] = "orange" —— 替换一个元素

fruits = ["apple", "banana", "cherry", "durian"]fruits[1] = "orange"

含义：

• 访问索引 1（即第二个元素 "banana"）
• 用 "orange" 替换它

修改后：

["apple", "orange", "cherry", "durian"]

2. fruits[1:3] = ["pineapple", "orange"] —— 替换两个元素

fruits = ["apple", "banana", "cherry", "durian"]fruits[1:3] = ["pineapple", "orange"]

含义：

• 切片 1:3 → 包含索引 1 和 2，即：
  ["banana", "cherry"]
• 用 ["pineapple", "orange"] 替换这两个

修改后：

["apple", "pineapple", "orange", "durian"]

✔ 左右数量相同；
✔ 列表长度不变。

3. fruits[1:2] = ["mango", "peach"] —— 用多个替换一个

fruits = ["apple", "banana", "cherry", "durian"]fruits[1:2] = ["mango", "peach"]

含义：

• 切片 1:2 → 只包含索引 1（即 "banana"）
• 用两个元素 ["mango", "peach"] 替换它

修改后：

["apple", "mango", "peach", "cherry", "durian"]

✔ 用 2 个替换 1 个
✔ 列表长度增加 1
✔ 切片赋值可以改变列表长度！

总结对比

代码	修改方式	列表长度变化
fruits[1] = "orange"	替换单个元素	不变
fruits[1:3] = ["pineapple", "orange"]	两个替换两个	不变
fruits[1:2] = ["mango", "peach"]	两个替换一个	增加

---

1. 列表排序（sort）

• 数字：从小到大

• 字符串：按字典序（Unicode），从a到z。先比第 1 个字符，相同再比第 2 个，不同字母按 Unicode 编码比较

• 大写字母优先级高于小写字母（因为 ASCII 值小）

• 不同类型无法比较

✔ 1.1 从 A → Z 排序（默认）

会按照字母顺序排序。

例子：

fruits = ["banana", "apple", "durian", "cherry"]
fruits.sort()
print(fruits)

输出：

['apple', 'banana', 'cherry', 'durian']

1.2 反向排序（Z → A）

fruits.sort(reverse=True)

输出：

['durian', 'cherry', 'banana', 'apple']

1.3 按 key 排序（高级功能）

例如按字符串长度排序：

fruits.sort(key=len)

输出：

['apple', 'banana', 'cherry', 'durian']   # 按长度从短到长

反向：

fruits.sort(key=len, reverse=True)

1.4 sort() 会修改原列表！

如果你想保留原列表，用 sorted()：

new_list = sorted(fruits)

---

2. 列表合并 extend

2.1 extend 的作用

把 local_fruits 的所有元素展开后加入到 fruits 末尾。

例：

fruits = ["apple", "banana"]
local_fruits = ["cherry", "durian"]
fruits.extend(local_fruits)
print(fruits)

输出：

['apple', 'banana', 'cherry', 'durian']

extend() 会修改原列表。

2.2 extend vs append 的区别（最重要）

a.append(b)    # 把整个 b 当作一个元素加入
a.extend(b)    # 把 b 的元素展开加入

例：

a = [1, 2]
b = [3, 4]a.append(b)
print(a)

输出：

[1, 2, [3, 4]]

再看 extend：

a = [1, 2]
a.extend([3, 4])
print(a)

输出：

[1, 2, 3, 4]

---

2.3 其他合并写法（你可以选择）

fruits = fruits + local_fruits    # 返回一个新列表
fruits += local_fruits            # 就地扩展（类似 extend）

---

3. 删除元素 remove / pop

原例：

fruits.remove("cherry")  # 按值删
fruits.pop(2)            # 按索引删除

3.1 remove(value)删除

删除第一个匹配的值

fruits.remove("banana")

如果有多个相同的值，只删第一个。

remove 删除不存在的值会报错

fruits.remove("watermelon")

会报：

ValueError: list.remove(x): x not in list

3.2 pop(index)删除

根据索引删除并返回删除的元素

deleted = fruits.pop(2)
print("删除了:", deleted)

输出：

删除了: cherry

---

不写 index → 默认删除最后一个

fruits.pop()

---

pop 超出索引会报错

fruits.pop(100)

错误：

IndexError: pop index out of range

---

pop 会返回删除的值

1️. 取出并处理某个元素
从列表中“拿出来”某个元素并立即处理，而不是仅仅删除。

numbers = [10, 20, 30, 40]
removed = numbers.pop(2)print(removed)   # 30
print(numbers)   # [10, 20, 40]

用处：

• 想得到被删除的东西
• 想要对它做进一步计算

---

2. 实现“栈（stack）”的数据结构
栈是后进先出（LIFO）结构，pop() 可用来取出栈顶元素。

stack = [1, 2, 3]
item = stack.pop()   # 默认 pop(-1)print(item)    # 3
print(stack)   # [1, 2]

如果没有“返回值”，就不能获取被弹出的元素做逻辑处理。

---

3️. 从列表移动元素到另一个列表

你想把值从一个列表取出来放到另一个列表：

source = [10, 20, 30]
target = []value = source.pop(0)   # 取出 10
target.append(value)print(target)   # [10]
print(source)   # [20, 30]

---

4️. 在循环中动态取出元素

处理队列（queue）或优先取任务时非常常见：

tasks = ["task1", "task2", "task3"]while tasks:task = tasks.pop(0)print("处理：", task)

输出：

处理： task1
处理： task2
处理： task3

如果不用返回值，你就无法知道你取出的任务是什么。

---

3.3 del 删除（补充）

del fruits[1]      # 删除索引1
del fruits[1:3]    # 删除一段

del 不返回删除的值。

---

总结

操作	功能	是否返回值	会修改原列表
sort()	排序	❌	✔
extend()	扩展列表	❌	✔
remove(value)	按值删	❌	✔
pop(index)	按索引删	✔	✔
del	按索引/切片删	❌	✔

---

✔ 列表方法总表（PDF 原文）

方法	说明
append()	尾部添加
clear()	清空列表
copy()	复制
count()	某值出现次数
extend()	合并列表
index()	找到值的位置
insert()	插入
pop()	删除并返回元素
remove()	删除指定值
reverse()	反序
sort()	排序

---

⭐ Finger Exercise – 例子解释

代码：

fruits = []for _ in range(3):fruits.append(input("Name a fruit: "))print(fruits)for fruit in sorted(fruits):print(fruit)

逐行解释：

• fruits = [] 建立空列表
• for _ in range(3)：循环 3 次；_ 表示不关心变量名
• 每次 input() 获取用户输入并放入列表
• sorted() 返回排序后的新列表
• 最后逐行打印水果名

前面有提到不同类型不能比较，会报错，但是如果我这个程序分别输入 1 2 A，还是可以比较

关键原因：input() 的返回值永远是字符串 str

用户输入：

1

实际上执行：

fruits.append("1") 		# append了 "1" 这个字符

输入：

1
2
A

fruits列表内容实际上是：

fruits = ["1", "2", "A"]

全部是字符串类型，同类型之间当然可以排序，所以不会报错。

那排序结果是什么？

按照字符串的排序规则（字典序 / Unicode）：

字符的 ASCII 值比较顺序：

"A" = 65
"1" = 49
"2" = 50

所以顺序从小到大：

1  (ASCII 49)
2  (ASCII 50)
A  (ASCII 65)

结果：

["1", "2", "A"]

打印时：

1
2
A

---

3️⃣ enumerate() 函数

将列表变成 “(索引, 值)” 形式的可迭代对象。

例子：

fruits = ["apple", "banana", "cherry"]
enu_fruits = enumerate(fruits, 10)for index, item in enu_fruits:print(index)print(item)

解释：

• enumerate(fruits, 10)：从索引 10 开始
• 每轮循环返回 (index, value)
• 输出：

10 apple
11 banana
12 cherry

---

4️⃣ List Comprehension（列表推导式）

普通写法：

new_list = []
for x in fruits:if "a" in x:new_list.append(x)

推导式：

new_list = [x for x in fruits if "a" in x]

---

5️⃣ Tuple（元组）

特性

• 使用 ()
• 不可修改（immutable）
• 可包含不同类型
• 访问方式与列表一样

例子：

fruits = ("apple", "banana", "cherry", "banana")

---

➤ 常用方法

fruits.count("banana")
fruits.index("banana")

---

➤ 元组不可变，但可绕过：

this_tuple = ("apple", "banana", "cherry")
y = list(this_tuple)   # 转列表
y.remove("apple")
this_tuple = tuple(y)  # 转回元组

---

6️⃣ Dictionary（字典）

➤ 基本用法

car = {"brand": "BYD", "model": "SEAL", "year": 2024}
print(car["model"])

---

➤ 查看 keys、values、items

car.keys()
car.values()
car.items()

---

➤ 修改、增加

car["year"] = 2025
car["color"] = "RED"

---

➤ 删除

car.pop("model")

---

➤ 嵌套字典

cars = {"car_1": {"brand": "Toyota", "model": "Corolla", "year": 2010},"car_2": {"brand": "Mazda",  "model": "CX5",     "year": 2018}
}print(cars["car_1"]["model"])

---

➤ 字典推导式

fruits = ["apple", "banana", "cherry"]
fruit_lengths = {fruit: len(fruit) for fruit in fruits}

---

7️⃣ Set（集合）

特性

• {} 表示
• 无序、不重复
• 自动去重

例子：

this_set = {"apple", "banana", "cherry", "banana"}

输出将自动去掉重复值。

---

➤ 集合运算

Set_1 = {1, 2, 3, 4}
Set_2 = {2, 3, 5, 6}Set_1 | Set_2   # 并集
Set_1 & Set_2   # 交集
Set_1 - Set_2   # 差集

---

最终总结对比

数据结构	优点	缺点	典型用途
List	灵活，可改，可重复	操作速度比 tuple 慢	收集任意数据
Tuple	不可变、安全、快	不能改	配置、固定数据
Dictionary	键值对结构清晰	键必须唯一	表示对象、资料结构
Set	自动去重、数学集合	无序、不能索引	唯一值、交并差