10种 Python数据结构,从入门到精通

今天我们将深入探讨 Python 中常用的数据结构，帮助你从基础到精通。每种数据结构都有其独特的特点和适用场景，通过实际代码示例和生活中的比喻，让你更容易理解这些概念。

学习数据结构的三个阶段

1、掌握基本用法：使用这些数据结构解决一些基本问题。

2、应用场景选择：知道在何种场景下选用哪种数据结构。

3、深入理解实现：了解内置数据结构的源码实现，并将其与相关算法知识联系起来，提升编程能力。

下面逐一介绍这 10 种常用的数据结构。

---

1. List (列表)

基本用法

list 是 Python 中最基本的数据结构，允许存储多个值且支持动态大小。

# 创建一个列表
fruits = ['apple', 'banana', 'cherry']
print(fruits[0])  # 输出：apple

# 添加元素
fruits.append('orange')
print(fruits)  # 输出：['apple', 'banana', 'cherry', 'orange']

# 修改元素
fruits[1] = 'kiwi'
print(fruits)  # 输出：['apple', 'kiwi', 'cherry', 'orange']

# 删除元素
fruits.remove('cherry')
print(fruits)  # 输出：['apple', 'kiwi', 'orange']

使用场景

• 适合频繁查询和修改：例如，在需要按索引访问元素时，list 的性能优越。

• 不适合频繁插入和删除：特别是在开头插入或删除时，因为这样会导致后面的元素都要移动。

实现原理

list 底层是动态数组，初始状态下无需指定长度。当插入元素超过初始容量时，会进行扩容，通常是以两倍的方式增加大小。删除操作尤其在列表开头执行时，由于涉及大量元素的位移，因此时间复杂度为 O(n)。

---

2. Tuple (元组)

基本用法

tuple 是一种不可变的序列，一旦创建便无法修改。

# 创建一个元组
coordinates = (10, 20)
print(coordinates[0])  # 输出：10

# 元组解包
x, y = coordinates
print(x, y)  # 输出：10 20

使用场景

• 确保数据不被修改：如果确定对象不会被修改（比如坐标），可以使用元组。

• 节省内存：由于元组的不可变性，Python 在内存管理上更高效。

from sys import getsizeof
print(getsizeof(list()))  # 输出：72
print(getsizeof(tuple()))  # 输出：56

实现原理

tuple 是一种静态数组，不支持动态扩展，其存储方式相较于 list 更加紧凑，因此在同等条件下占用的内存更少。

---

3. Set (集合)

基本用法

set 是一种无序且不重复的集合，主要用于去重和集合运算。

# 创建一个集合
a = [3, 2, 5, 2, 5, 3]
unique_values = set(a)
print(unique_values)  # 输出：{2, 3, 5}

# 集合操作
b = {3, 4, 6, 2}
intersection = unique_values.intersection(b)  # 求交集
print(intersection)  # 输出：{2, 3}

使用场景

• 去除重复元素：例如，统计购物车中的唯一商品。

• 快速查找：适合快速判断某个元素是否存在。

实现原理

set 通过哈希表实现，采用哈希函数将元素映射到固定的索引，增删查操作平均时间复杂度为 O(1)，因此效率极高。

---

4. Dict (字典)

基本用法

dict 是基于键-值对数据结构，广泛用于数据存储和检索。

# 创建字典
d = {'a': 1, 'b': 2}
print(d['a'])  # 输出：1

# 添加元素
d['c'] = 3
print(d)  # 输出：{'a': 1, 'b': 2, 'c': 3}

# 修改元素
d['b'] = 5
print(d)  # 输出：{'a': 1, 'b': 5, 'c': 3}

# 删除元素
del d['a']
print(d)  # 输出：{'b': 5, 'c': 3}

使用场景

• 高效查询：适合需要快速查找的场景，如用户信息存储。

• 统计数据：比如计算字符串中字符出现次数的场景。

text = "hello world"
count_dict = {}
for char in text:
    count_dict[char] = count_dict.get(char, 0) + 1
print(count_dict)  # 输出：{'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}

实现原理

dict 实际上是哈希表实现，基于键值对存储数据，查找、插入和删除操作的平均时间复杂度是 O(1)。不过，由于哈希表的设计，字典在内存上相对消耗较大。

---

5. Deque (双端队列)

基本用法

deque 是双端队列，支持从左右两边高效地添加和删除元素。

from collections import deque

# 创建一个双端队列
d = deque([3, 2, 4])
d.appendleft(1)  # 从左侧添加元素
print(d)  # 输出：deque([1, 3, 2, 4])

# 从右侧添加元素
d.append(5)
print(d)  # 输出：deque([1, 3, 2, 4, 5])

# 从左侧删除元素
d.popleft()
print(d)  # 输出：deque([3, 2, 4, 5])

使用场景

• 需要频繁在两端进行操作的场景：如任务调度、回溯算法等。

实现原理

deque 是一个双向链表，因此在两端进行操作时，时间复杂度都是 O(1)。它内部维护了一个数组和链表的数据结构，使得存取操作灵活且高效。

---

6. Counter (计数器)

基本用法

Counter 是用于计数的容器，可以轻松统计元素出现的频率。

from collections import Counter

# 创建 Counter
c = Counter(['apple', 'orange', 'apple', 'banana'])
print(c)  # 输出：Counter({'apple': 2, 'orange': 1, 'banana': 1})

# 获取最常见的元素
most_common = c.most_common(2)  # 前两个常见元素
print(most_common)  # 输出：[('apple', 2), ('orange', 1)]

使用场景

• 统计频次：分析文本数据、用户行为等，找出最常见的项。

实现原理

Counter 继承自 dict，其实现简单明了，将元素作为键，出现的次数作为值，方便快速统计和查询。

---

7. OrderedDict (有序字典)

基本用法

OrderedDict 是一个保持插入顺序的字典。

from collections import OrderedDict

od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3

for k, v in od.items():
    print(k, v)  # 输出：a 1, b 2, c 3

使用场景

• 需要保持元素插入顺序的场景：如任务调度、配置文件解析等。

实现原理

OrderedDict 内部维护了一个双向链表来记录元素的插入顺序，同时还能保证 O(1) 的插入、删除和查找效率。

---

8. Heapq (堆队列)

基本用法

heapq 提供了堆队列算法，支持高效的优先级队列实现。

import heapq

a = [3, 1, 4, 2]
heapq.heapify(a)  # 建堆
print(a[0])  # 输出：1，最小元素

# 获取前 3 个最大元素
largest = heapq.nlargest(3, a)
print(largest)  # 输出：[4, 3, 2]

# 获取前 3 个最小元素
smallest = heapq.nsmallest(3, a)
print(smallest)  # 输出：[1, 2, 3]

使用场景

• 需要经常获取最小或最大值的场景：如实时数据处理、任务调度等。

实现原理

堆是一种特殊的完全二叉树，其中父节点的值小于子节点（最小堆）。heapq 模块使用数组实现堆，能够很方便地维持堆的性质。

---

9. Defaultdict (默认字典)

基本用法

defaultdict 是一种带默认值的字典，避免了键不存在时的 KeyError。

from collections import defaultdict

d = defaultdict(int)  # 默认值为 0
d['apple'] += 1
d['banana'] += 2
print(d)  # 输出：defaultdict(<class 'int'>, {'apple': 1, 'banana': 2})

# 添加列表作为默认值
dd = defaultdict(list)
words = ['book', 'nice', 'great', 'book']
for i, word in enumerate(words):
    dd[word].append(i)
print(dd)  # 输出：defaultdict(<class 'list'>, {'book': [0, 3], 'nice': [1], 'great': [2]})

使用场景

• 适合需要自动初始化的字典：如频率统计、分组归类等场景。

实现原理

defaultdict 是对 dict 的扩展，当访问一个未定义的键时，会调用默认工厂函数生成一个默认值，避免了显式的检查。

---

10. ChainMap (链式映射)

基本用法

ChainMap 用于将多个字典组合为一个字典视图，支持同时查找。

from collections import ChainMap

d1 = {'a': 1, 'b': 2}
d2 = {'b': 3, 'c': 4}
cm = ChainMap(d1, d2)

print(cm['b'])  # 输出：2，取自 d1
print(cm['c'])  # 输出：4，取自 d2

# 修改键值对
cm['b'] = 5
print(d1)  # 输出：{'a': 1, 'b': 5}, d1 被修改

使用场景

• 合并多个字典并希望同步更改的场景：如配置文件管理、环境变量设置等。

实现原理

ChainMap 将多个字典视为一个单一的映射，每次查找首先会检查第一个字典，如果没有找到，再查找下一个，这使得多个字典的合并变得简单而高效。

---

总结

本文详细介绍了 Python 中的 10 种常用数据结构，并结合了代码示例和实际场景解析，希望能帮助读者加深对这些数据结构的理解。在实际开发中，合理选择数据结构能够显著提升代码的效率和可读性。如果觉得这篇文章对你有帮助，请转发、点赞或收藏，以支持我们继续原创！

python教程22

python教程 · 目录

上一篇​十个常见的 Python 脚本 (详细介绍 + 代码举例)下一篇反爬虫？不存在的！教你几招轻松绕过网站限制