集合(set)篇（一）

5.1 集合的创建

在Python中，集合（set）是一个无序的不重复元素序列。你可以使用大括号 {} 或者 set() 函数来创建一个集合。下面是一些创建集合的例子：

使用大括号 {} 创建集合：

# 创建一个空集合
empty_set = {}
print(empty_set)  # 输出: set()

# 创建一个包含几个元素的集合
my_set = {1, 2, 3, 4}
print(my_set)  # 输出: {1, 2, 3, 4}

# 集合中的元素必须是不可变类型，例如整数、字符串、元组等
# 下面的例子将引发一个错误，因为列表是可变的
# invalid_set = {[1, 2, 3]}  # TypeError: unhashable type: 'list'

使用 set() 函数创建集合：

# 创建一个空集合
empty_set = set()
print(empty_set)  # 输出: set()

# 创建一个包含几个元素的集合
my_set = set([1, 2, 2, 3, 4, 4])  # 重复的元素会被自动移除
print(my_set)  # 输出: {1, 2, 3, 4}

# 你也可以直接传递元素给set()函数，而不需要创建一个列表
another_set = set(1, 2, 3, 4)  # 错误用法，set()不接受多个位置参数
# 正确的用法是使用set()包裹一个可迭代对象（例如列表、元组等）
correct_set = set([1, 2, 3, 4])
print(correct_set)  # 输出: {1, 2, 3, 4}

请注意，集合是无序的，这意味着你不能依赖元素的插入顺序来遍历集合。此外，集合中的元素必须是可哈希的（hashable），这意味着它们必须是不可变的。因此，你不能在集合中直接存储列表或字典等可变对象。

集合在Python中主要用于成员关系测试和消除重复元素，它们也支持集合运算，如并集、交集、差集等

5.2 交集

在Python中，要计算两个集合（set）的交集，你可以使用&操作符或者intersection()方法。

使用&操作符计算交集：

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# 使用 & 操作符计算交集
intersection = set1 & set2
print(intersection)  # 输出: {3, 4}

使用intersection()方法计算交集：

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# 使用 intersection() 方法计算交集
intersection = set1.intersection(set2)
print(intersection)  # 输出: {3, 4}

这两种方法都会返回一个新的集合，其中包含了set1和set2中共有的元素。

需要注意的是，集合是无序的，因此交集中的元素顺序可能与原始集合中的顺序不同。此外，由于集合不包含重复元素，所以即使原始集合中有重复的元素，交集中也只会出现一次。

如果你想要计算多个集合的交集，你可以连续使用&操作符或者intersection()方法：

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set3 = {4, 5, 7, 8}

# 使用 & 操作符计算多个集合的交集
intersection = set1 & set2 & set3
print(intersection)  # 输出: {4}

# 使用 intersection() 方法计算多个集合的交集
intersection = set1.intersection(set2, set3)
print(intersection)  # 输出: {4}

在这个例子中，set1、set2和set3的交集是{4}，因为只有数字4同时出现在这三个集合中。

5.3 ^ 对称差集

在Python中，^ 符号用于表示集合的对称差集（Symmetric Difference），而不是差集（Difference）。对称差集包括在第一个集合或第二个集合中，但不同时出现在两个集合中的所有元素。

如果你想要计算两个集合的差集，你应该使用 - 符号或者 difference() 方法。但是，如果你想要计算对称差集，你可以使用 ^ 符号或者 symmetric_difference() 方法。

使用 ^ 符号计算对称差集：

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# 使用 ^ 符号计算对称差集
symmetric_difference = set1 ^ set2
print(symmetric_difference)  # 输出: {1, 2, 5, 6}

使用 symmetric_difference() 方法计算对称差集：

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# 使用 symmetric_difference() 方法计算对称差集
symmetric_difference = set1.symmetric_difference(set2)
print(symmetric_difference)  # 输出: {1, 2, 5, 6}

这两种方法都会返回一个新的集合，其中包含了在set1或set2中，但不同时出现在两个集合中的所有元素。

总结来说，- 或 difference() 用于计算差集，而 ^ 或 symmetric_difference() 用于计算对称差集。

5.4 - 差集

在Python中，使用-符号来表示集合的差集。差集运算将返回第一个集合中存在但不在第二个集合中的所有元素。

下面是一个使用-符号计算差集的例子：

# 定义两个集合
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# 使用 - 符号计算差集
difference = set1 - set2

# 输出差集结果
print(difference)  # 输出: {1, 2}

在这个例子中，set1和set2分别包含一些元素。通过执行set1 - set2，我们得到了一个新的集合difference，它只包含那些属于set1但不属于set2的元素。

同样地，你也可以使用difference()方法来计算差集：

# 定义两个集合
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# 使用 difference() 方法计算差集
difference = set1.difference(set2)

# 输出差集结果
print(difference)  # 输出: {1, 2}

这两种方式都会得到相同的结果，即差集{1, 2}，因为这两个元素只存在于set1中，而不存在于set2中

5.5 并集

在Python中，你可以使用 | 符号来表示集合的并集。并集运算将返回两个集合中所有的元素，包括重复的元素只计算一次。

下面是一个使用 | 符号计算并集的例子：

# 定义两个集合
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# 使用 | 符号计算并集
union = set1 | set2

# 输出并集结果
print(union)  # 输出: {1, 2, 3, 4, 5, 6}

在这个例子中，set1 和 set2 分别包含一些元素。通过执行 set1 | set2，我们得到了一个新的集合 union，它包含了 set1 和 set2 中所有的元素。

同样地，你也可以使用 union() 方法来计算并集：

# 定义两个集合
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# 使用 union() 方法计算并集
union = set1.union(set2)

# 输出并集结果
print(union)  # 输出: {1, 2, 3, 4, 5, 6}

这两种方式都会得到相同的结果，即并集 {1, 2, 3, 4, 5, 6}，因为这个集合包含了 set1 和 set2 中所有的元素，且没有重复。

5.6 <= 判断当前集合是否为另一个集合的子集

在Python中，你可以使用 <= 运算符来判断一个集合是否是另一个集合的子集。如果集合A是集合B的子集，那么集合A中的每一个元素都必须在集合B中。

下面是一个使用 <= 运算符来判断集合是否为子集的例子：

# 定义两个集合
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5}

# 使用 <= 运算符判断set1是否是set2的子集
is_subset = set1 <= set2

# 输出判断结果
print(is_subset)  # 输出: True

在这个例子中，set1 包含元素 {1, 2, 3}，而 set2 包含元素 {1, 2, 3, 4, 5}。因为 set1 中的所有元素都出现在 set2 中，所以 set1 是 set2 的子集。因此，set1 <= set2 的结果为 True。

如果你想要判断一个集合是否不是另一个集合的子集，你可以使用 not 关键字来取反：

# 判断set1是否不是set2的子集
is_not_subset = not (set1 <= set2)

# 输出判断结果
print(is_not_subset)  # 输出: False

在这个例子中，set1 确实是 set2 的子集，所以 not (set1 <= set2) 的结果为 False。

5.7 ==

在Python中，== 是一个比较运算符，用于检查两个对象是否相等。对于集合（set）这种数据类型，== 运算符用于比较两个集合是否包含相同的元素。

如果两个集合具有相同的元素（不考虑元素的顺序），则这两个集合被认为是相等的。下面是一个简单的例子：

# 创建两个集合
set1 = {1, 2, 3}
set2 = {3, 2, 1}

# 使用 == 运算符比较这两个集合
result = set1 == set2

# 输出比较结果
print(result)  # 输出: True

在这个例子中，set1 和 set2 包含相同的元素，尽管元素的顺序不同，但它们仍然相等，因此 set1 == set2 的结果是 True。

集合的相等性比较不考虑元素的重复性，也就是说，集合中的元素必须是唯一的。如果两个集合包含相同的元素且每个元素只出现一次，则它们是相等的。

# 创建两个集合
set3 = {1, 2, 2, 3}
set4 = {1, 2, 3}

# 使用 == 运算符比较这两个集合
result = set3 == set4

# 输出比较结果
print(result)  # 输出: True

在这个例子中，set3 虽然包含了重复的元素2，但在转换为集合时，重复的元素会被自动移除，所以 set3 和 set4 实际上是相等的。

总之，对于集合，== 运算符用于检查两个集合是否包含完全相同的元素（不考虑元素的顺序和重复性）。

5.8 >= 判断当前集合是否为另一个集合的超集

在Python中，要判断一个集合是否是另一个集合的超集（superset），可以使用 >= 运算符。如果集合A包含集合B中的所有元素，那么集合A是集合B的超集。使用 >= 运算符时，如果左边的集合是右边的集合的超集，则表达式的结果为 True；否则为 False。

下面是一个例子：

# 创建两个集合
set_a = {1, 2, 3, 4}
set_b = {2, 3}

# 使用 >= 运算符判断 set_a 是否是 set_b 的超集
is_superset = set_a >= set_b

# 输出结果
print(is_superset)  # 输出: True

在这个例子中，set_a 包含 set_b 中的所有元素（2和3），所以 set_a 是 set_b 的超集，因此 set_a >= set_b 的结果是 True。

如果你想判断两个集合是否相等（即它们互为超集），你可以使用 == 运算符，或者同时检查两个方向的不等式：

# 判断两个集合是否相等
are_equal = set_a == set_b

# 或者使用 >= 和 <= 运算符
are_equal_alternative = (set_a >= set_b) and (set_a <= set_b)

# 输出结果
print(are_equal)         # 输出: False
print(are_equal_alternative)  # 输出: False

在这个例子中，set_a 和 set_b 不相等，所以 set_a == set_b 和 (set_a >= set_b) and (set_a <= set_b) 的结果都是 False。