Python有列表、元组、集合、字典四大数据结构，用对用错性能差几十倍！今天用一张表+实战代码，帮你彻底搞懂什么时候该用什么类型。

★ P1：列表 vs 元组——到底该选谁？

列表和元组的核心区别只有一件事：可变 vs 不可变。元组能做的事列表基本都能做，但元组在特定场景下有独特优势。

核心区别对比：

# 列表（可变）          
lst = [1, 2, 3]          
lst[0] = 10       # ✅ 可以修改          
lst.append(4)    # ✅ 可以添加          
lst.remove(2)    # ✅ 可以删除          

# 元组（不可变）          
tup = (1, 2, 3)          
tup[0] = 10       # ❌ TypeError          
tup.append(4)    # ❌ AttributeError

什么时候用元组：

# 1. 作为字典的键（列表不行）          
location = {(0, 0): '原点', (1, 1): '对角点'}          

# 2. 函数返回值用元组（暗示不可修改）          
def get_min_max(numbers):          
    return min(numbers), max(numbers)  # 返回元组          

# 3. 性能优势：元组内存占用更小，创建更快          
import sys          
print(sys.getsizeof([1,2,3]))  # 约80字节          
print(sys.getsizeof((1,2,3))) # 约64字节

★ P2：集合（set）——去重和成员判断的王者

集合的独门绝技：O(1)时间复杂度的成员判断和自动去重。用列表做成员判断是O(n)，用集合是O(1)，差了上百倍！

集合的核心操作：

s = {1, 2, 3, 4, 5}          

# 成员判断 O(1)          
print(3 in s)        # True          
print(10 in s)       # False          

# 自动去重          
nums = [1, 2, 2, 3, 3, 3, 4]          
unique = set(nums)   # {1, 2, 3, 4}          
print(list(unique))  # [1, 2, 3, 4]

性能对比——列表 vs 集合查成员：

import time          

lst = list(range(1000000))          
s = set(range(1000000))          
target = 999999          

start = time.time()          
result = target in lst  # O(n) 列表查询          
print(f'列表查询: {time.time()-start:.4f}秒')     # 输出：列表查询：0.0077秒     

start = time.time()          
result = target in s    # O(1) 集合查询          
print(f'集合查询: {time.time()-start:.4f}秒')     # 输出：集合查询：0.0003秒     
# 列表约0.0077秒，集合约0.0003秒，性能差距约25倍。

★ P3：字典（dict）——键值查找的首选

字典是Python最核心的数据结构，所有对象以字典形式存储。键值对查找平均复杂度O(1)，是处理映射关系的首选。

字典的高效操作：

d = {'name': 'Rose', 'age': 25, 'city': '上海'}          

# 键值遍历          
for key, value in d.items():          
    print(f'{key}: {value}')          

# defaultdict：键不存在时自动初始化          
from collections import defaultdict          
dd = defaultdict(list)          
dd['fruits'].append('apple')          
dd['fruits'].append('banana')          
print(dd['fruits'])  # ['apple', 'banana']          
print(dd['vegetables'])  # [] 自动返回空列表，不报错

★ P4：推导式——一行代码搞定数据结构转换

Python的列表推导式、集合推导式、字典推导式是代码简洁高效的秘诀。掌握它们让你的代码瞬间Pythonic！

列表推导式 vs 循环：

# 循环写法（3行）          
squares = []          
for i in range(10):          
    squares.append(i ** 2)          

# 列表推导式（1行）          
squares = [i**2 for i in range(10)]          

# 带条件过滤          
odd_squares = [i**2 for i in range(10) if i % 2 == 1]          
print(odd_squares)  # [1, 9, 25, 49, 81]

集合推导式和字典推导式：

# 集合推导式          
words = ['apple', 'banana', 'apple', 'cherry']          
unique_lengths = {len(w) for w in words}          
print(unique_lengths)  # {5, 6}          

# 字典推导式          
names = ['Alice', 'Bob', 'Charlie']          
name_lengths = {name: len(name) for name in names}          
print(name_lengths)  # {'Alice': 5, 'Bob': 3, 'Charlie': 7}

★ P5：总结

今天全面对比了Python四大数据结构的用法和性能，核心要点：

1.   列表（list）：有序、可变，适合需要索引和修改的场景，但成员判断是O(n)；
2.  元组（tuple）：有序、不可变，作为字典键用，函数返回值暗示不可变性，小巧高效；
3.  集合（set）：无序、唯一、自动去重，成员判断O(1)，做去重和快速查找首选；
4.  字典（dict）：键值映射，O(1)查找，适合建立索引和快速查询。

性能选型口诀：查成员用set，改元素用list，固定组合用tuple，键值映射用dict。

进阶建议：遇到大数据量（>10000条）的查找、去重、统计场景，先想数据结构选对没有。同样逻辑，数据结构选错可能慢10-100倍。养成在动手前先思考"什么数据结构最适合"的习惯，受益无穷！

更多相关技术内容咨询欢迎前往并持续关注好学星城论坛了解详情。

想高效系统的学习Python编程语言，推荐大家关注一个微信公众号：Python编程学习圈。每天分享行业资讯、技术干货供大家阅读，关注即可免费领取整套Python入门到进阶的学习资料以及教程，感兴趣的小伙伴赶紧行动起来吧。