python教程（二）：python数据结构大全（附代码）

Python 中数据结构的重要性不言而喻，它们是构建高效、可维护代码的基础。数据结构决定了如何存储、组织和操作数据。理解和使用合适的数据结构能够极大地提升程序的性能、简洁性以及代码的可读性。

Python 的基础数据结构有 4 种，分别是 列表 (list)、元组 (tuple)、集合 (set) 和 字典 (dictionary)，它们都是 Python 内置的，并不需要额外导入模块。基础数据结构广泛用于存储和操作数据，支持常见的增删改查等操作。

Python 的高级数据结构有 6 种，通常需要从 collections、heapq 和 queue 模块导入，包括 双端队列 (deque)、默认字典 (defaultdict)、有序字典 (OrderedDict)、计数器 (Counter)、堆 (heap) 和 优先队列 (Priority Queue)。这些高级数据结构提供了更高效和专业化的功能，适用于复杂的场景如优先级处理、计数统计、双向数据操作等。

本文将会详细介绍Python的基础数据结构。

1、python基础结构

1.1 列表（list）

列表（list）是一种有序的、可变的序列，用于存储多个元素。它是最常见的基础数据结构之一，可以存储任意类型的对象（数字、字符串、甚至其他列表）。

特点:
有序: 元素按照插入顺序排列。
可变: 可以动态添加、删除和修改元素。
支持重复元素: 列表中的元素可以重复。
元素可以是不同类型: 列表可以包含任何类型的对象（数字、字符串、列表等）。

列表使用方括号 [] 来定义，元素用逗号分隔。列表可以很方便进行元素访问、切片、修改、添加、删除，列表的长度使用 len() 函数可以获取列表的长度，合并列表可以通过 + 操作符或 extend() 方法合并两个列表，如果需要遍历列表的索引和元素，可以使用 enumerate() 函数。列表的具体使用如下：

# 创建一个包含多种元素类型的列表
my_list = [1, 2, 3, 'hello', [4, 5]]  # 列表可以包含数字、字符串、甚至其他列表

# 访问列表中的元素
print(my_list[0])  # 输出: 1，访问第一个元素
print(my_list[-1])  # 输出: [4, 5]，访问最后一个元素（支持负索引）

# 列表切片
print(my_list[1:3])  # 输出: [2, 3]，从索引1开始到索引3之前的元素
print(my_list[:2])   # 输出: [1, 2]，获取从开始到索引2之前的元素
print(my_list[::2])  # 输出: [1, 3, [4, 5]]，每隔一个元素取一次

# 修改列表中的元素
my_list[1] = 'changed'  # 修改索引1处的元素为'changed'
print(my_list)  # 输出: [1, 'changed', 3, 'hello', [4, 5]]

# 添加元素到列表
my_list.append(6)  # 在列表末尾添加元素6
print(my_list)  # 输出: [1, 'changed', 3, 'hello', [4, 5], 6]

# 在指定位置插入元素
my_list.insert(2, 'new')  # 在索引2处插入'new'
print(my_list)  # 输出: [1, 'changed', 'new', 3, 'hello', [4, 5], 6]

# 删除列表中的元素
removed = my_list.pop()  # 删除并返回列表末尾的元素
print(removed)  # 输出: 6，显示被删除的元素
print(my_list)  # 输出: [1, 'changed', 'new', 3, 'hello', [4, 5]]

my_list.remove('new')  # 删除列表中的第一个'new'元素
print(my_list)  # 输出: [1, 'changed', 3, 'hello', [4, 5]]

# 获取列表的长度
print(len(my_list))  # 输出: 5，列表中包含5个元素

# 合并两个列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2  # 使用'+'操作符合并列表
print(combined)  # 输出: [1, 2, 3, 4, 5, 6]

list1.extend(list2)  # 使用extend方法合并list2到list1中
print(list1)  # 输出: [1, 2, 3, 4, 5, 6]

# 对列表排序
nums = [3, 1, 4, 2]
nums.sort()  # 原地排序
print(nums)  # 输出: [1, 2, 3, 4]

# 反转列表
nums.reverse()  # 原地反转列表
print(nums)  # 输出: [4, 3, 2, 1]

# 列表的遍历
for item in my_list:
    print(item)  # 逐个打印列表中的元素

# 使用enumerate同时获取索引和值
for index, value in enumerate(my_list):
    print(f"Index: {index}, Value: {value}")  # 打印索引和值

列表的常用方法：

方法	描述
append(x)	将元素 x 添加到列表末尾
extend(iterable)	将可迭代对象的元素添加到列表末尾
insert(i, x)	在索引 i 处插入元素 x
remove(x)	删除列表中第一个值为 x 的元素
pop([i])	移除并返回索引 i 处的元素（默认移除最后一个元素）
clear()	移除列表中的所有元素
index(x[, start[, end]])	返回列表中第一个值为 x 的元素索引
count(x)	返回元素 x 在列表中出现的次数
sort(key=None, reverse=False)	对列表进行原地排序
reverse()	原地反转列表中的元素
copy()	返回列表的浅拷贝

列表的内存管理与性能:
由于列表是动态数组，它的大小可以动态调整，这使得 Python 列表能够以灵活的方式存储不同大小的数据。然而，频繁的插入和删除操作（尤其是在列表的中间部分）可能导致性能下降，因为这些操作可能需要移动列表中的其他元素。

时间复杂度:
访问元素: O(1)
在末尾添加元素 (append()): O(1)
插入或删除（中间或开头）: O(n)
遍历列表: O(n)
排序: O(n log n)

应用场景:
列表适用于需要按顺序存储数据且数据量较小的场景。
动态管理元素集合，例如任务列表、购物车、学生名单等。
适用于需要频繁访问、更新或追加数据的场景。

1.2 元组（tuple）

元组（tuple）是 Python 中的一种有序的、不可变的数据结构。元组中的元素一旦创建后就不能被修改，因此它适用于存储那些不需要更改的数据。元组类似于列表，但它的不可变性使它在某些场景下更高效，并且可以作为字典的键。

特点:
有序: 元素按照插入顺序排列。
不可变: 一旦元组被创建，就不能修改其内容（不能添加、删除、修改元素）。
支持重复元素: 元组中的元素可以重复。
元素可以是不同类型: 元组可以包含任意类型的元素（数字、字符串、列表，甚至另一个元组）。
轻量高效: 由于不可变性，元组在内存和性能方面比列表更高效。

元组使用圆括号 () 定义，元素用逗号分隔。如果创建只有一个元素的元组，需要在元素后加一个逗号，否则会被识别为一个普通的类型。元组的具体操作如下：

# 创建一个元组
my_tuple = (1, 2, 3, 'hello', [4, 5])

# 访问元组中的元素
print(my_tuple[0])  # 输出: 1
print(my_tuple[-1])  # 输出: [4, 5]

# 元组的长度
print(len(my_tuple))  # 输出: 4，元组中有4个元素

# 元组切片
print(my_tuple[1:3])  # 输出: (2, 3)

# 遍历元组
for item in my_tuple:
    print(item)
    
# 元组不可变性 
# my_tuple[1] = 'new_value'  # 这会引发错误，因为元组是不可变的   
    
# 元组解包
a, b, c = (1, 2, 3)
print(a, b, c)  # 输出: 1 2 3

# 嵌套元组
nested_tuple = (1, (2, 3), (4, (5, 6)))
print(nested_tuple[2][1])  # 输出: (5, 6)

# 元组的方法
print(my_tuple.count(2))  # 输出: 1，元素 2 出现了一次
print(my_tuple.index('hello'))  # 输出: 3，'hello' 在索引 3 处

元组的常用方法：

方法	描述
count(x)	返回元素 x 在元组中出现的次数
index(x)	返回元素 x 在元组中第一次出现的索引位置

时间复杂度:
访问元素: O(1)
遍历元组: O(n)

元组的应用场景:
不可变数据的存储: 元组适用于存储不需要更改的数据，例如数据库表中的一行记录、GPS 坐标等。
字典的键: 因为元组是不可变的，所以它可以作为字典的键，而列表不行。
解包操作: 在函数返回多个值时，经常使用元组解包来获取这些值。
 

1.3 集合（set）

集合（set）是 Python 中的一种无序且不重复的可变数据结构，用于存储唯一的元素。集合主要用于执行集合相关的操作，如交集、并集和差集等。集合中的元素必须是不可变的对象（例如，数字、字符串、元组），但集合本身是可变的。

特点:
无序: 集合中的元素没有固定顺序，不能通过索引访问元素。
元素唯一: 集合中的所有元素都是唯一的，自动去重。
可变: 可以动态添加、删除元素。
高效查找: 集合基于哈希表实现，查找、插入、删除操作的时间复杂度为 O(1)。
元素必须是不可变对象: 例如，数字、字符串、元组可以作为集合元素，而列表和字典不能。

集合可以使用大括号 {} 或内置的 set() 函数创建。集合的操作如下：

# 创建集合
my_set = {1, 2, 3, 4, 4}  # 自动去重，重复的元素4只保留一个
print(my_set)  # 输出: {1, 2, 3, 4}

# 添加元素
my_set.add(5)  # 向集合中添加元素5
print(my_set)  # 输出: {1, 2, 3, 4, 5}

# 删除元素
my_set.discard(5)  # 删除元素5，不会引发错误
print(my_set)  # 输出: {1, 2, 3, 4}

# 随机删除并返回集合中的一个元素
popped_element = my_set.pop()  # 随机删除并返回一个元素
print(f"被删除的元素: {popped_element}")
print(my_set)  # 输出集合的剩余元素

# 判断元素是否存在
print(2 in my_set)  # 输出: True，2 在集合中
print(5 in my_set)  # 输出: False，5 不在集合中

# 获取集合的长度
print(f"集合长度: {len(my_set)}")  # 输出: 集合长度

# 清空集合
my_set.clear()  # 清空集合
print(my_set)  # 输出: set()

# 集合运算
set1 = {1, 2, 3}
set2 = {3, 4, 5}

print(set1 & set2)  # 输出: {3}，交集
print(set1 | set2)  # 输出: {1, 2, 3, 4, 5}，并集
print(set1 - set2)  # 输出: {1, 2}，差集
print(set1 ^ set2)  # 输出: {1, 2, 4, 5}，对称差集（不同时存在于两个集合中的元素）

# 遍历集合
for item in set1:
    print(f"集合中的元素: {item}")  # 逐个打印集合中的元素

集合的常用方法:

方法	描述
add(x)	向集合添加元素 x
remove(x)	删除元素 x，若不存在则报错
discard(x)	删除元素 x，若不存在不报错
pop()	随机删除一个元素并返回
clear()	清空集合
union(set)	返回两个集合的并集
intersection(set)	返回两个集合的交集
difference(set)	返回当前集合与另一个集合的差集
symmetric_difference(set)	返回两个集合的对称差集
issubset(set)	判断当前集合是否为另一个集合的子集
issuperset(set)	判断当前集合是否为另一个集合的超集
isdisjoint(set)	判断两个集合是否没有交集

时间复杂度:

插入元素: O(1)
删除元素: O(1)
查找元素: O(1)
遍历集合: O(n)

应用场景:

去重: 适合用来快速去重。例如，将列表转换为集合后可以自动去除重复元素。
集合运算: 处理交集、并集、差集等集合相关操作的场景，如计算共同好友、差异项等。
快速查找: 利用集合的 O(1) 查找特性，适合用于大量元素的快速存在性检查。

1.4 字典（dict）

字典（dict）是 Python 中的一种无序的、可变的数据结构，用于存储键值对（key-value）。每个键是唯一的，并且与对应的值相映射。字典是 Python 中最常用的数据结构之一，适合存储和快速查找数据。

特点:
无序（Python 3.7+ 版本中字典按插入顺序保存，但仍称为无序结构）。
键唯一: 每个键在字典中是唯一的，重复的键会覆盖之前的值。
可变: 可以动态添加、删除、修改键值对。
键必须是不可变类型: 键可以是字符串、数字或元组，但不能是列表或字典。
快速查找: 字典查找操作的时间复杂度是 O(1)，非常高效。

字典使用大括号 {} 定义，键值对之间使用逗号分隔，键和值使用冒号 : 分隔。字典的操作如下：

# 创建字典
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 访问字典中的值
print(my_dict['name'])  # 输出: Alice

# 使用 get() 方法访问不存在的键时返回默认值
print(my_dict.get('country', 'Not Found'))  # 输出: Not Found

# 修改字典中的值
my_dict['age'] = 26
print(my_dict)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York'}

# 添加新的键值对
my_dict['country'] = 'USA'
print(my_dict)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York', 'country': 'USA'}

# 删除键值对
my_dict.pop('city')  # 删除键 'city'
print(my_dict)  # 输出: {'name': 'Alice', 'age': 26, 'country': 'USA'}

# 使用 del 删除键值对
del my_dict['age']
print(my_dict)  # 输出: {'name': 'Alice', 'country': 'USA'}

# 获取字典的键、值和键值对
print(my_dict.keys())    # 输出: dict_keys(['name', 'country'])
print(my_dict.values())  # 输出: dict_values(['Alice', 'USA'])
print(my_dict.items())   # 输出: dict_items([('name', 'Alice'), ('country', 'USA')])

# 遍历字典的键值对
for key, value in my_dict.items():
    print(f"Key: {key}, Value: {value}")

# 合并两个字典
other_dict = {'age': 30, 'job': 'Engineer'}
my_dict.update(other_dict)
print(my_dict)  # 输出: {'name': 'Alice', 'country': 'USA', 'age': 30, 'job': 'Engineer'}

# 清空字典
my_dict.clear()
print(my_dict)  # 输出: {}

字典的常用方法:

方法	描述
get(key[, default])	返回指定键的值，如果键不存在，返回默认值
pop(key[, default])	删除并返回指定键的值
keys()	返回字典中所有键
values()	返回字典中所有值
items()	返回字典中所有键值对
update(dict)	使用另一个字典或键值对更新当前字典
clear()	清空字典
copy()	返回字典的浅复制

时间复杂度:
访问元素: O(1)
插入/删除元素: O(1)
遍历字典: O(n)

应用场景:
快速查找数据: 通过唯一键快速查找对应的值，如用户名到用户数据的映射。
存储配置信息: 字典常用于存储配置信息，如应用程序的设置参数。
数据映射: 字典非常适合存储映射关系，如商品 ID 到商品详情的映射。