Python Set 集合完全指南：使用与遍历详解

原创 于 2026-08-16 11:19:53 发布 · 186 阅读 · 4 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
python学习

当前文章被收录于：

python学习
21 篇文章 0 人学习
订阅专栏 查看详情

1. 什么是 Set 集合？

在 Python 中，Set（集合）是一种无序、不重复元素的数据结构。它基于数学中的集合概念，主要用于成员关系测试和消除重复元素。

Set 的主要特点：

  • 无序性：元素没有固定顺序
  • 唯一性：自动去除重复元素
  • 可变性：可以添加或删除元素（frozenset 除外）
  • 可哈希性：元素必须是不可变类型

2. Set 的创建方法

2.1 使用花括号创建

# 创建包含元素的集合
fruits = {'apple', 'banana', 'orange', 'apple'}
print(fruits)  # 输出: {'banana', 'orange', 'apple'}（重复的 'apple' 被自动去除）

2.2 使用 set() 函数创建

# 从列表创建集合
numbers = set([1, 2, 3, 2, 4, 1])
print(numbers)  # 输出: {1, 2, 3, 4}

# 从字符串创建集合（每个字符作为元素）
chars = set('hello')
print(chars)  # 输出: {'h', 'e', 'l', 'o'}

# 创建空集合（必须使用 set()，不能用 {}）
empty_set = set()
print(type(empty_set))  # 输出: <class 'set'>

2.3 使用集合推导式

# 创建 1-10 的平方集合
squares = {x**2 for x in range(1, 11)}
print(squares)  # 输出: {1, 4, 9, 16, 25, 36, 49, 64, 81, 100}

# 创建只包含偶数的平方集合
even_squares = {x**2 for x in range(1, 11) if x % 2 == 0}
print(even_squares)  # 输出: {16, 4, 36, 100, 64}

3. Set 的基本操作

3.1 添加元素

my_set = {1, 2, 3}

# 添加单个元素
my_set.add(4)
print(my_set)  # 输出: {1, 2, 3, 4}

# 添加多个元素
my_set.update([5, 6, 7])
print(my_set)  # 输出: {1, 2, 3, 4, 5, 6, 7}

# 添加已存在的元素（不会有任何效果）
my_set.add(3)
print(my_set)  # 输出: {1, 2, 3, 4, 5, 6, 7}

3.2 删除元素

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

# remove() - 删除指定元素，元素不存在会报错
my_set.remove(3)
print(my_set)  # 输出: {1, 2, 4, 5}

# discard() - 删除指定元素，元素不存在不会报错
my_set.discard(2)
my_set.discard(10)  # 不会报错
print(my_set)  # 输出: {1, 4, 5}

# pop() - 随机删除并返回一个元素
removed = my_set.pop()
print(f"删除了: {removed}, 剩余: {my_set}")

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

3.3 集合运算

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# 并集
union_set = A | B  # 或 A.union(B)
print(f"并集: {union_set}")  # 输出: {1, 2, 3, 4, 5, 6, 7, 8}

# 交集
intersection_set = A & B  # 或 A.intersection(B)
print(f"交集: {intersection_set}")  # 输出: {4, 5}

# 差集
difference_set = A - B  # 或 A.difference(B)
print(f"A-B差集: {difference_set}")  # 输出: {1, 2, 3}

# 对称差集（只属于一个集合的元素）
symmetric_diff = A ^ B  # 或 A.symmetric_difference(B)
print(f"对称差集: {symmetric_diff}")  # 输出: {1, 2, 3, 6, 7, 8}

4. Set 的遍历方法

4.1 使用 for 循环直接遍历

colors = {'red', 'green', 'blue', 'yellow'}

print("直接遍历集合:")
for color in colors:
    print(f"- {color}")

# 输出示例（顺序可能不同）:
# - red
# - green
# - blue
# - yellow

4.2 使用 enumerate() 获取索引

fruits = {'apple', 'banana', 'orange', 'grape'}

print("带索引的遍历:")
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

# 输出示例（索引从0开始，但顺序不确定）:
# 0: banana
# 1: orange
# 2: apple
# 3: grape

4.3 转换为列表后遍历

numbers = {10, 20, 30, 40, 50}

# 转换为列表（会丢失集合特性，但可以控制顺序）
sorted_numbers = sorted(numbers)  # 按升序排序
print("按升序遍历:")
for num in sorted_numbers:
    print(num)

# 输出:
# 10
# 20
# 30
# 40
# 50

4.4 遍历时修改集合（使用副本）

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

# 错误做法：遍历时直接修改原集合
# for num in original_set:
#     if num % 2 == 0:
#         original_set.remove(num)  # 可能引发 RuntimeError

# 正确做法：遍历副本，修改原集合
print("删除偶数元素:")
for num in original_set.copy():  # 使用副本遍历
    if num % 2 == 0:
        original_set.remove(num)
        print(f"删除了 {num}")

print(f"最终集合: {original_set}")  # 输出: {1, 3, 5}

4.5 使用 while 循环遍历

my_set = {'a', 'b', 'c', 'd'}
set_copy = my_set.copy()  # 创建副本用于遍历

print("使用 while 循环遍历:")
while set_copy:
    element = set_copy.pop()  # 随机弹出元素
    print(f"当前元素: {element}")
    # 可以对原集合进行操作
    if element == 'b':
        my_set.add('new_element')

print(f"原集合最终状态: {my_set}")

5. 高级遍历技巧

5.1 条件遍历

data_set = {15, 22, 8, 31, 45, 12, 7}

print("大于20的元素:")
for num in data_set:
    if num > 20:
        print(num)

print("\n能被3整除的元素:")
divisible_by_3 = {x for x in data_set if x % 3 == 0}
for num in divisible_by_3:
    print(num)

5.2 嵌套集合遍历

# 集合的集合（需要将内层集合转换为 frozenset）
set_of_sets = {
    frozenset({1, 2, 3}),
    frozenset({4, 5, 6}),
    frozenset({7, 8, 9})
}

print("遍历嵌套集合:")
for inner_set in set_of_sets:
    print(f"子集: {set(inner_set)}")
    for element in inner_set:
        print(f"  - {element}")

5.3 遍历集合并执行操作

# 示例：统计字符频率
text = "python programming is fun with python"
words = text.split()
unique_words = set(words)

print("单词统计:")
for word in unique_words:
    count = words.count(word)
    print(f"'{word}': 出现 {count} 次")

# 示例：查找共同兴趣
alice_interests = {'reading', 'coding', 'hiking', 'music'}
bob_interests = {'coding', 'music', 'gaming', 'cooking'}

print("\n共同兴趣:")
common_interests = alice_interests & bob_interests
for interest in common_interests:
    print(f"- {interest}")

6. 性能考虑与最佳实践

6.1 成员测试性能

import time

# 创建大数据集
large_list = list(range(1000000))
large_set = set(large_list)

# 测试列表查找性能
target = 999999
start = time.time()
found_in_list = target in large_list
list_time = time.time() - start

# 测试集合查找性能
start = time.time()
found_in_set = target in large_set
set_time = time.time() - start

print(f"列表查找时间: {list_time:.6f} 秒")
print(f"集合查找时间: {set_time:.6f} 秒")
print(f"集合比列表快 {list_time/set_time:.1f} 倍")

6.2 遍历性能对比

import time

# 准备测试数据
test_data = set(range(1000000))

# 方法1：直接遍历
start = time.time()
total1 = 0
for num in test_data:
    total1 += num
time1 = time.time() - start

# 方法2：转换为列表后遍历
start = time.time()
total2 = 0
for num in list(test_data):
    total2 += num
time2 = time.time() - start

print(f"直接遍历时间: {time1:.4f} 秒")
print(f"转列表后遍历时间: {time2:.4f} 秒")
print(f"直接遍历比转列表快 {time2/time1:.2f} 倍")

6.3 最佳实践总结

  1. 去重优先使用集合：快速去除列表中的重复元素
  2. 成员测试用集合：O(1)时间复杂度 vs 列表的 O(n)
  3. 遍历时不要修改原集合：使用副本或推导式
  4. 需要顺序时先排序：使用 sorted() 获取有序列表
  5. 大数据集考虑性能：集合操作通常比列表更快

7. 实际应用示例

7.1 数据清洗

# 去除重复记录
raw_data = [
    {'id': 1, 'name': 'Alice'},
    {'id': 2, 'name': 'Bob'},
    {'id': 1, 'name': 'Alice'},  # 重复记录
    {'id': 3, 'name': 'Charlie'},
    {'id': 2, 'name': 'Bob'},    # 重复记录
]

# 使用集合记录已处理的ID
processed_ids = set()
clean_data = []

for record in raw_data:
    if record['id'] not in processed_ids:
        processed_ids.add(record['id'])
        clean_data.append(record)

print(f"原始数据: {len(raw_data)} 条")
print(f"清洗后数据: {len(clean_data)} 条")

7.2 标签系统

class TagSystem:
    def __init__(self):
        self.tags = set()
    
    def add_tags(self, *new_tags):
        """添加多个标签"""
        self.tags.update(new_tags)
        print(f"添加标签: {new_tags}")
    
    def remove_tag(self, tag):
        """移除标签"""
        if tag in self.tags:
            self.tags.remove(tag)
            print(f"移除标签: {tag}")
        else:
            print(f"标签不存在: {tag}")
    
    def find_common_tags(self, other_system):
        """查找共同标签"""
        return self.tags & other_system.tags
    
    def display_tags(self):
        """显示所有标签"""
        print("当前标签:")
        for i, tag in enumerate(sorted(self.tags), 1):
            print(f"{i}. {tag}")

# 使用示例
system1 = TagSystem()
system1.add_tags('python', 'programming', 'tutorial')
system1.add_tags('python', 'advanced')  # 重复的 'python' 不会被添加

system2 = TagSystem()
system2.add_tags('python', 'beginner', 'tutorial')

print("\n系统1标签:")
system1.display_tags()

print("\n系统2标签:")
system2.display_tags()

print("\n共同标签:")
common = system1.find_common_tags(system2)
for tag in common:
    print(f"- {tag}")

7.3 权限管理系统

class PermissionManager:
    def __init__(self):
        self.user_permissions = {}
    
    def grant_permissions(self, user, *permissions):
        """授予用户权限"""
        if user not in self.user_permissions:
            self.user_permissions[user] = set()
        self.user_permissions[user].update(permissions)
    
    def revoke_permissions(self, user, *permissions):
        """撤销用户权限"""
        if user in self.user_permissions:
            self.user_permissions[user].difference_update(permissions)
    
    def check_permission(self, user, permission):
        """检查用户是否有特定权限"""
        return user in self.user_permissions and permission in self.user_permissions[user]
    
    def list_user_permissions(self, user):
        """列出用户所有权限"""
        if user in self.user_permissions:
            print(f"{user} 的权限:")
            for perm in sorted(self.user_permissions[user]):
                print(f"  - {perm}")
        else:
            print(f"用户 {user} 没有权限")

# 使用示例
manager = PermissionManager()

# 授予权限
manager.grant_permissions('alice', 'read', 'write', 'delete')
manager.grant_permissions('bob', 'read', 'execute')

# 检查权限
print(f"Alice 有 write 权限: {manager.check_permission('alice', 'write')}")
print(f"Bob 有 delete 权限: {manager.check_permission('bob', 'delete')}")

# 列出权限
manager.list_user_permissions('alice')
manager.list_user_permissions('bob')

# 撤销权限
manager.revoke_permissions('alice', 'delete')
print(f"\n撤销后 Alice 有 delete 权限: {manager.check_permission('alice', 'delete')}")

8. 总结

Python 的 Set 集合是一个强大而高效的数据结构，特别适合处理需要唯一性和快速成员测试的场景。通过本文的学习，你应该已经掌握了：

  1. Set 的创建：使用花括号、set()函数和集合推导式
  2. 基本操作：添加、删除、集合运算等
  3. 多种遍历方法：for循环、enumerate、排序遍历等
  4. 高级技巧：条件遍历、嵌套遍历、性能优化
  5. 实际应用：数据清洗、标签系统、权限管理等

记住集合的核心优势：去重、快速查找、集合运算。在实际编程中，合理使用集合可以显著提高代码的效率和可读性。

最后提示：虽然集合是无序的，但从 Python 3.7 开始，字典和集合的插入顺序会被保留（作为实现细节），但不应依赖这一特性编写代码。如果需要有序集合，请使用 collections.OrderedDict 或排序后的列表。

标签
#python #开发语言
《Python入门到精通》集合 Set 详解
wangyuxiang946的博客
07-24 1万+
「集合」使用大括号{}包裹，「元素」之间使用逗号,间隔，集合中的元素「不会重复」。
Python 集合set详解（超详细）
leoatliang的博客
07-23 3万+
本文主要讲解了在Python中有关集合的一些知识。主要包含构造集合、基本计算、访问项目、内置函数和内置方法等。
【python】集合set详解（超详细）
devil_son1234的博客
02-08 3万+
集合set详解
Python 集合 — set
qq_43629857的博客
09-17 1万+
set（集合）虽然用的很少，但它是一个无序的不重复元素序列，用来简单的去重挺方便的。
Python之集合set遍历元素
热门推荐
王员外的博客
01-04 4万+
不废话，直接干货 0、第一种方式，iter（），迭代器 girl_list= ["美女", "好看的美女", "特别好看的美女"] girl_set = set(girl_list) #嘿嘿，把list转成set，set就接受一个参数 for every in iter(girl_set): print every 1、第二种方式（不支持），使用range（）或者x...
【Python】set遍历
J小白的博客
08-16 1万+
set是一组数，无序，内容不能重复，通过调用set()方法创建，那么如何对set集合进行遍历呢？ 1.简单的set： s1 = set(['111', '222', '333']) 对于s1，是一组数，有几种方法可以遍历： function1：直接用in的方式遍历set集合。 function2：用iter()迭代器来遍历集合 看到前两种方法可能有人就有疑问了，为啥和上面写...
Python中集合（set）的详细使用
m0_74968078的博客
10-30 4994
集合也是存储元素的数据类型。集合中的元素是无序的不重复的，所以我们也无法通过函数找到某个元素的索引。集合的主要作用是去重，不能对集合进行修改、查找、访问单个元素等操作，可以进行添加、删除、整体打印等操作。
Python 集合set
另一个自己
09-03 1万+
可变集合set集合set是Python中一种基本数据类型，它分为可变集合（set）和不可变集合（frozenset）两种。类似于其他语言，集合是一个无序不重复元素集，包括创建集合set、向集合中添加元素、删除集合中的元素、求集合的交集、并集、差集等操作。下面就让我们一一来学习集合的这些知识吧。1、set创建集合set集合类需要的参数必须是迭代器类型的，如：序列、字典等，然后转换成无序不重复的元素集。
Python的set集合详解
wulishinian的博客
04-07 1367
Python 还包含了一个数据类型 —— set （集合）。 集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。 集合对象还支持 union（联合），intersection（交），difference（差）和 sysmmetric difference（对称差集）等数学运算。 创建集合set 大括号或 set() 函数可以用来创建集合。　 set集合类需要的参数必须是迭代器类型的...
二进制与字符编码
KevinChen2019的博客
06-23 3091
计算机为什么能够认识我？ ‘A’ 使用了8个位（bit）来表示，对应的二进制位 01000001，换算成十进制就是65 基本概念 1、bit（位，又名“比特”）：bit的缩写是b，是计算机中的最小数据单位（属于二进制的范畴，其实就是0或者1） 2、Byte（字节）：Byte的缩写是B，是计算机文件大小的基本计算单位。比如一个字符就是1Byte，如果是汉字，则是2Byte。 换算 1B（字节）=8b（位） 1 KB = 1024 B 1 MB = 1024 KB 1 GB = 1024 MB 1TB =
Python中的for循环使用
KevinChen2019的博客
11-15 2570
Python 中的循环语句有 2 种，分别是 while 循环和 for 循环，for 循环它常用于遍历字符串、列表、元组、字典、集合等序列类型，逐个获取序列中的各个元素。 for 循环的语法格式如下： 格式中，迭代变量用于存放从序列类型变量中读取出来的元素，所以一般不会在循环中对迭代变量手动赋值；代码块指的是具有相同缩进格式的多行代码（和 while 一样），由于和循环结构联用，因此代码块又称为...
Python中的while循环使用
KevinChen2019的博客
11-15 2097
while和for都可以使程序重复执行某一段代码（又称作循环体），区别是for循环用于针对集合中的每一个元素都一个代码块，而while循环在表达式为True的情况下会不断地执行，直到指定条件不满足为止。 1、while循环简介 while在英语中的解释是：当…时候 在Python中的语法是： 意味着，当表达式为True的时候，程序会一直执行循环体代码，直至表达式为False。 1.1使用while...
Python中的变量定义和基本数据类型
KevinChen2019的博客
06-27 461
一、变量的定义和使用 变量在内存中是一个带标签的盒子 变量由三部分组成： 1、标识：就是对象所存储的内存地址，使用内置函数 id(obj) 来获取 2、类型：就是对象的数据类型，使用内置函数 type(obj) 来获取 3、值：就是对象所存储的具体数据，使用函数 print(obj) 可以将去打印输出 代码如下： 二、数据类型 2.1 整数类型 int 英文位 integer，简写 int，可以表示正数、负数、零 2.2 浮点类型 float 浮点类型是由整数部分和小数部分组成 2.3 布尔类型
Python 字符串（String）常用方法总结
KevinChen2019的博客
08-11 342
方法描述示例返回字符串的小写版本→"hello"返回字符串的大写版本→"HELLO"将字符串首字母大写，其余小写→将每个单词的首字母大写→交换字符串中的大小写→字符串不可变：所有方法都返回新字符串，原字符串不变。优先使用f-string：Python 3.6+ 推荐使用f-string进行字符串格式化，它更简洁、高效。注意find与index的区别find在未找到时返回-1index会抛出异常，根据场景选择。处理用户输入：使用strip()清理输入两端的空白字符是常见做法。性能考虑。
Python包管理工具pip：从入门到精通
KevinChen2019的博客
06-06 308
pip 是 Python 的包管理工具，全称为 “Pip Installs Packages”。它是 Python 生态系统中最重要的工具之一，用于安装、升级、卸载和管理 Python 包（也称为库或模块）。从 Python Package Index (PyPI) 安装包管理项目依赖关系升级已安装的包卸载不需要的包生成和读取 requirements.txt 文件pip 作为 Python 生态系统的基石，掌握其使用技巧对于 Python 开发者至关重要。提高开发效率。
Python 字符串完全指南：从基础到高级操作
KevinChen2019的博客
06-06 278
在 Python 中，字符串（String）是一种不可变的序列数据类型，用于表示文本数据。字符串由一系列字符组成，可以包含字母、数字、符号和空格。Python 字符串是编程中最常用的数据类型之一，掌握字符串的各种操作对于编写高效、清晰的代码至关重要。本文涵盖了从基础创建、索引切片到高级格式化、编码解码的全面内容。字符串不可变：所有修改操作都会返回新字符串优先使用 f-string：Python 3.6+ 中最简洁高效的格式化方式大量连接用 join()：避免使用 + 连接大量字符串注意编码问题。
Python 字典（dict）类型详解：从基础到高级用法
最新发布
KevinChen2019的博客
08-14 258
Python 字典（dict）是一种内置的、可变的数据结构，用于存储键值对（key-value pairs）的集合。字典中的每个元素都由一个键（key）和对应的值（value）组成，键必须是不可变类型（如字符串、数字、元组），而值可以是任意类型的 Python 对象。字典在 Python 中通过花括号{}创建，使用冒号分隔键和值，元素之间用逗号分隔。# 创建一个空字典# 创建一个包含键值对的字典person = {"age": 30,字典的核心特性是无序。
Python 循环详解：for、while 及高级用法
KevinChen2019的博客
08-11 223
Python 的循环结构强大而灵活。for循环适合遍历已知的序列，而while循环更适合在条件满足时重复执行。通过breakcontinue和else可以精细控制循环流程。掌握enumeratezip和推导式等高级技巧，能让你写出更简洁、高效的 Python 代码。记住，编写循环时要时刻注意循环条件，避免无限循环，并谨慎处理正在迭代的数据结构。
Python 语言的基本数据类型
KevinChen2019的博客
06-11 221
Python 作为一门简洁而强大的编程语言，其数据类型系统是其核心特性之一。理解 Python 的数据类型对于编写高效、可维护的代码至关重要。本文将详细介绍 Python 语言中的基本数据类型，帮助初学者和有一定经验的开发者更好地掌握这一基础概念。Python 的基本数据类型是构建程序的基础，主要包括数字、字符串和布尔值。它们是不可变类型，意味着一旦创建，其值就不能被改变。) 是由 Unicode 字符组成的不可变序列，用于表示文本信息。在 Python 中，Python 支持三种主要的数字类型：整数 (
深入理解常见的字符编码：从ASCII到Unicode
KevinChen2019的博客
06-11 210
字符编码（Character Encoding）是将字符集中的字符映射到二进制数据（字节序列）的规则。简单来说，它定义了如何用计算机能够理解的数字来表示人类可读的文本。ASCII：基础，仅支持英文ISO-8859系列：区域特定，单语言支持GB系列：中文环境专用UTF-8：现代标准，多语言支持，推荐使用在实际开发中，遵循“内部使用UTF-8，对外接口明确编码”的原则，可以避免大多数编码相关问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值