Python 五大核心数据结构完全指南：列表(List)、字符串(String)、元组(Tuple)、集合(Set)、字典(Dictionary)

Python 核心数据结构完全指南

一、列表 (List)

1.1 定义与特点

列表是 Python 中最常用的数据容器，可以一次性存储多个元素。

定义：

列表名 = [元素1, 元素2, 元素3, ...]

例如：

s = [54, 15, 75, 108, 23, 78, 75]

特点：

• 可以存储不同类型的元素（数字、字符串、布尔值等混合存放）。
• 元素有序，排列顺序固定。
• 元素可以重复。
• 元素可以被修改（增、删、改）。
• 属于序列类型：可通过索引访问。

1.2 列表的索引

• 正向索引 ：从 0 开始，从左向右。
• 反向索引 ：从 -1 开始，从右向左。

1.3 元素的查看、修改与删除

操作	语法示例	说明
查看	s[0]	获取第一个元素
修改	s[0] = 100	将第一个元素改为100
删除	del s[3]	删除索引为3的元素

1.4 列表的切片

语法：s[start:end:step]

• start：开始索引（包含），不指定默认为 0。
• end：结束索引（不包含），不指定默认为列表长度（即取到末尾）。
• step：步长，不指定默认为 1。

示例：

s = [54, 15, 75, 108, 23, 78, 75]
print(s[1:4])    # [15, 75, 108]   （索引1~3）
print(s[:3])     # [54, 15, 75]    （开头到索引2）
print(s[3:])     # [108, 23, 78, 75]（索引3到末尾）
print(s[::2])    # [54, 75, 23, 75]  （步长为2，跳过一个取一个）

1.5 列表的常用方法

方法	作用	示例
append(x)	在列表尾部追加元素 x	s.append(10086)
insert(i, x)	在索引 i 之前插入元素 x	s.insert(0, 92)
remove(x)	移除列表中第一个匹配到的值 x	s.remove(75)
pop(i)	删除索引 i 处的元素，并返回该元素（默认删除最后一个）	s.pop(2) 或 s.pop()
sort()	对列表进行排序（要求元素类型一致）	s.sort()
reverse()	反转列表元素的顺序	s.reverse()

完整示例：

s = [54, 15, 75, 108, 23, 78, 75]

s.append(10086)          # [54, 15, 75, 108, 23, 78, 75, 10086]
s.insert(0, 92)          # [92, 54, 15, 75, 108, 23, 78, 75]
s.remove(75)             # 移除第一个75
s.pop(2)                 # 删除并返回索引2的元素
s.pop()                  # 删除并返回最后一个元素
s.sort()                 # 升序排序
s.reverse()              # 反转

---

二、字符串 (String)

2.1 定义与特点

字符串是字符的容器，用于存储文本信息。

定义：

s = "Python"
s = 'Python'
s = """多行
字符串"""

特点：

• 不可变性：一旦创建，无法修改（所有"修改"操作实际是生成了新字符串）。
• 有序性：每个字符都有固定的位置。
• 可迭代性 ：可以用 for 循环遍历每个字符。

2.2 字符串的索引

• 正向索引 ：从 0 开始。
• 反向索引 ：从 -1 开始。

s = "Python"
print(s[0])    # P
print(s[-1])   # n

2.3 字符串的切片

切片语法与列表相同：s[start:end:step]

• start：开始索引，默认 0。
• end：结束索引（不包含），默认字符串长度（即末尾）。
• step：步长，默认 1；若为 -1 则从后向前取。

s = "Python"
print(s[0:2])    # Py
print(s[:3])     # Pyt
print(s[2:])     # thon
print(s[::-1])   # nohtyP  (反转字符串)

2.4 字符串的常用方法

方法	作用	示例
find(sub)	在字符串中查找子串，返回第一次出现的索引，找不到返回 -1	s.find('Python')
count(sub)	统计子串在字符串中出现的次数	s.count('H')
upper()	将字符串所有字母转换为大写	s.upper()
lower()	将字符串所有字母转换为小写	s.lower()
split(sep)	将字符串按指定分隔符分割成列表	s.split(' ')
strip(chars)	去除字符串两端指定的字符（默认去除空白字符）	s.strip() 或 s.strip('*')
replace(old, new)	将字符串中的指定子串替换为新子串	s.replace('H','C')
startswith(prefix)	检查字符串是否以指定子串开头，返回布尔值	s.startswith('P')

完整示例：

s = "Hello Python"

print(s.find('Python'))    # 6
print(s.count('o'))        # 2
print(s.upper())           # HELLO PYTHON
print(s.lower())           # hello python
print(s.split(' '))        # ['Hello', 'Python']
print(s.strip())           # 去除两端空格
print(s.replace('H','C'))  # Cello Python
print(s.startswith('H'))   # True

---

三、元组 (Tuple)

3.1 定义与特点

元组与列表类似，也是一种序列容器，但它是不可变的。

定义：

t = (1, 2, 3, 4)
t = 1, 2, 3           # 括号可省略
t = (42, )            # 单元素元组必须加逗号

特点：

• 可以存储不同类型元素。
• 元素有序、可重复。
• 不可修改（无法增、删、改元素），因此具有更高的安全性和性能。
• 可作为字典的键（因为不可变）。

3.2 元组的索引与切片

与列表完全相同，通过索引访问元素，支持切片操作，但不能修改。

t = (10, 20, 30, 40)
print(t[0])       # 10
print(t[-1])      # 40
print(t[1:3])     # (20, 30)

3.3 元组的常用方法

由于不可变，元组的方法非常少，仅有两个：

方法	作用	示例
count(x)	统计元素 x 在元组中出现的次数	t.count(20)
index(x)	返回元素 x 第一次出现的索引	t.index(30)

示例：

t = (10, 20, 20, 30)
print(t.count(20))   # 2
print(t.index(30))   # 3

提示：元组本身不可修改，但如果元组内包含可变对象（如列表），该对象的内容可以改变。

---

四、集合 (Set)

4.1 定义与特点

集合是无序且不重复的元素集合，主要用于去重和数学运算（交集、并集等）。

定义：

s = {1, 2, 3, 4}
s = set([1, 2, 3])   # 通过 set() 函数创建

特点：

• 元素无序（不支持索引访问）。
• 元素不可重复（自动去重）。
• 元素必须是不可变类型（如数字、字符串、元组），不能包含列表或字典。
• 可变容器，可以增删元素。

4.2 集合的基本操作

• 添加元素：add(x)
• 删除元素：remove(x)（若不存在会报错）、discard(x)（不存在不报错）
• 随机弹出一个元素：pop()
• 清空集合：clear()

示例：

s = {1, 2, 3}
s.add(4)              # {1, 2, 3, 4}
s.remove(2)           # {1, 3, 4}
s.discard(10)         # 不存在，不报错
item = s.pop()        # 随机移除并返回一个元素
print(item)

4.3 集合的数学运算

方法	作用	示例
union(set) 或 `	`	并集
intersection(set) 或 &	交集	s1 & s2
difference(set) 或 -	差集	s1 - s2
symmetric_difference(set) 或 ^	对称差集（并集减去交集）	s1 ^ s2

示例：

a = {1, 2, 3}
b = {2, 3, 4}
print(a | b)   # {1, 2, 3, 4}  并集
print(a & b)   # {2, 3}        交集
print(a - b)   # {1}           差集
print(a ^ b)   # {1, 4}        对称差集

4.4 集合的其他常用方法

方法	作用
update(set)	添加多个元素（相当于求并集并更新原集合）
intersection_update(set)	只保留交集部分
difference_update(set)	移除差集部分
issubset(set)	判断是否为子集
issuperset(set)	判断是否为超集

---

五、字典 (Dictionary)

5.1 定义与特点

字典是存储键值对的容器，通过键来快速访问值。

定义：

d = {"name": "Alice", "age": 25, "city": "Beijing"}
d = dict(name="Bob", age=30)

特点：

• 键唯一，且键必须是不可变类型（字符串、数字、元组等）。
• 值可以是任意类型，允许重复。
• 元素无序（Python 3.7+ 开始，字典会保持插入顺序）。
• 可变容器，可以增、删、改键值对。

5.2 访问与修改

• 通过键访问：d["name"]
• 安全访问（避免键不存在报错）：d.get("name", default)
• 添加/修改：d["key"] = value
• 删除键值对：del d["key"] 或 d.pop("key")

示例：

d = {"name": "Alice", "age": 25}
print(d["name"])          # Alice
print(d.get("gender", "未知"))  # 未知
d["age"] = 26             # 修改
d["city"] = "Shanghai"    # 添加
del d["age"]              # 删除

5.3 字典的常用方法

方法	作用	示例
keys()	返回所有键	d.keys()
values()	返回所有值	d.values()
items()	返回所有键值对（元组列表）	d.items()
pop(key)	删除指定键并返回其值	d.pop("name")
popitem()	随机删除并返回一个键值对（Python 3.7+ 删除最后一个插入的）	d.popitem()
update(dict)	将另一个字典的键值对合并到当前字典	d.update({"gender": "F"})
clear()	清空字典	d.clear()
setdefault(key, default)	若键不存在则添加键并设默认值，返回最终值	d.setdefault("score", 0)

示例：

d = {"name": "Alice", "age": 25}
print(d.keys())          # dict_keys(['name', 'age'])
print(d.values())        # dict_values(['Alice', 25])
print(d.items())         # dict_items([('name', 'Alice'), ('age', 25)])

d.update({"age": 26, "city": "Beijing"})   # 有则改，无则加
d.setdefault("score", 100)                # 若不存在 score，则添加并返回100
print(d)

5.4 遍历字典

# 遍历键
for key in d:
    print(key)

# 遍历值
for value in d.values():
    print(value)

# 遍历键值对
for key, value in d.items():
    print(f"{key}: {value}")

---

六、总结对比

数据结构	有序性	可变性	元素重复	访问方式	典型使用场景
列表	✅	✅	✅	索引	存储有序数据序列
字符串	✅	❌	✅	索引	文本处理
元组	✅	❌	✅	索引	不可变数据、字典键
集合	❌	✅	❌	不可索引	去重、数学运算
字典	❌(3.6+)	✅	键不重复	通过键	键值映射、缓存

熟练掌握这五种核心数据结构，是 Python 编程的基础。建议多写代码、多实践，才能真正理解它们的差异和适用场景。