Python 数据结构全解析：从基础到实战
引言
Python 作为一门强大的编程语言，其丰富的数据结构是其受欢迎的关键原因之一。掌握这些数据结构不仅能提高代码效率，更能解决复杂问题。本文将系统梳理 Python 数据结构体系，从原始类型到复杂的自定义结构，并通过简洁案例展示其应用精髓。
一、原始数据类型
1. 整数 (Integers)
1
2
3
4
| # 整数运算简洁高效
a = 42
b = -10
print(a + b) # 32
|
2. 布尔值 (Boolean)
1
2
3
4
| # 条件判断的基础
is_valid = True
if is_valid:
print("验证通过")
|
3. 字符串 (Strings)
1
2
3
4
| # 强大的文本处理能力
text = "Python 数据结构"
print(text[0:6]) # Python
print(text.replace("Python", "Java")) # Java 数据结构
|
4. 浮点数 (Float)
1
2
3
4
5
| # 科学计算的基础
pi = 3.14159
radius = 5
area = pi * (radius ** 2)
print(f"圆面积：{area:.2f}") # 圆面积：78.54
|
二、内置非原始数据类型
1. 列表 (Lists)
1
2
3
4
| # 动态数组，支持增删改查
fruits = ["苹果", "香蕉", "橙子"]
fruits.append("草莓")
print(fruits) # ['苹果', '香蕉', '橙子', '草莓']
|
2. 集合 (Sets)
1
2
3
4
5
6
| # 去重和集合运算
numbers = {1, 2, 3, 2, 1}
print(numbers) # {1, 2, 3}
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.intersection(set2)) # {3}
|
3. 字典 (Dictionaries)
1
2
3
4
5
| # 键值对映射，高效查找
student = {"name": "张三", "age": 20, "score": 95}
print(student["name"]) # 张三
student["grade"] = "A"
print(student) # {'name': '张三', 'age': 20, 'score': 95, 'grade': 'A'}
|
4. 元组 (Tuples)
1
2
3
4
| # 不可变序列，数据安全
point = (10, 20)
rgb = (255, 0, 0) # 红色
print(point[0]) # 10
|
三、用户自定义数据结构
1. 栈 (Stack)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| # 后进先出 (LIFO)
class Stack:
def __init__(self):
self.items = []
def push(self, item):
self.items.append(item)
def pop(self):
return self.items.pop()
def is_empty(self):
return self.items == []
# 案例：括号匹配检查
def is_balanced(expression):
stack = Stack()
for char in expression:
if char == '(':
stack.push(char)
elif char == ')':
if stack.is_empty():
return False
stack.pop()
return stack.is_empty()
print(is_balanced("((1+2)*(3-4))")) # True
|
2. 队列 (Queue)
1
2
3
4
5
6
7
| # 先进先出 (FIFO)
from collections import deque
queue = deque()
queue.append("任务 1")
queue.append("任务 2")
print(queue.popleft()) # 任务 1
|
3. 树 (Tree)
1
2
3
4
5
6
7
8
9
10
11
| # 层次结构表示
class TreeNode:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
# 简单二叉树构建
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
|
4. 链表 (Linked List)
1
2
3
4
5
6
7
8
9
10
| # 动态内存分配
class Node:
def __init__(self, data):
self.data = data
self.next = None
# 创建简单链表
head = Node("A")
head.next = Node("B")
head.next.next = Node("C")
|
5. 图 (Graph)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| # 网络关系表示
graph = {
'A': ['B', 'C'],
'B': ['A', 'D', 'E'],
'C': ['A', 'F'],
'D': ['B'],
'E': ['B', 'F'],
'F': ['C', 'E']
}
# 深度优先遍历
def dfs(graph, start, visited=None):
if visited is None:
visited = set()
visited.add(start)
print(start, end=' ')
for next_node in graph[start]:
if next_node not in visited:
dfs(graph, next_node, visited)
dfs(graph, 'A') # A B D E F C
|
四、数据结构选择指南
| 数据结构 |
适用场景 |
时间复杂度 |
| 列表 |
需要有序、可变集合 |
查找 O(n)，插入末尾 O(1) |
| 字典 |
需要快速查找，键值映射 |
查找 O(1)，插入 O(1) |
| 集合 |
需要去重，集合运算 |
查找 O(1)，插入 O(1) |
| 栈 |
需要后进先出处理 |
插入/删除 O(1) |
| 队列 |
需要先进先出处理 |
插入/删除 O(1) |
| 树 |
需要层次结构，如文件系统 |
查找 O(log n)（平衡树） |
| 图 |
需要表示网络关系 |
取决于算法和实现 |
五、实战应用案例
使用字典和集合优化查找
1
2
3
4
5
6
7
8
9
10
11
12
13
| # 问题：在大数据集中查找重复元素
def find_duplicates(numbers):
seen = set()
duplicates = set()
for num in numbers:
if num in seen:
duplicates.add(num)
else:
seen.add(num)
return duplicates
data = [1, 2, 3, 2, 1, 5, 6, 5]
print(find_duplicates(data)) # {1, 2, 5}
|
使用栈实现表达式求值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| # 简化版后缀表达式计算器
def evaluate_postfix(expression):
stack = []
for token in expression.split():
if token in "+-*/":
b = stack.pop()
a = stack.pop()
if token == '+': stack.append(a + b)
elif token == '-': stack.append(a - b)
elif token == '*': stack.append(a * b)
elif token == '/': stack.append(a / b)
else:
stack.append(float(token))
return stack[0]
print(evaluate_postfix("3 4 + 2 *")) # (3+4)*2 = 14.0
|
总结
Python 数据结构体系丰富而强大，从原始类型到复杂的用户自定义结构，为不同问题提供了最优解决方案。选择合适的数据结构是高效编程的关键。原始类型适合基本数据存储，内置集合类型满足大多数日常需求，而自定义数据结构则为特定问题提供专业解决方案。
掌握这些数据结构不仅能提高代码性能，更能培养算法思维。无论是开发应用、数据分析还是人工智能，深入理解数据结构都是成为 Python 高手的必经之路。
希望本文的简明案例能帮助你快速掌握 Python 数据结构的精髓，在实际项目中灵活应用。
