Python 数据结构知识汇总
📌 前言
Python 作为一门优雅且功能强大的编程语言，其内置的数据结构是每个 Python 开发者必须掌握的基础知识。本文将系统性地介绍 Python 中五大核心数据结构：字符串（str）、列表（list）、元组（tuple）、字典（dict）和集合（set），帮助读者建立完整的知识体系。
一、字符串（str）
1.1 什么是字符串
字符串是 Python 中最常用的数据类型，用于表示文本信息。可以使用单引号、双引号或三引号来定义。
python
# 字符串定义 str1 = 'Hello World' str2 = "Python" str3 = """多行 字符串"""
1.2 字符串的常用操作
| 操作 | 方法 | 示例 |
|---|---|---|
| 长度 | len() | len("hello")→ 5 |
| 索引 | [索引] | "hello"[1]→ 'e' |
| 切片 | [开始:结束:步长] | "hello"[1:4]→ 'ell' |
| 拼接 | + | "Hello" + "World"→ 'HelloWorld' |
| 重复 | * | "Hi" * 3→ 'HiHiHi' |
| 查找 | find() | "hello".find("e")→ 1 |
| 替换 | replace() | "hello".replace("e", "a")→ 'hallo' |
| 分割 | split() | "a,b,c".split(",")→ ['a','b','c'] |
| 大写 | upper() | "hello".upper()→ 'HELLO' |
| 小写 | lower() | "HELLO".lower()→ 'hello' |
| 去除空格 | strip() | " hi ".strip()→ 'hi' |
| 判断字母数字 | isalnum() | "abc123".isalnum()→ True |
1.3 字符串的切片操作（重点）
python
s = "Python学习" # 切片语法：s[开始:结束:步长] print(s[0]) # P print(s[-1]) # 习 print(s[0:6]) # Python print(s[6:]) # 学习 print(s[::-1]) # 习学nohtyP（反转字符串）
1.4 字符串格式化
python
# 三种常用格式化方式 # 1. % 格式化（旧式） name = "张三" age = 18 print("姓名：%s，年龄：%d" % (name, age)) # 2. format() 方法 print("姓名：{}，年龄：{}".format(name, age)) # 3. f-string（Python 3.6+，推荐） print(f"姓名：{name}，年龄：{age}")二、列表（list）
2.1 什么是列表
列表是 Python 中最常用的可变容器类型，可以存储任意类型的元素，支持增删改查操作。
python
# 列表定义 list1 = [] # 空列表 list2 = [1, 2, 3] # 整数列表 list3 = ["a", "b", "c"] # 字符串列表 list4 = [1, "hello", 3.14, True] # 混合类型
2.2 列表的增删改查
增加元素
| 方法 | 说明 | 示例 |
|---|---|---|
append() | 在末尾添加一个元素 | lst.append(4) |
insert() | 在指定位置插入 | lst.insert(0, 0) |
extend() | 合并另一个列表 | lst.extend([5,6]) |
python
lst = [1, 2, 3] lst.append(4) # [1, 2, 3, 4] lst.insert(0, 0) # [0, 1, 2, 3, 4] lst.extend([5, 6]) # [0, 1, 2, 3, 4, 5, 6]
删除元素
| 方法 | 说明 | 示例 |
|---|---|---|
pop() | 删除末尾元素（可指定索引） | lst.pop()→ 返回删除的值 |
remove() | 删除指定值的第一个匹配项 | lst.remove(2) |
del | 删除指定索引或切片 | del lst[0]或del lst[1:3] |
clear() | 清空列表 | lst.clear() |
python
lst = [1, 2, 3, 4, 5] lst.pop() # [1, 2, 3, 4] lst.pop(0) # [2, 3, 4] lst.remove(3) # [2, 4] del lst[0] # [4]
修改元素
python
lst = [1, 2, 3] lst[0] = 100 # [100, 2, 3] lst[1:3] = [200, 300] # [100, 200, 300]
查询元素
python
lst = [10, 20, 30, 20, 40] # 获取元素 print(lst[0]) # 10 print(lst[-1]) # 40 print(lst[1:4]) # [20, 30, 20] # 查找索引 print(lst.index(20)) # 1（返回第一个匹配的索引） # 统计次数 print(lst.count(20)) # 2 # 判断是否存在 print(30 in lst) # True # 遍历 for item in lst: print(item) for i, item in enumerate(lst): print(f"索引{i}: {item}")2.3 列表推导式（重点）
python
# 生成 1-10 的平方列表 squares = [i**2 for i in range(1, 11)] print(squares) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] # 带条件的列表推导式 even = [i for i in range(1, 21) if i % 2 == 0] print(even) # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20] # 嵌套列表推导式 matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] flatten = [num for row in matrix for num in row] print(flatten) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
2.4 列表的常用函数
| 函数 | 说明 | 示例 |
|---|---|---|
len() | 获取长度 | len([1,2,3])→ 3 |
max() | 获取最大值 | max([1,5,3])→ 5 |
min() | 获取最小值 | min([1,5,3])→ 1 |
sum() | 求和 | sum([1,2,3])→ 6 |
sorted() | 排序（返回新列表） | sorted([3,1,2])→ [1,2,3] |
reverse() | 反转列表 | lst.reverse() |
三、元组（tuple）
3.1 什么是元组
元组与列表类似，但一旦创建不可修改（不可变）。使用小括号()定义。
python
# 元组定义 t1 = () # 空元组 t2 = (1, 2, 3) # 普通元组 t3 = (1,) # 单元素元组（注意逗号） t4 = 1, 2, 3 # 不加括号也可以
3.2 元组的特点
python
t = (10, 20, 30, 40, 50) # ✅ 支持索引 print(t[0]) # 10 print(t[-1]) # 50 # ✅ 支持切片 print(t[1:4]) # (20, 30, 40) # ✅ 支持遍历 for item in t: print(item) # ✅ 支持成员判断 print(30 in t) # True # ❌ 不支持修改 t[0] = 100 # TypeError: 'tuple' object does not support item assignment
3.3 元组的应用场景
python
# 1. 函数返回多个值 def get_student(): return "张三", 18, "男" name, age, sex = get_student() print(name, age, sex) # 张三 18 男 # 2. 交换变量 a, b = 10, 20 a, b = b, a # 本质是元组解包 print(a, b) # 20 10 # 3. 作为字典的键（列表不行） d = {(1, 2): "value"} # ✅ 元组可以作为键 # d = {[1, 2]: "value"} # ❌ 列表不可以作为键四、字典（dict）
4.1 什么是字典
字典是 Python 中唯一的键值对（key-value）映射类型，通过键来访问值。键必须是不可变类型（字符串、数字、元组），值可以是任意类型。
python
# 字典定义 d1 = {} # 空字典 d2 = {"name": "张三", "age": 18} # 普通字典 d3 = dict(name="张三", age=18) # 使用 dict() 函数4.2 字典的增删改查
增加/修改
python
d = {"name": "张三", "age": 18} # 增加或修改 d["gender"] = "男" # 新增键值对 d["age"] = 19 # 修改已有键的值 # update() 合并字典 d.update({"score": 90, "grade": "A"}) print(d) # {'name': '张三', 'age': 19, 'gender': '男', 'score': 90, 'grade': 'A'}删除
python
d = {"name": "张三", "age": 18, "gender": "男"} # pop() 删除指定键并返回值 age = d.pop("age") print(age) # 18 # popitem() 删除并返回最后一个键值对 item = d.popitem() print(item) # ('gender', '男') # del 删除指定键 del d["name"] # clear() 清空 d.clear()查询
python
d = {"name": "张三", "age": 18, "gender": "男"} # 通过键取值（键不存在会报错） print(d["name"]) # 张三 # get() 取值（键不存在返回 None 或默认值） print(d.get("name")) # 张三 print(d.get("score")) # None print(d.get("score", 0)) # 0 # 获取所有键 print(d.keys()) # dict_keys(['name', 'age', 'gender']) # 获取所有值 print(d.values()) # dict_values(['张三', 18, '男']) # 获取所有键值对 print(d.items()) # dict_items([('name', '张三'), ('age', 18), ('gender', '男')]) # 遍历字典 for key in d: print(f"{key}: {d[key]}") for key, value in d.items(): print(f"{key}: {value}")4.3 字典推导式
python
# 生成数字平方的字典 squares = {i: i**2 for i in range(1, 6)} print(squares) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25} # 筛选条件 even_squares = {i: i**2 for i in range(1, 11) if i % 2 == 0} print(even_squares) # {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}4.4 字典的常用方法
| 方法 | 说明 |
|---|---|
get(key, default) | 获取键的值，不存在返回默认值 |
setdefault(key, default) | 如果键存在返回其值，否则插入键并设置默认值 |
pop(key) | 删除键并返回其值 |
keys() | 返回所有键的视图 |
values() | 返回所有值的视图 |
items() | 返回所有键值对的视图 |
update(dict2) | 合并另一个字典 |
五、集合（set）
5.1 什么是集合
集合是无序的、元素唯一的容器类型，主要用于去重和集合运算（交集、并集等）。
python
# 集合定义 s1 = set() # 空集合（不能使用 {}，那是空字典） s2 = {1, 2, 3} # 普通集合 s3 = set([1, 2, 2, 3, 3]) # [1, 2, 3]（自动去重）5.2 集合的操作
添加元素
python
s = {1, 2, 3} # add() 添加单个元素 s.add(4) # {1, 2, 3, 4} s.add(2) # {1, 2, 3, 4}（不会重复） # update() 添加多个元素 s.update([5, 6, 7]) # {1, 2, 3, 4, 5, 6, 7}删除元素
python
s = {1, 2, 3, 4, 5} # remove() 删除指定元素（不存在报错） s.remove(3) # {1, 2, 4, 5} # discard() 删除指定元素（不存在不报错） s.discard(10) # 不会报错 # pop() 随机删除并返回一个元素 item = s.pop() # clear() 清空 s.clear()5.3 集合运算
python
A = {1, 2, 3, 4, 5} B = {4, 5, 6, 7, 8} # 交集 print(A & B) # {4, 5} print(A.intersection(B)) # 并集 print(A | B) # {1, 2, 3, 4, 5, 6, 7, 8} print(A.union(B)) # 差集（A 有 B 没有） print(A - B) # {1, 2, 3} print(A.difference(B)) # 对称差集（不同时存在的） print(A ^ B) # {1, 2, 3, 6, 7, 8} print(A.symmetric_difference(B)) # 判断子集 print({1, 2} <= A) # True（{1,2} 是 A 的子集） # 判断超集 print(A >= {1, 2}) # True（A 是 {1,2} 的超集）5.4 集合的去重应用
python
# 去重 lst = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4] unique = list(set(lst)) print(unique) # [1, 2, 3, 4] # 统计字符串中的不同字符 text = "hello world" chars = set(text) print(chars) # {'h', 'e', 'l', 'o', ' ', 'w', 'r', 'd'}六、数据结构对比总结
6.1 快速对比表
| 特性 | 列表 (list) | 元组 (tuple) | 字典 (dict) | 集合 (set) |
|---|---|---|---|---|
| 符号 | [] | () | {} | {} |
| 可变性 | ✅ 可变 | ❌ 不可变 | ✅ 可变 | ✅ 可变 |
| 有序性 | ✅ 有序 | ✅ 有序 | ✅ 有序（Python 3.7+） | ❌ 无序 |
| 元素唯一性 | ❌ 可重复 | ❌ 可重复 | ✅ 键唯一 | ✅ 元素唯一 |
| 索引方式 | 整数索引 | 整数索引 | 键（key） | 不支持索引 |
| 适用场景 | 存储有序数据 | 存储不可变数据 | 键值映射 | 去重、集合运算 |
6.2 使用场景速查
python
# 列表：需要频繁修改的有序数据 students = ["张三", "李四", "王五"] # 元组：不需要修改的数据，或函数返回多个值 coordinates = (10, 20) # 字典：需要键值映射的数据 user = {"name": "张三", "age": 18} # 集合：去重或集合运算 unique_numbers = {1, 2, 3, 4, 5}七、常见面试题
7.1 列表和元组的区别
| 区别 | 列表 | 元组 |
|---|---|---|
| 可变性 | 可变 | 不可变 |
| 性能 | 较慢（需要额外分配内存） | 较快（固定大小） |
| 使用场景 | 需要修改的数据 | 不需要修改的数据 |
7.2 字典和集合的区别
| 区别 | 字典 | 集合 |
|---|---|---|
| 元素类型 | 键值对 | 单个元素 |
| 键唯一性 | 键唯一 | 元素唯一 |
| 使用场景 | 映射关系 | 去重、集合运算 |
7.3 可变对象 vs 不可变对象
python
# 不可变对象（修改会创建新对象） s = "hello" s = s + " world" # 创建了新字符串 # 可变对象（修改不会创建新对象） lst = [1, 2, 3] lst.append(4) # 在原列表上修改
八、总结
本文系统介绍了 Python 中五大核心数据结构：
字符串（str）：文本处理，不可变
列表（list）：有序可变容器，最常用的序列类型
元组（tuple）：有序不可变容器，安全性高
字典（dict）：键值映射，高效查找
集合（set）：无序不重复元素，去重与集合运算
掌握这些数据结构是学好 Python 的基础，建议在实际编码中多加练习，理解每种数据结构的特性和适用场景。
📌本文首发于 CSDN，欢迎点赞、收藏、转发！
📧 如有问题，欢迎在评论区留言交流。
