数据结构

Python提供了四种主要的内置数据结构：列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set）。每种数据结构都有其特定的用途和特性。

Python数据结构概览：
┌─────────────────────────────────────────────┐
│                数据结构分类                 │
├─────────────────────────────────────────────┤
│ 序列类型（有序）：                          │
│   • 列表 [1,2,3]     - 可变，可重复        │
│   • 元组 (1,2,3)     - 不可变，可重复      │
│   • 字符串 "abc"     - 不可变，可重复      │
│                                             │
│ 映射类型：                                  │
│   • 字典 {k:v}       - 可变，键唯一        │
│                                             │
│ 集合类型：                                  │
│   • 集合 {1,2,3}     - 可变，元素唯一      │
└─────────────────────────────────────────────┘

列表（List）

列表是Python中最常用的数据结构，用方括号 [] 表示，元素之间用逗号分隔。

1. 创建列表

# 空列表
empty_list = []
print(f"空列表: {empty_list}")# 包含元素的列表
numbers = [1, 2, 3, 4, 5]
fruits = ["apple", "banana", "orange"]
mixed = [1, "hello", 3.14, True, None]print(f"数字列表: {numbers}")
print(f"水果列表: {fruits}")
print(f"混合列表: {mixed}")# 使用list()函数创建
list_from_string = list("hello")
list_from_range = list(range(5))print(f"从字符串创建: {list_from_string}")
print(f"从range创建: {list_from_range}")# 列表推导式创建
squares = [x**2 for x in range(1, 6)]
even_numbers = [x for x in range(10) if x % 2 == 0]print(f"平方数列表: {squares}")
print(f"偶数列表: {even_numbers}")

2. 访问、修改、删除元素

fruits = ["apple", "banana", "orange", "grape", "kiwi"]
print(f"原始列表: {fruits}")# 访问元素（索引从0开始）
print(f"第一个元素: {fruits[0]}")
print(f"最后一个元素: {fruits[-1]}")
print(f"倒数第二个: {fruits[-2]}")# 切片访问
print(f"前三个元素: {fruits[:3]}")
print(f"后两个元素: {fruits[-2:]}")
print(f"中间元素: {fruits[1:4]}")
print(f"每隔一个: {fruits[::2]}")
print(f"反向列表: {fruits[::-1]}")# 修改元素
fruits[1] = "blueberry"
print(f"修改后: {fruits}")# 修改多个元素
fruits[2:4] = ["mango", "pineapple"]
print(f"批量修改: {fruits}")# 删除元素
del fruits[0]  # 删除指定索引的元素
print(f"删除第一个元素: {fruits}")del fruits[1:3]  # 删除切片
print(f"删除切片: {fruits}")

3. 列表方法

# 创建示例列表
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print(f"原始列表: {numbers}")# append() - 在末尾添加元素
numbers.append(8)
print(f"append(8): {numbers}")# insert() - 在指定位置插入元素
numbers.insert(2, 99)
print(f"insert(2, 99): {numbers}")# extend() - 扩展列表
numbers.extend([10, 11])
print(f"extend([10, 11]): {numbers}")# remove() - 删除第一个匹配的元素
numbers.remove(1)
print(f"remove(1): {numbers}")# pop() - 删除并返回指定位置的元素
popped = numbers.pop()  # 默认删除最后一个
print(f"pop(): {numbers}, 删除的元素: {popped}")popped_index = numbers.pop(0)  # 删除指定位置
print(f"pop(0): {numbers}, 删除的元素: {popped_index}")# index() - 查找元素的索引
index_of_4 = numbers.index(4)
print(f"4的索引: {index_of_4}")# count() - 统计元素出现次数
count_of_1 = numbers.count(1)
print(f"1出现的次数: {count_of_1}")# sort() - 原地排序
numbers_copy = numbers.copy()
numbers_copy.sort()
print(f"升序排序: {numbers_copy}")numbers_copy.sort(reverse=True)
print(f"降序排序: {numbers_copy}")# reverse() - 反转列表
numbers.reverse()
print(f"反转列表: {numbers}")# clear() - 清空列表
temp_list = [1, 2, 3]
temp_list.clear()
print(f"清空后: {temp_list}")

4. 列表的高级操作

# 列表合并
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2
print(f"列表合并: {combined}")# 列表重复
repeated = [0] * 5
print(f"重复列表: {repeated}")# 列表比较
print(f"[1,2,3] == [1,2,3]: {[1,2,3] == [1,2,3]}")
print(f"[1,2,3] < [1,2,4]: {[1,2,3] < [1,2,4]}")# 嵌套列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(f"矩阵: {matrix}")
print(f"第二行第三列: {matrix[1][2]}")# 列表解包
a, b, c = [1, 2, 3]
print(f"解包: a={a}, b={b}, c={c}")# 使用*解包
first, *middle, last = [1, 2, 3, 4, 5]
print(f"解包: first={first}, middle={middle}, last={last}")

元组（Tuple）

元组是不可变的有序集合，用圆括号 () 表示。

1. 创建元组

# 空元组
empty_tuple = ()
print(f"空元组: {empty_tuple}")# 包含元素的元组
coordinates = (3, 4)
colors = ("red", "green", "blue")
mixed_tuple = (1, "hello", 3.14, True)print(f"坐标: {coordinates}")
print(f"颜色: {colors}")
print(f"混合元组: {mixed_tuple}")# 单元素元组（注意逗号）
single_tuple = (42,)  # 必须有逗号
print(f"单元素元组: {single_tuple}")
print(f"类型: {type(single_tuple)}")# 不带括号也可以创建元组
point = 1, 2, 3
print(f"不带括号的元组: {point}")
print(f"类型: {type(point)}")# 使用tuple()函数创建
tuple_from_list = tuple([1, 2, 3, 4])
tuple_from_string = tuple("hello")print(f"从列表创建: {tuple_from_list}")
print(f"从字符串创建: {tuple_from_string}")

2. 访问元素

fruits = ("apple", "banana", "orange", "grape")
print(f"水果元组: {fruits}")# 索引访问
print(f"第一个水果: {fruits[0]}")
print(f"最后一个水果: {fruits[-1]}")# 切片访问
print(f"前两个水果: {fruits[:2]}")
print(f"后两个水果: {fruits[-2:]}")# 元组解包
first, second, third, fourth = fruits
print(f"解包: {first}, {second}, {third}, {fourth}")# 部分解包
first, *others = fruits
print(f"第一个: {first}, 其他: {others}")# 交换变量（利用元组）
a, b = 10, 20
print(f"交换前: a={a}, b={b}")
a, b = b, a
print(f"交换后: a={a}, b={b}")

3. 元组的方法和特性

numbers = (1, 2, 3, 2, 4, 2, 5)
print(f"数字元组: {numbers}")# count() - 统计元素出现次数
count_of_2 = numbers.count(2)
print(f"2出现的次数: {count_of_2}")# index() - 查找元素的索引
index_of_3 = numbers.index(3)
print(f"3的索引: {index_of_3}")# len() - 获取长度
print(f"元组长度: {len(numbers)}")# 成员检测
print(f"3 in numbers: {3 in numbers}")
print(f"6 not in numbers: {6 not in numbers}")# 元组比较
print(f"(1,2,3) < (1,2,4): {(1,2,3) < (1,2,4)}")
print(f"(1,2,3) == (1,2,3): {(1,2,3) == (1,2,3)}")# 嵌套元组
nested = ((1, 2), (3, 4), (5, 6))
print(f"嵌套元组: {nested}")
print(f"访问嵌套元素: {nested[1][0]}")

4. 元组的应用场景

# 1. 函数返回多个值
def get_name_age():return "Alice", 25name, age = get_name_age()
print(f"姓名: {name}, 年龄: {age}")# 2. 作为字典的键（因为不可变）
locations = {(0, 0): "原点",(1, 1): "右上",(-1, -1): "左下"
}
print(f"坐标字典: {locations}")
print(f"(1,1)位置: {locations[(1, 1)]}")# 3. 配置信息
DATABASE_CONFIG = ("localhost",  # host5432,         # port"mydb",       # database"user",       # username"password"    # password
)host, port, db, user, pwd = DATABASE_CONFIG
print(f"数据库配置: {host}:{port}/{db}")# 4. 枚举替代
STATUS_PENDING = 0
STATUS_RUNNING = 1
STATUS_COMPLETED = 2STATUS_NAMES = ("待处理", "运行中", "已完成")
status = STATUS_RUNNING
print(f"当前状态: {STATUS_NAMES[status]}")

字典（Dictionary）

字典是键值对的集合，用花括号 {} 表示，键和值之间用冒号 : 分隔。

1. 创建字典

# 空字典
empty_dict = {}
print(f"空字典: {empty_dict}")# 包含元素的字典
student = {"name": "张三","age": 20,"grade": "A","subjects": ["数学", "英语", "物理"]
}
print(f"学生信息: {student}")# 使用dict()函数创建
dict_from_pairs = dict([("a", 1), ("b", 2), ("c", 3)])
dict_from_kwargs = dict(name="李四", age=22, city="北京")print(f"从键值对创建: {dict_from_pairs}")
print(f"从关键字参数创建: {dict_from_kwargs}")# 字典推导式
squares_dict = {x: x**2 for x in range(1, 6)}
filtered_dict = {k: v for k, v in student.items() if isinstance(v, str)}print(f"平方数字典: {squares_dict}")
print(f"过滤后的字典: {filtered_dict}")

2. 访问、修改、删除键值对

student = {"name": "张三","age": 20,"grade": "A","city": "上海"
}
print(f"原始字典: {student}")# 访问值
print(f"姓名: {student['name']}")
print(f"年龄: {student.get('age')}")
print(f"电话: {student.get('phone', '未提供')}")  # 提供默认值# 修改值
student["age"] = 21
student["grade"] = "A+"
print(f"修改后: {student}")# 添加新键值对
student["phone"] = "13800138000"
student["email"] = "zhangsan@example.com"
print(f"添加后: {student}")# 删除键值对
del student["city"]
print(f"删除city后: {student}")phone = student.pop("phone")  # 删除并返回值
print(f"删除phone: {phone}, 字典: {student}")email = student.pop("email", "无邮箱")  # 提供默认值
print(f"删除email: {email}")

3. 字典方法

student = {"name": "张三","age": 20,"grade": "A","subjects": ["数学", "英语"]
}print(f"原始字典: {student}")# keys() - 获取所有键
keys = student.keys()
print(f"所有键: {list(keys)}")# values() - 获取所有值
values = student.values()
print(f"所有值: {list(values)}")# items() - 获取所有键值对
items = student.items()
print(f"所有键值对: {list(items)}")# update() - 更新字典
student.update({"city": "北京", "phone": "13800138000"})
print(f"更新后: {student}")student.update(age=21, grade="A+")  # 使用关键字参数
print(f"再次更新: {student}")# setdefault() - 设置默认值
email = student.setdefault("email", "default@example.com")
print(f"设置默认email: {email}")
print(f"字典: {student}")# copy() - 浅拷贝
student_copy = student.copy()
print(f"拷贝的字典: {student_copy}")# clear() - 清空字典
temp_dict = {"a": 1, "b": 2}
temp_dict.clear()
print(f"清空后: {temp_dict}")

4. 字典的高级操作

# 字典合并（Python 3.9+）
dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
merged = dict1 | dict2
print(f"合并字典: {merged}")# 字典合并（通用方法）
dict1.update(dict2)
print(f"更新后的dict1: {dict1}")# 嵌套字典
company = {"name": "科技公司","employees": {"张三": {"age": 25, "position": "工程师"},"李四": {"age": 30, "position": "经理"},"王五": {"age": 28, "position": "设计师"}},"departments": ["技术部", "市场部", "人事部"]
}print(f"公司信息: {company['name']}")
print(f"张三的年龄: {company['employees']['张三']['age']}")# 安全访问嵌套字典
def safe_get(dictionary, *keys):"""安全获取嵌套字典的值"""for key in keys:if isinstance(dictionary, dict) and key in dictionary:dictionary = dictionary[key]else:return Nonereturn dictionaryage = safe_get(company, "employees", "张三", "age")
print(f"安全获取张三年龄: {age}")# 字典遍历
print("\n遍历字典:")
for key in company:print(f"键: {key}")for key, value in company.items():if key != "employees":print(f"{key}: {value}")# 遍历嵌套字典
print("\n员工信息:")
for name, info in company["employees"].items():print(f"{name}: {info['age']}岁, {info['position']}")

集合（Set）

集合是无序且元素唯一的集合，用花括号 {} 表示（但不包含键值对）。

1. 创建集合

# 空集合（注意：{}创建的是字典，不是集合）
empty_set = set()
print(f"空集合: {empty_set}")
print(f"类型: {type(empty_set)}")# 包含元素的集合
numbers = {1, 2, 3, 4, 5}
fruits = {"apple", "banana", "orange"}
mixed = {1, "hello", 3.14, True}print(f"数字集合: {numbers}")
print(f"水果集合: {fruits}")
print(f"混合集合: {mixed}")# 从其他数据结构创建集合
set_from_list = set([1, 2, 2, 3, 3, 4])  # 自动去重
set_from_string = set("hello")  # 字符去重
set_from_tuple = set((1, 2, 3, 2, 1))print(f"从列表创建（去重）: {set_from_list}")
print(f"从字符串创建: {set_from_string}")
print(f"从元组创建: {set_from_tuple}")# 集合推导式
squares_set = {x**2 for x in range(1, 6)}
even_set = {x for x in range(10) if x % 2 == 0}print(f"平方数集合: {squares_set}")
print(f"偶数集合: {even_set}")

2. 集合运算

set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}
set_c = {1, 2, 3}print(f"集合A: {set_a}")
print(f"集合B: {set_b}")
print(f"集合C: {set_c}")# 并集（Union）
union1 = set_a | set_b
union2 = set_a.union(set_b)
print(f"并集 A|B: {union1}")
print(f"并集 A.union(B): {union2}")# 交集（Intersection）
intersection1 = set_a & set_b
intersection2 = set_a.intersection(set_b)
print(f"交集 A&B: {intersection1}")
print(f"交集 A.intersection(B): {intersection2}")# 差集（Difference）
difference1 = set_a - set_b
difference2 = set_a.difference(set_b)
print(f"差集 A-B: {difference1}")
print(f"差集 A.difference(B): {difference2}")# 对称差集（Symmetric Difference）
sym_diff1 = set_a ^ set_b
sym_diff2 = set_a.symmetric_difference(set_b)
print(f"对称差集 A^B: {sym_diff1}")
print(f"对称差集 A.symmetric_difference(B): {sym_diff2}")# 子集和超集
print(f"C是A的子集: {set_c.issubset(set_a)}")
print(f"A是C的超集: {set_a.issuperset(set_c)}")
print(f"A和B不相交: {set_a.isdisjoint(set_b)}")

集合运算图解：
┌─────────────────────────────────────────────┐
│              集合运算示意图                 │
├─────────────────────────────────────────────┤
│                                             │
│    A = {1,2,3,4,5}    B = {4,5,6,7,8}      │
│                                             │
│    ┌─────────┐      ┌─────────┐             │
│    │ 1  2  3 │ 4  5 │ 6  7  8 │             │
│    │    A    │      │    B    │             │
│    └─────────┘      └─────────┘             │
│                                             │
│ 并集 A∪B = {1,2,3,4,5,6,7,8}               │
│ 交集 A∩B = {4,5}                           │
│ 差集 A-B = {1,2,3}                         │
│ 对称差集 A△B = {1,2,3,6,7,8}               │
│                                             │
└─────────────────────────────────────────────┘

3. 集合方法

fruits = {"apple", "banana", "orange"}
print(f"原始集合: {fruits}")# add() - 添加单个元素
fruits.add("grape")
print(f"添加grape: {fruits}")# update() - 添加多个元素
fruits.update(["kiwi", "mango"])
print(f"添加多个元素: {fruits}")fruits.update("pear")  # 字符串会被拆分
print(f"添加字符串: {fruits}")# remove() - 删除元素（不存在会报错）
fruits.remove("p")  # 删除字符'p'
print(f"删除p: {fruits}")# discard() - 删除元素（不存在不报错）
fruits.discard("grape")
fruits.discard("nonexistent")  # 不会报错
print(f"discard后: {fruits}")# pop() - 随机删除并返回一个元素
popped = fruits.pop()
print(f"随机删除: {popped}, 剩余: {fruits}")# clear() - 清空集合
temp_set = {1, 2, 3}
temp_set.clear()
print(f"清空后: {temp_set}")# copy() - 复制集合
fruits_copy = fruits.copy()
print(f"复制的集合: {fruits_copy}")

4. 集合的应用场景

# 1. 去重
numbers_with_duplicates = [1, 2, 2, 3, 3, 3, 4, 4, 5]
unique_numbers = list(set(numbers_with_duplicates))
print(f"原列表: {numbers_with_duplicates}")
print(f"去重后: {unique_numbers}")# 2. 成员检测（比列表快）
large_set = set(range(1000000))
print(f"999999 in large_set: {999999 in large_set}")  # 很快# 3. 找出两个列表的共同元素
list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common = list(set(list1) & set(list2))
print(f"共同元素: {common}")# 4. 找出差异
diff1 = list(set(list1) - set(list2))
diff2 = list(set(list2) - set(list1))
print(f"list1独有: {diff1}")
print(f"list2独有: {diff2}")# 5. 权限管理
user_permissions = {"read", "write"}
required_permissions = {"read", "write", "execute"}has_all_permissions = required_permissions.issubset(user_permissions)
missing_permissions = required_permissions - user_permissionsprint(f"用户权限: {user_permissions}")
print(f"需要权限: {required_permissions}")
print(f"权限足够: {has_all_permissions}")
print(f"缺少权限: {missing_permissions}")

字符串（String）

字符串是字符的序列，在Python中是不可变的。

1. 字符串基本操作

切片操作

text = "Hello, Python!"
print(f"原字符串: {text}")# 基本切片
print(f"前5个字符: {text[:5]}")
print(f"后7个字符: {text[-7:]}")
print(f"中间部分: {text[7:13]}")
print(f"每隔一个字符: {text[::2]}")
print(f"反转字符串: {text[::-1]}")# 步长切片
print(f"从索引1开始，每隔2个: {text[1::2]}")
print(f"倒序每隔2个: {text[::-2]}")

字符串拼接

# 使用+操作符
first_name = "张"
last_name = "三"
full_name = first_name + last_name
print(f"姓名: {full_name}")# 使用+=操作符
greeting = "Hello"
greeting += ", "
greeting += "World!"
print(f"问候: {greeting}")# 使用join()方法（推荐用于多个字符串）
words = ["Python", "is", "awesome"]
sentence = " ".join(words)
print(f"句子: {sentence}")# 使用*操作符重复
line = "-" * 30
print(line)
print("标题".center(30))
print(line)

字符串格式化

name = "Alice"
age = 25
score = 95.5# 1. f-string（Python 3.6+，推荐）
formatted1 = f"姓名: {name}, 年龄: {age}, 分数: {score:.1f}"
print(formatted1)# 表达式和函数调用
formatted2 = f"明年{name}将{age + 1}岁，分数是{score}（{'及格' if score >= 60 else '不及格'}）"
print(formatted2)# 2. str.format()方法
formatted3 = "姓名: {}, 年龄: {}, 分数: {:.1f}".format(name, age, score)
formatted4 = "姓名: {name}, 年龄: {age}, 分数: {score:.1f}".format(name=name, age=age, score=score
)
print(formatted3)
print(formatted4)# 3. %格式化（旧式，不推荐）
formatted5 = "姓名: %s, 年龄: %d, 分数: %.1f" % (name, age, score)
print(formatted5)# 格式化选项
pi = 3.14159265359
print(f"π = {pi:.2f}")      # 保留2位小数
print(f"π = {pi:.6f}")      # 保留6位小数
print(f"π = {pi:10.2f}")    # 总宽度10，右对齐
print(f"π = {pi:<10.2f}")   # 左对齐
print(f"π = {pi:^10.2f}")   # 居中对齐
print(f"π = {pi:0>10.2f}")  # 用0填充# 数字格式化
number = 1234567
print(f"数字: {number:,}")        # 千位分隔符
print(f"百分比: {0.85:.1%}")       # 百分比格式
print(f"科学计数法: {number:.2e}")  # 科学计数法

2. 字符串方法

text = "  Hello, Python World!  "
print(f"原字符串: '{text}'")# 大小写转换
print(f"大写: {text.upper()}")
print(f"小写: {text.lower()}")
print(f"首字母大写: {text.capitalize()}")
print(f"标题格式: {text.title()}")
print(f"大小写互换: {text.swapcase()}")# 去除空白
print(f"去除两端空白: '{text.strip()}'")
print(f"去除左侧空白: '{text.lstrip()}'")
print(f"去除右侧空白: '{text.rstrip()}'")# 查找和替换
print(f"查找'Python': {text.find('Python')}")
print(f"查找'Java': {text.find('Java')}")
print(f"统计'l'的个数: {text.count('l')}")
print(f"替换'Python'为'Java': {text.replace('Python', 'Java')}")# 分割和连接
sentence = "apple,banana,orange,grape"
fruits = sentence.split(",")
print(f"分割结果: {fruits}")rejoined = " | ".join(fruits)
print(f"重新连接: {rejoined}")# 按行分割
multiline = """第一行
第二行
第三行"""
lines = multiline.splitlines()
print(f"按行分割: {lines}")# 判断方法
test_strings = ["123", "abc", "ABC", "123abc", "  ", ""]
for s in test_strings:print(f"'{s}': 数字={s.isdigit()}, 字母={s.isalpha()}, "f"字母数字={s.isalnum()}, 空白={s.isspace()}, "f"大写={s.isupper()}, 小写={s.islower()}")# 对齐方法
text = "Python"
print(f"左对齐: '{text.ljust(20, '-')}'")
print(f"右对齐: '{text.rjust(20, '-')}'")
print(f"居中: '{text.center(20, '-')}'")
print(f"零填充: '{text.zfill(10)}'")# 编码和解码
original = "你好，世界！"
encoded = original.encode('utf-8')
decoded = encoded.decode('utf-8')
print(f"原字符串: {original}")
print(f"编码后: {encoded}")
print(f"解码后: {decoded}")

3. 字符串的高级操作

# 字符串模板
from string import Templatetemplate = Template("Hello, $name! You have $count new messages.")
message = template.substitute(name="Alice", count=5)
print(f"模板结果: {message}")# 安全替换（缺少变量不报错）
partial = template.safe_substitute(name="Bob")
print(f"部分替换: {partial}")# 正则表达式（简单介绍）
import retext = "联系电话：138-0013-8000，邮箱：user@example.com"
phone_pattern = r'\d{3}-\d{4}-\d{4}'
email_pattern = r'\w+@\w+\.\w+'phone = re.search(phone_pattern, text)
email = re.search(email_pattern, text)if phone:print(f"找到电话: {phone.group()}")
if email:print(f"找到邮箱: {email.group()}")# 字符串性能优化
# 错误方式：频繁使用+拼接
# result = ""
# for i in range(1000):
#     result += str(i)# 正确方式：使用join
numbers = [str(i) for i in range(1000)]
result = "".join(numbers)
print(f"拼接结果长度: {len(result)}")# 使用io.StringIO处理大量字符串
from io import StringIObuffer = StringIO()
for i in range(10):buffer.write(f"Line {i}\n")
result = buffer.getvalue()
print(f"StringIO结果:\n{result}")
buffer.close()

数据结构性能比较

import time
import sys# 创建测试数据
test_size = 100000
test_data = list(range(test_size))print("数据结构性能比较（基于100,000个元素）:")
print("=" * 50)# 1. 内存占用比较
list_data = list(test_data)
tuple_data = tuple(test_data)
set_data = set(test_data)
dict_data = {i: i for i in test_data}print(f"列表内存占用: {sys.getsizeof(list_data):,} 字节")
print(f"元组内存占用: {sys.getsizeof(tuple_data):,} 字节")
print(f"集合内存占用: {sys.getsizeof(set_data):,} 字节")
print(f"字典内存占用: {sys.getsizeof(dict_data):,} 字节")# 2. 查找性能比较
search_value = test_size - 1# 列表查找
start = time.time()
result = search_value in list_data
list_time = time.time() - start# 集合查找
start = time.time()
result = search_value in set_data
set_time = time.time() - start# 字典查找
start = time.time()
result = search_value in dict_data
dict_time = time.time() - startprint(f"\n查找性能比较:")
print(f"列表查找时间: {list_time:.6f} 秒")
print(f"集合查找时间: {set_time:.6f} 秒")
print(f"字典查找时间: {dict_time:.6f} 秒")
print(f"集合比列表快: {list_time/set_time:.1f} 倍")

数据结构选择指南：
┌─────────────────────────────────────────────┐
│              何时使用哪种数据结构           │
├─────────────────────────────────────────────┤
│ 列表 List:                                 │
│ • 需要有序存储                             │
│ • 允许重复元素                             │
│ • 需要频繁修改                             │
│ • 需要索引访问                             │
│                                             │
│ 元组 Tuple:                                │
│ • 数据不需要修改                           │
│ • 作为字典的键                             │
│ • 函数返回多个值                           │
│ • 配置信息存储                             │
│                                             │
│ 字典 Dict:                                 │
│ • 需要键值对映射                           │
│ • 快速查找和访问                           │
│ • 数据有明确的标识                         │
│                                             │
│ 集合 Set:                                  │
│ • 需要去重                                 │
│ • 集合运算（交集、并集等）                 │
│ • 快速成员检测                             │
│ • 数学集合操作                             │
└─────────────────────────────────────────────┘