Python中内置的数据结构类型详析（内置数据容器）

1. 元组（Tuple）​​

元组是一种​​不可变​​的有序序列，用于存储固定数据。适用于需要数据保护或哈希的场景（如字典的键）。

# 1、创建元组
# 可以使用圆括号 () 或者内置的 tuple() 函数来创建元组
empty_tuple = ()  		# 空元组
single_element = (1,)  	# 单元素元组（需逗号）
multi_elements = (1, "a", 3.14)# 使用 tuple() 函数创建元组
from_list = tuple([4, 5, 6]) 	 # 从列表创建元组
from_string = tuple('abc') 		 # 从字符串创建元组 ，输出('a', 'b', 'c')# 2、双向访问与切片
# 元组支持切片操作，用于获取元组的子集
# 切片操作使用 [start:stop:step] 的语法
print(multi_elements[0])       # 输出: 1 
print(multi_elements[-1])      # 输出: 3.14
print(multi_elements[1:3])     # 输出: ('a', 3.14)  
print(multi_elements[0::2])    # 输出：(1, 3.14)  # 3、不可变性示例
try:multi_elements[0] = 10  
except TypeError as e:print(f"错误: {e}")  # 输出: 元组不可修改  # 4、常用方法
# 元组只有两个内置方法：count() 和 index()
# count()：用于返回指定元素在元组中出现的次数
# index()：用于返回指定元素在元组中第一次出现的索引，如果元素不存在则引发 ValueError
count = multi_elements.count(1)      # 统计元素在元组中出现次数  
index = multi_elements.index("a") 	 # 查找元素索引  
print(count, index)  				 # 输出: 1 1  # 5、元组的解包
# 可以将元组中的元素解包到多个变量中
my_tuple = (10, 20, 30)
a, b, c = my_tuple
print(a)  # 输出10
print(b)  # 输出20
print(c)  # 输出30# 6、元组作为函数返回值
# 函数可以返回一个元组，方便同时返回多个值
def get_name_and_age():return 'Alice', 25name, age = get_name_and_age()
print(name)
print(age)# 7、元组的遍历
my_tuple = (1, 2, 3, 4, 5)
for element in my_tuple:print(element)

2. 列表（List）​

列表是​​可变​​的有序集合，支持动态增删改，适合存储动态数据。与元组不同，列表的元素可以被修改、添加或删除。

# 1、创建列表
my_list = [1, "a", 3.14]  
from_range = list(range(3))  # [0, 1, 2]  # 2、访问与切片
my_list = [10, 20, 30, 40, 50]
first_element = my_list[0]		# 访问第一个元素
last_element = my_list[-1]		#访问最后一个元素
subset = my_list[1:3]			# 获取从索引 1 到索引 3（不包含）的元素
every_second = my_list[0::2]	# 获取从索引 0 到末尾，步长为 2 的元素# 3、增删改操作
# 可以使用 append()、extend() 和 insert() 方法来添加元素
# 可以使用 remove()、pop() 和 del 语句来删除元素
my_list = [10, 10, 20, 30, 40, 50]my_list.append(4)          # 末尾添加   
my_list.extend([5, 6])	   # 扩展列表，将另一个可迭代对象的元素添加到列表末尾
my_list.insert(1, 15)	   # 在指定索引位置插入一个元素my_list[1] = 20            # 修改元素  
my_list.remove(20)		   # 删除指定值的第一个匹配项
popped_element = my_list.pop(1)		# 删除指定索引位置的元素，并返回该元素
del my_list[0]             # 删除索引0的元素
print(my_list)             # [20, 30, 40, 50, 4, 5, 6]# 4、切片与遍历
my_list = [10, 10, 20, 30, 40, 50]
print(my_list[::2])        # 输出: [10, 20, 40]  
for idx, val in enumerate(my_list):print(f"索引{idx}: {val}")  # 5、常用方法
# 列表还有 count()、index()、sort()、reverse() 等方法
my_list = [1, 2, 2, 3, 2]
count_2 = my_list.count(2)		# 统计元素 2 出现的次数
index_3 = my_list.index(3)		# 查找元素 3 第一次出现的索引
my_list.sort()					# 对列表进行排序
my_list.reverse()				# 反转列表
print(count_2)	# 3
print(index_3)	# 3
print(my_list) 	# [3, 2, 2, 2, 1]# 6、列表的遍历
my_list = [1, 2, 3, 4, 5]
for element in my_list:print(element)# 7、列表推导式
# 创建一个包含 1 到 5 的平方的列表
# 列表推导式是一种简洁的创建列表的方式
squares = [i ** 2 for i in range(1, 6)]
print(squares)	# [1, 4, 9, 16, 25]

3. 字典（Dict）

字典（dict）是一种无序、可变且以键值对形式存储数据的数据结构。字典是​​键值对​​的无序集合（Python 3.7+ 有序），支持快速查询。

# 1、创建字典
# 可以使用花括号 {} 或者内置的 dict() 函数来创建字典
empty_dict = {}  # 空字典
simple_dict = {'name': 'Alice', 'age': 25}  # 包含键值对的字典
from_tuples = dict([('city', 'New York'), ('country', 'USA')])
from_kwargs = dict(name='Bob', age=30)# 2、访问字典元素
# 可以通过键来访问字典中的值。如果键不存在，直接访问会引发 KeyError
# 解决办法在下段落，此处先不谈
my_dict = {'name': 'Alice', 'age': 25}		
name = my_dict['name']		# 通过键访问值
city = my_dict.get('city')	# 使用 get() 方法访问值，如果键不存在，返回默认值（这里是 None）# 3、增删查改
my_dict = {'name': 'Alice', 'age': 25}	
my_dict['age'] = 26					# 修改已有键的值
my_dict['city'] = 'New York'		# 添加新的键值对
print(my_dict)						# {'name': 'Alice', 'age': 26, 'city': 'New York'}
del my_dict['city']			# 使用 del 语句删除指定键的键值对
age = my_dict.pop('age')	# 使用 pop() 方法删除指定键的键值对，并返回该键对应的值
print(my_dict)				# {'name': 'Alice'}# 4、遍历键值
for key, value in person.items():print(f"{key}: {value}")  # 5、常用方法
# keys()：返回一个包含字典所有键的视图对象。
# values()：返回一个包含字典所有值的视图对象。
# items()：返回一个包含字典所有键值对的视图对象。
# update()：将另一个字典的键值对更新到当前字典中
my_dict = {'name': 'Alice', 'age': 25}
keys = my_dict.keys()			# 获取所有键
values = my_dict.values()		# 获取所有值
items = my_dict.items()			# 获取所有键值对
new_dict = {'city': 'Bei Jing'}	# 更新字典
my_dict.update(new_dict)
print(keys)						# dict_keys(['name', 'age', 'city'])
print(values)					# dict_values(['Alice', 25, 'Bei Jing'])
print(list(values))				# ['Alice', 25, 'Bei Jing']
print(items)					# dict_items([('name', 'Alice'), ('age', 25), ('city', 'Bei Jing')])
print(my_dict)					# {'name': 'Alice', 'age': 25, 'city': 'Bei Jing'}# 6、字典推导式
# 创建一个包含 1 到 5 的平方的字典
squares_dict = {i: i ** 2 for i in range(1, 6)}
print(squares_dict)		# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

在 Python 中，字典（dict）是一种非常常用的数据结构，用于存储键值对。当尝试访问一个不存在的键时，直接使用 dict[key] 会导致 KeyError。为了避免这种情况，可以使用以下几种方法：

1. 使用 get() 方法
   get() 方法是字典的一个内置方法，它允许你安全地访问字典中的值。如果键不存在，get() 方法会返回一个默认值（通常是 None），而不是抛出错误。

my_dict = {"a": 1, "b": 2}# 使用 get() 方法访问键
value = my_dict.get("a")  # 返回 1
print(value)# 如果键不存在，返回默认值 None
value = my_dict.get("c")  # 返回 None
print(value)# 也可以指定默认值
value = my_dict.get("c", "默认值")  # 返回 "默认值"
print(value)

2. 使用 defaultdict
   defaultdict 是 collections 模块中的一个类，它继承自普通的字典，但允许你指定一个默认值。当你访问一个不存在的键时，defaultdict 会自动创建一个默认值，并将其与该键关联起来。

from collections import defaultdict# 创建一个 defaultdict，指定默认值为 list
anagram_dict = defaultdict(list)# 添加一些数据
anagram_dict["a"].append("apple")
anagram_dict["b"].append("banana")# 访问一个不存在的键
print(anagram_dict["c"])  # 输出：[]

3. 使用 setdefault() 方法
   setdefault() 方法也是字典的一个内置方法，它类似于 get()，但会在键不存在时插入一个默认值。

my_dict = {"a": 1, "b": 2}# 使用 setdefault() 方法访问键
value = my_dict.setdefault("a", "默认值")  # 返回 1
print(value)# 如果键不存在，插入默认值
value = my_dict.setdefault("c", "默认值")  # 返回 "默认值"
print(value)print(my_dict)  # 输出：{'a': 1, 'b': 2, 'c': '默认值'}

4. 集合（Set）​​

集合（set）是一种无序且唯一的数据结构，它不允许有重复的元素，常用于去重、成员检测和集合运算（如并集、交集、差集等）。

# 1、创建集合
str = set()					# set() 是创建空集合的唯一方式，str = {}是空字典
my_set = {1, 2, 2, 3}       # 自动去重 → {1, 2, 3}  
from_list = set([3, 4, 5])  
fruits = {'apple', 'banana', 'cherry'}# 2、访问集合元素
# 由于集合是无序的，不能通过索引来访问元素。但可以使用 for 循环遍历集合中的元素，或者使用 in 关键字检查元素是否存在于集合中```python
fruits = {'apple', 'banana', 'cherry'}	# 遍历集合
for fruit in fruits:print(fruit)# 检查元素是否存在
is_apple_in = 'apple' in fruits
print(is_apple_in)		# True# 3、添加元素
# 可以使用 add() 方法向集合中添加单个元素，使用 update() 方法添加多个元素（可以是列表、元组、集合等可迭代对象）
fruits = {'apple', 'banana'}
# 添加单个元素
fruits.add('cherry')
# 添加多个元素
fruits.update(['date', 'elderberry'])
print(fruits)		# {'apple', 'banana', 'cherry', 'elderberry', 'date'}# 4、删除元素
# 可以使用 remove()、discard() 和 pop() 方法来删除集合中的元素
# remove()：如果元素存在，将其从集合中移除；若元素不存在，会引发 KeyError
# discard()：如果元素存在，将其从集合中移除；若元素不存在，不会引发错误
# pop()：随机移除并返回集合中的一个元素，若集合为空，会引发 KeyError
fruits = {'apple', 'banana', 'cherry'}# 使用 remove() 方法删除元素
fruits.remove('apple')# 使用 discard() 方法删除元素
fruits.discard('banana')# 使用 pop() 方法删除元素
popped_fruit = fruits.pop()# 5、集合的常用操作
## 5.1并集：可以使用 | 运算符或 union() 方法实现
set1 = {1, 2, 3}
set2 = {3, 4, 5}# 使用 | 运算符求并集
union_set1 = set1 | set2# 使用 union() 方法求并集
union_set2 = set1.union(set2)print(union_set1)	# {1, 2, 3, 4, 5}
print(union_set2)	# {1, 2, 3, 4, 5}## 5.2交集：可以使用 & 运算符或 intersection() 方法实现
set1 = {1, 2, 3}
set2 = {3, 4, 5}# 使用 & 运算符求交集
intersection_set1 = set1 & set2# 使用 intersection() 方法求交集
intersection_set2 = set1.intersection(set2)print(intersection_set1)	# {3}
print(intersection_set2)	# {3}## 5.3差集：可以使用 - 运算符或 difference() 方法实现
set1 = {1, 2, 3}
set2 = {3, 4, 5}# 使用 - 运算符求差集
difference_set1 = set1 - set2# 使用 difference() 方法求差集
difference_set2 = set1.difference(set2)print(difference_set1)	# {1, 2}
print(difference_set2)	# {1, 2}## 5.4对称差集：可以使用 ^ 运算符或 symmetric_difference() 方法实现
set1 = {1, 2, 3}
set2 = {3, 4, 5}# 使用 ^ 运算符求对称差集
symmetric_difference_set1 = set1 ^ set2# 使用 symmetric_difference() 方法求对称差集
symmetric_difference_set2 = set1.symmetric_difference(set2)print(symmetric_difference_set1)	# {1, 2, 4, 5}
print(symmetric_difference_set2)	# {1, 2, 4, 5}# 6、集合的长度
# 可以使用 len() 函数获取集合中元素的数量
fruits = {'apple', 'banana', 'cherry'}
length = len(fruits)
print(length)	# 3# 7、清空集合
# 可以使用 clear() 方法清空集合中的所有元素
fruits = {'apple', 'banana', 'cherry'}
fruits.clear()
print(fruits)	# set()

5. 字符串（Str）

字符串是​​不可变​​的字符序列，支持文本处理和格式化。

# 创建字符串
s = "Hello, 世界!"  
multiline = """多行  
字符串"""  # 切片与操作
print(s[0:5])              # 输出: Hello  
print(s.upper())           # 转为大写  # 常用方法
words = s.split(",")       # 分割 → ['Hello', ' 世界!']  
joined = '-'.join(words)  # 合并 → "Hello-世界!"  # 格式化
name = "Alice"  
print(f"Name: {name}")     # 输出: Name: Alice  

6. 队列（Queue）与栈（Stack）​

​​队列（FIFO）​​：用 deque 实现。
​​栈（LIFO）​​：用列表的 append 和 pop 实现。
队列（Queue）和栈（Stack）是两种常见的数据结构，它们在数据存储和访问方式上有很大的区别。以下是它们的主要区别：

6.1. 数据访问方式

6.1.1 队列（Queue）

特点：先进先出（FIFO，First In First Out）。最早进入队列的元素会最先被移除。
操作：
入队（Enqueue）：在队列的尾部添加一个元素。
出队（Dequeue）：从队列的头部移除一个元素。
查看队首元素（Peek）：查看队列头部的元素，但不移除它。

6.1.2 栈（Stack）

特点：后进先出（LIFO，Last In First Out）。最后进入栈的元素会最先被移除。
操作：
入栈（Push）：在栈的顶部添加一个元素。
出栈（Pop）：从栈的顶部移除一个元素。
查看栈顶元素（Peek）：查看栈顶的元素，但不移除它。

# 队列示例
from collections import deque  
queue = deque([1, 2, 3])  
queue.append(4)            # 入队  
print(queue.popleft())     # 出队 → 1  # 栈示例
stack = []  
stack.append(10)          # 入栈  
print(stack.pop())         # 出栈 → 10  

6.2. 应用场景

队列（Queue）
任务调度：操作系统中的任务调度，按照任务到达的顺序执行。
消息队列：在多线程或多进程环境中，用于传递消息。
打印队列：打印机按照任务提交的顺序打印文档。
广度优先搜索（BFS）：在图的遍历中，队列用于存储待访问的节点。

栈（Stack）
函数调用：程序运行时，函数调用的上下文（如局部变量、返回地址等）存储在栈中。
表达式求值：计算算术表达式的值，如逆波兰表达式。
括号匹配：检查括号是否正确匹配。
深度优先搜索（DFS）：在图的遍历中，栈用于存储待访问的节点。
撤销操作（Undo）：在软件中实现撤销功能，如文本编辑器中的撤销操作。

6.3. 实现方式

队列（Queue）
Python 实现：可以使用 collections.deque，它是一个双端队列，支持高效的头部和尾部操作。

from collections import dequequeue = deque()
queue.append(1)  # 入队
queue.append(2)
queue.append(3)
print(queue.popleft())  # 出队，输出 1

栈（Stack）
Python 实现：可以使用普通的列表（list），利用 append() 和 pop() 方法来模拟栈的操作。

stack = []
stack.append(1)  # 入栈
stack.append(2)
stack.append(3)
print(stack.pop())  # 出栈，输出 3

6.4. 内存结构

队列（Queue）
队列的元素顺序是固定的，新元素总是添加到尾部，旧元素总是从头部移除。队列的头部和尾部可以动态变化。
队列通常需要维护两个指针（头部指针和尾部指针）来跟踪元素的位置。
栈（Stack）
栈的元素顺序是动态的，新元素总是添加到顶部，旧元素也总是从顶部移除。栈的顶部位置会不断变化。
栈通常只需要维护**一个指针（栈顶指针）**来跟踪元素的位置。

6.5. 性能

队列（Queue）
使用 collections.deque 时，队列的头部和尾部操作（入队、出队）的时间复杂度为 O(1)。
栈（Stack）
使用列表（list）时，栈的入栈和出栈操作的时间复杂度为 O(1)。

总结：数据结构对比表