Python中的set是无序且元素唯一的集合，适用于快速成员检测、去重和集合运算。通过花括号{}或set()创建，支持add、remove、discard等操作，并提供交集(&)、并集(|)、差集(-)、对称差集(^)等数学运算。与列表和元组不同，set不支持索引，元素必须可哈希，常用于高效去重和集合关系处理。注意空集合需用set()创建，且集合操作性能高但内存占用较大。
Python中的
set
set
使用Python的
set
直接使用花括号 {}
my_set = {1, 2, 3, 4, 1} # 重复的1会被自动去除
print(my_set) # 输出: {1, 2, 3, 4} (顺序可能不同)需要注意的是，创建一个空的
set
{}set()
立即学习“Python免费学习笔记（深入）”；
使用 set()
empty_set = set()
print(empty_set) # 输出: set()
from_list = set([1, 2, 2, 3])
print(from_list) # 输出: {1, 2, 3}
from_string = set("hello")
print(from_string) # 输出: {'o', 'e', 'l', 'h'} (同样，顺序不确定，且字符唯一)添加和删除元素：
add(element)
my_set.add(5)
my_set.add(2) # 2已存在，无变化
print(my_set) # 输出: {1, 2, 3, 4, 5}remove(element)
KeyError
my_set.remove(5)
# my_set.remove(99) # 这会引发KeyError
print(my_set) # 输出: {1, 2, 3, 4}discard(element)
remove()
my_set.discard(4)
my_set.discard(99) # 不会报错
print(my_set) # 输出: {1, 2, 3}pop()
set
KeyError
popped_element = my_set.pop()
print(f"移除的元素: {popped_element}, 剩余集合: {my_set}")clear()
my_set.clear() print(my_set) # 输出: set()
集合操作：
set
|
union()
set_a = {1, 2, 3}
set_b = {3, 4, 5}
union_set = set_a | set_b
print(union_set) # 输出: {1, 2, 3, 4, 5}
print(set_a.union(set_b)) # 同样输出: {1, 2, 3, 4, 5}&
intersection()
intersection_set = set_a & set_b
print(intersection_set) # 输出: {3}
print(set_a.intersection(set_b)) # 同样输出: {3}-
difference()
difference_set = set_a - set_b
print(difference_set) # 输出: {1, 2}
print(set_a.difference(set_b)) # 同样输出: {1, 2}^
symmetric_difference()
symmetric_difference_set = set_a ^ set_b
print(symmetric_difference_set) # 输出: {1, 2, 4, 5}
print(set_a.symmetric_difference(set_b)) # 同样输出: {1, 2, 4, 5}成员检测和子集/超集判断：
element in my_set
print(1 in set_a) # 输出: True print(9 in set_a) # 输出: False
issubset()
<=
set_c = {1, 2}
print(set_c.issubset(set_a)) # 输出: True
print(set_c <= set_a) # 同样输出: Trueissuperset()
>=
print(set_a.issuperset(set_c)) # 输出: True print(set_a >= set_c) # 同样输出: True
isdisjoint()
set_d = {6, 7}
print(set_a.isdisjoint(set_d)) # 输出: True
print(set_a.isdisjoint(set_b)) # 输出: False (因为有共同元素3)这个问题问得很好，因为这三者在Python中都是用来存储多个元素的，但它们的设计哲学和适用场景却大相径庭。理解这些差异，是高效选择数据结构的关键。
首先，最核心的区别在于元素的唯一性和元素的顺序性。
列表（List）：它是有序的，可以包含重复的元素。你可以通过索引访问任何位置的元素，并且列表是可变的，意味着你可以添加、删除或修改其中的元素。我们平时处理序列数据，比如一串用户操作记录、一份商品清单（即使商品有重复），列表总是首选。它的有序性保证了数据的输入和输出顺序一致，这在很多业务逻辑中是不可或缺的。
my_list = [1, 2, 3, 2, 1] print(my_list[0]) # 输出: 1 my_list.append(4) print(my_list) # 输出: [1, 2, 3, 2, 1, 4]
元组（Tuple）：它也是有序的，可以包含重复的元素，但它是不可变的。一旦创建，就不能修改其内容。这使得元组在某些场景下比列表更安全，例如作为函数参数传递时，可以确保其内容不会被意外修改。同时，由于其不可变性，元组可以作为字典的键，或者作为集合的元素（而列表不行）。我个人觉得元组更像是一种“固定不变的记录”，比如坐标
(x, y)
(year, month, day)
my_tuple = (1, 2, 3, 2, 1) print(my_tuple[0]) # 输出: 1 # my_tuple.append(4) # 这会报错，元组不可变
集合（Set）：这是今天的主角。它最大的特点是无序的，并且只存储唯一的元素。这意味着你不能通过索引来访问集合中的元素，而且当你创建一个包含重复元素的集合时，重复项会自动被去除。集合是可变的，你可以添加或删除元素，但集合中的元素本身必须是不可变的（可哈希的）。这种设计让它在处理“成员资格”和“去重”问题时表现出色。当你只关心“有什么”而不关心“有多少个”或“在什么位置”时，
set
my_set = {1, 2, 3, 2, 1}
print(my_set) # 输出: {1, 2, 3} (顺序不确定)
# print(my_set[0]) # 这会报错，集合无序，不支持索引
my_set.add(4)
print(my_set) # 输出: {1, 2, 3, 4}从性能角度看，由于
set
in
set
在Python中，
set
高效去重：
最常见的场景就是从一个列表中去除重复项。
set
# 假设我们有一份日志，里面有很多重复的IP地址 log_ips = ["192.168.1.1", "10.0.0.5", "192.168.1.1", "172.16.0.10", "10.0.0.5"] # 去重只需要一步 unique_ips = list(set(log_ips)) print(unique_ips) # 输出: ['192.168.1.1', '10.0.0.5', '172.16.0.10'] (顺序不定) # 如果你不需要保持列表形式，直接用set就可以 unique_ips_set = set(log_ips) print(unique_ips_set)
这种方法利用了
set
高效集合运算：
set
找出共同的元素 (交集)： 假设我们有两个用户群体的ID列表，想知道哪些用户同时属于这两个群体。
group_a_users = {101, 103, 105, 107, 109}
group_b_users = {105, 107, 110, 112, 114}
common_users = group_a_users.intersection(group_b_users)
# 或者 common_users = group_a_users & group_b_users
print(f"共同用户: {common_users}") # 输出: 共同用户: {105, 107}合并所有元素 (并集)： 如果你想知道所有参与过这两个群体的用户有哪些。
all_users = group_a_users.union(group_b_users)
# 或者 all_users = group_a_users | group_b_users
print(f"所有用户: {all_users}") # 输出: 所有用户: {101, 103, 105, 107, 109, 110, 112, 114}找出特定群体独有的元素 (差集)： 想知道A群组中有哪些用户不在B群组中。
a_only_users = group_a_users.difference(group_b_users)
# 或者 a_only_users = group_a_users - group_b_users
print(f"A群组独有用户: {a_only_users}") # 输出: A群组独有用户: {101, 103, 109}找出在任一群组但不同时在两个群组的元素 (对称差集)： 这在找出两个集合中“不重叠”的部分时很有用。
exclusive_users = group_a_users.symmetric_difference(group_b_users)
# 或者 exclusive_users = group_a_users ^ group_b_users
print(f"任一群组独有用户: {exclusive_users}") # 输出: 任一群组独有用户: {101, 103, 109, 110, 112, 114}这些操作不仅代码简洁，而且在Python底层都经过高度优化，对于处理大规模数据集时，性能表现通常非常出色。
另外，值得一提的是
frozenset
set
frozenset
set
set
frozen_set_example = frozenset([1, 2, 3])
# my_set_of_sets = {frozen_set_example, frozenset([3, 4])} # 这样是合法的
# my_set_of_sets = {{1, 2}, {3, 4}} # 这样会报错，因为普通的set是可变的，不可哈希尽管
set
常见的陷阱：
空花括号 {}
set
set()
empty_dict = {}
print(type(empty_dict)) # 输出: <class 'dict'>
empty_set = set()
print(type(empty_set)) # 输出: <class 'set'>这个细节很重要，因为如果你误用
{}集合的元素必须是可哈希的（Hashable）。 这意味着集合不能包含可变的数据类型，比如列表（
list
dict
set
TypeError: unhashable type
# valid_set = {[1, 2]} # 这会报错！list是不可哈希的
valid_set = {1, "hello", (1, 2)} # 数字、字符串、元组都是可哈希的
print(valid_set)这是因为
set
frozenset
remove()
discard()
remove()
KeyError
discard()
remove()
discard()
pop()
set
pop()
pop()
性能考量：
成员检测 (in
set
import time
large_list = list(range(1_000_000))
large_set = set(large_list)
# 列表查找
start = time.time()
_ = 999_999 in large_list
end = time.time()
print(f"列表查找耗时: {end - start:.6f}秒")
# 集合查找
start = time.time()
_ = 999_999 in large_set
end = time.time()
print(f"集合查找耗时: {end - start:.6f}秒")
# 通常会看到集合查找快得多因此，当你的核心需求是频繁地进行成员资格测试时，
set
内存占用。
set
set
集合操作的效率。 像并集、交集、差集这样的集合操作，在
set
创建集合的开销。 从一个列表或其他可迭代对象创建
set
总的来说，
set
以上就是python中set数据类型怎么用_python集合set数据类型操作方法的详细内容，更多请关注php中文网其它相关文章！
python怎么学习？python怎么入门？python在哪学？python怎么学才快？不用担心，这里为大家提供了python速学教程(入门到精通)，有需要的小伙伴保存下载就能学习啦！
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
647
收藏
