由于前几天给大家介绍过字符串,元组,列表,字典.今天给大家介绍集合.同时对前几天的知识进行汇总,Python 提供了多种内置数据结构，用于存储和组织数据。不同的数据结构有不同的特点和适用场景，选择合适的结构能让代码更简洁、效率更高。这篇文章将系统性地对比和汇总 Python 中五种最常用的数据结构：字符串（str）、列表（list）、元组（tuple）、字典（dict）和集合（set）。

一、总体对比

在深入了解每种结构之前，先通过一张表格建立整体认识：

二、字符串（str）

字符串是不可变的字符序列，用引号括起来表示。

定义方式

# 单引号、双引号、三引号 s1 = 'hello' s2 = "world" s3 = """ 多行字符串 """

核心特性

s = "Python" # 索引（正向从0开始，负向从-1开始） print(s[0]) # P print(s[-1]) # n # 切片 [start:end:step] print(s[1:4]) # yth print(s[::-1]) # nohtyP（反转） # 不可变性 # s[0] = "J" # TypeError

常用方法

text = " Hello, World! " print(text.strip()) # "Hello, World!" print(text.lower()) # " hello, world! " print(text.replace("World", "Python")) # " Hello, Python! " print(text.split(",")) # [' Hello', ' World! ']

格式化

name = "张三" age = 25 # f-string print(f"我叫{name}，今年{age}岁") # format() 方法 print("我叫{}，今年{}岁".format(name, age)) # % 格式化 print("我叫%s，今年%d岁" % (name, age))

三、列表（list）

列表是可变的有序序列，用方括号[]表示，可以存放任意类型的元素。

定义方式

# 直接定义 nums = [1, 2, 3, 4, 5] mixed = [1, "hello", 3.14, [1, 2]] # 空列表 empty = [] # list() 构造 chars = list("abc") # ['a', 'b', 'c'] r = list(range(5)) # [0, 1, 2, 3, 4] # 列表推导式 squares = [x**2 for x in range(1, 6)] # [1, 4, 9, 16, 25]

核心操作

nums = [1, 2, 3, 4, 5] # 索引访问和修改 print(nums[0]) # 1 nums[2] = 99 # [1, 2, 99, 4, 5] # 切片 print(nums[1:4]) # [2, 99, 4] print(nums[::-1]) # [5, 4, 99, 2, 1]

常用方法

nums = [1, 2, 3] # 添加 nums.append(4) # [1, 2, 3, 4] nums.insert(0, 0) # [0, 1, 2, 3, 4] nums.extend([5, 6]) # [0, 1, 2, 3, 4, 5, 6] # 删除 last = nums.pop() # 6，nums变为 [0, 1, 2, 3, 4, 5] nums.remove(3) # [0, 1, 2, 4, 5] # 查找 print(nums.index(4)) # 3 print(2 in nums) # True

列表复制

a = [1, 2, 3] # 引用赋值（错误） b = a b.append(4) print(a) # [1, 2, 3, 4] 原列表被修改 # 浅拷贝（正确） a = [1, 2, 3] b = a[:] # 或 list(a) 或 a.copy() b.append(4) print(a) # [1, 2, 3] 原列表不变

四、元组（tuple）

元组是不可变的有序序列，用圆括号()表示。与列表类似，但创建后不能修改。

定义方式

# 直接定义 t1 = (1, 2, 3) t2 = ("a", "b", "c") # 单元素元组（注意逗号） t3 = (1,) # 正确，类型为 tuple t4 = (1) # 错误，类型为 int # 不加括号也可以 t5 = 1, 2, 3 # (1, 2, 3) # tuple() 构造 t6 = tuple([1, 2, 3]) # (1, 2, 3)

核心特性

t = (1, 2, 3, 4, 5) # 索引和切片（与列表相同） print(t[0]) # 1 print(t[1:4]) # (2, 3, 4) # 不可变性 # t[0] = 10 # TypeError: 'tuple' object does not support item assignment # 元组可以包含可变元素 t = (1, 2, [3, 4]) t[2].append(5) # (1, 2, [3, 4, 5]) 元组本身不变，但内部列表变了

元组的常用操作

由于元组不可变，它的方法比列表少：

t = (1, 2, 3, 2, 4, 2) print(t.count(2)) # 3 print(t.index(3)) # 2 print(4 in t) # True

元组的解包

t = (1, 2, 3) a, b, c = t print(a, b, c) # 1 2 3 # 配合 enumerate 使用 for index, value in enumerate([10, 20, 30]): print(index, value) # 0 10, 1 20, 2 30

五、字典（dict）

字典是可变的键值对集合，用花括号{}表示。键必须是不可变类型且唯一，值可以是任意类型。

定义方式

# 直接定义 person = {"name": "张三", "age": 25, "city": "北京"} # 空字典 empty = {} # dict() 构造 person = dict(name="李四", age=30) # {'name': '李四', 'age': 30} person = dict([("name", "王五"), ("age", 28)]) # 从键值对列表 # 字典推导式 squares = {x: x**2 for x in range(1, 6)} # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

核心操作

person = {"name": "张三", "age": 25} # 访问（推荐使用 get 安全访问） print(person["name"]) # 张三 print(person.get("city", "未知")) # 未知（不存在返回默认值） # 添加/修改 person["city"] = "北京" # 添加 person["age"] = 26 # 修改 # 删除 del person["city"] # 删除指定键 age = person.pop("age") # 删除并返回值 person.clear() # 清空

常用方法

字典遍历

person = {"name": "张三", "age": 25, "city": "北京"} # 遍历键 for key in person: print(key) # 遍历值 for value in person.values(): print(value) # 同时遍历键和值（最常用） for key, value in person.items(): print(f"{key}: {value}")

字典与JSON

字典与JSON格式天然对应，可通过json模块互转：

import json # 字典 → JSON字符串（序列化） data = {"name": "张三", "age": 25, "scores": [85, 92]} json_str = json.dumps(data, ensure_ascii=False, indent=2) # JSON字符串 → 字典（反序列化） data = json.loads(json_str)

六、集合（set）

集合是可变的无序集合，元素唯一且必须是可哈希（不可变）类型。用花括号{}表示，但注意空集合必须用set()创建。

定义方式

# 直接定义 s = {1, 2, 3, 4, 5} mixed = {1, "hello", 3.14, (1, 2)} # 元组可以，列表不可以 # 空集合（注意：{} 是空字典） empty = set() # set() 构造 s = set([1, 2, 2, 3, 3, 3]) # {1, 2, 3} 自动去重 s = set("hello") # {'h', 'e', 'l', 'o'}

核心特性

s = {1, 2, 3, 4, 5} # 自动去重 s = {1, 1, 2, 2, 3} # {1, 2, 3} # 无序性（不支持索引） # print(s[0]) # TypeError: 'set' object is not subscriptable # 添加和删除 s.add(6) # {1, 2, 3, 4, 5, 6} s.remove(3) # {1, 2, 4, 5, 6} 不存在会报错 s.discard(10) # 不存在也不会报错 s.pop() # 删除并返回一个任意元素

集合运算

集合支持数学上的各种集合运算：

a = {1, 2, 3, 4} b = {3, 4, 5, 6} print(a | b) # {1, 2, 3, 4, 5, 6} 并集 print(a & b) # {3, 4} 交集 print(a - b) # {1, 2} 差集（属于a不属于b） print(a ^ b) # {1, 2, 5, 6} 对称差集

集合的常用场景

# 1. 列表去重 nums = [1, 2, 2, 3, 3, 3, 4] unique = list(set(nums)) # [1, 2, 3, 4] # 2. 快速判断元素是否存在 s = {1, 2, 3, 4, 5} print(3 in s) # True（集合的 in 操作比列表快得多） # 3. 寻找共同好友/共同标签 friends_a = {"张三", "李四", "王五"} friends_b = {"李四", "王五", "赵六"} common = friends_a & friends_b # {"李四", "王五"}

七、五种数据结构对比总结

八、选择指南

根据实际需求选择合适的数据结构：

# 1. 处理文本 → str text = "Hello, World!" # 2. 需要存储有序的多个值，且可能修改 → list scores = [85, 92, 78, 90] # 3. 需要存储有序的多个值，且不会被修改 → tuple coordinates = (10, 20) # 4. 需要通过键快速查找对应的值 → dict user = {"id": 1001, "name": "张三", "status": "active"} # 5. 需要去重或进行集合运算 → set tags = {"python", "data", "analysis"}

九、类型转换速查

s = "hello" print(list(s)) # ['h', 'e', 'l', 'l', 'o'] print(tuple(s)) # ('h', 'e', 'l', 'l', 'o') print(set(s)) # {'h', 'e', 'l', 'o'} 去重后 lst = [("a", 1), ("b", 2)] print(dict(lst)) # {'a': 1, 'b': 2}

十、总结

Python 的五大核心数据结构各有特点和适用场景，掌握它们之间的区别和联系是写出高质量Python代码的基础：

• str：不可变字符序列，专注文本处理

• list：可变有序序列，使用频率最高

• tuple：不可变有序序列，比列表更轻量、更安全

• dict：可变键值映射，通过键快速查找

• set：可变无序集合，自动去重 + 集合运算

理解每种结构的特点，在实际编码中选出最合适的那一个，代码会变得更清晰、更高效。

如果觉得这篇内容对你有帮助，欢迎收藏备用。