python

Python中的集合可以执行数学集合运算，如判断某个集合是否为另一个集合的子集、并集、交集等，使用运算符或集合方法都可以做到。下面将讨论常见的集合方法。

1、issubset()方法或“<=”“<”求子集

如果集合A中的任意一个项都是集合B中的项，那么集合A称为集合B的子集。集合的issubset()方法用于判断某个集合是否为另一个集合的子集：

1. >>> # 下面三个集合中，b是a的子集， 同时b也是c的子集
2. >>> a = {1, 2, 3}
3. >>> b = {1, 2}
4. >>> c = {1, 2, 4}
5. >>> b.issubset(a)
6. True
7. >>> b.issubset(c)
8. True
9. >>> a.issubset(b) # b是a的子集，但a不是b的子集
10. False
11. >>> c.issubset(a) # a不是c的子集，返回False
12. False
13. >>> a.issubset(a) # 每个集合都一定是自己的子集
14. True

也可以使用“<=”操作符来判断某个集合是否为另一个集合的子集，这与issubset()方法是等价的：

1. >>> a = {1, 2, 3}
2. >>> b = {1, 2}
3. >>> c = {1, 2, 4}
4. >>> b <= a
5. True
6. >>> b <= c
7. True
8. >>> a <= b
9. False
10. >>> c <= a
11. False
12. >>> a <= a
13. True

如果集合A是集合B的子集，但集合A不等于集合B，那么集合A称为集合B的真子集。可以使用“<”操作符来判断某个集合是否为另一个集合的真子集：

1. >>> a = {1, 2, 3}
2. >>> b = {1, 2}
3. >>> b < a # b是a的真子集
4. True
5. >>> a < a # a不是自己的真子集
6. False

2、issuperset()方法或“>=”“>”求超集

与子集对应的是超集。如果集合A是集合B的子集，那么集合B是集合A的超集。集合的issuperset()方法用于判断某个集合是否为另一个集合的超集：

1. >>> # 下面三个集合中，a是b的超集， 同时c也是b的超集
2. >>> a = {1, 2, 3}
3. >>> b = {1, 2}
4. >>> c = {1, 2, 4}
5. >>> a.issuperset(b)
6. True
7. >>> c.issuperset(b)
8. True
9. >>> b.issuperset(a)
10. False
11. >>> a.issuperset(c) # a不是c的超集，返回False
12. False
13. >>> a.issuperset(a) # 每个集合都一定是自己的超集
14. True

也可以使用“>=”操作符来判断某个集合是否为另一个集合的超集，这与issuperset()方法是等价的：

1. >>> a = {1, 2, 3}
2. >>> b = {1, 2}
3. >>> c = {1, 2, 4}
4. >>> a >= b
5. True
6. >>> c >= b
7. True
8. >>> b >= a
9. False
10. >>> a >= c
11. False
12. >>> a >= a
13. True

如果集合A是集合B的超集，但集合A不等于集合B，那么集合A称为集合B的真超集。可以使用“>”操作符来判断某个集合是否为另一个集合的真超集：

1. >>> a = {1, 2, 3}
2. >>> b = {1, 2}
3. >>> a > b # a是b的真超集
4. True
5. >>> a > a # a不是自己的真超集
6. False

3、()方法或“|”求并集

给定两个集合A、B，将它们所有的项合并在一起组成的集合，称为集合A与集合B的并集。集合的()方法用于求集合间的并集：

1. >>> a = {1, 2, 3}
2. >>> b = {2, 3, 4}
3. >>> c = {5, 6, 7}
4. >>> a.(b) # a和b的并集
5. {1, 2, 3, 4}
6. >>> b.(c) # b和c的并集
7. {2, 3, 4, 5, 6, 7}
8. >>> c.(b) # 并集运算满足交换律，即b和c的并集等于c和b的并集
9. {2, 3, 4, 5, 6, 7}

“|”操作符可以用来代替()方法：

1. >>> a = {1, 2, 3}
2. >>> b = {2, 3, 4}
3. >>> c = {5, 6, 7}
4. >>> a | b
5. {1, 2, 3, 4}
6. >>> b | c
7. {2, 3, 4, 5, 6, 7}
8. >>> c | b
9. {2, 3, 4, 5, 6, 7}

多个集合间可以求并集，这种情况下使用“|”操作符往往更方便：

1. >>> a = {1, 2, 3}
2. >>> b = {2, 3, 4}
3. >>> c = {5, 6, 7}
4. >>> a | b | c
5. {1, 2, 3, 4, 5, 6, 7}

4、intersection()方法或“&”求交集

两个集合A和B的交集是含有所有既属于集合A又属于集合B的项，而没有其他项的集合。集合的intersection()方法用于求集合间的交集：

1. >>> a = {1, 2, 3}
2. >>> b = {2, 3, 4}
3. >>> c = {5, 6, 7}
4. >>> a.intersection(b) # a和b的交集
5. {2, 3}
6. >>> b.intersection(a) # 交集运算满足交换律
7. {2, 3}
8. >>> a.intersection(c) # a和c的交集是空集
9. set()

“&”操作符可以用来代替intersection()方法：

1. >>> a = {1, 2, 3}
2. >>> b = {2, 3, 4}
3. >>> c = {3, 5, 6}
4. >>> a & b
5. {2, 3}
6. >>> b & c
7. {3}
8. >>> a & b & c # 多个集合间求交集
9. {3}
10. >>> a & a # 任意一个集合和自己的交集是它本身
11. {1, 2, 3}

5、difference()方法或“-”求差集

集合A与集合B的差集是含有所有属于集合A而不属于集合B的项，而没有其他项的集合。集合的difference()方法用于求集合间的差集：

1. >>> a = {1, 2, 3}
2. >>> b = {2, 3, 4}
3. >>> c = {5, 6, 7}
4. >>> b.difference(c) # b与c的差集
5. {2, 3, 4}
6. >>> a.difference(b) # a与b的差集
7. {1}
8. >>> c.difference(b) # 差集运算不满足交换律
9. {5, 6, 7}

“-”操作符可以用来代替difference()方法：

1. >>> a = {1, 2, 3}
2. >>> b = {2, 3, 4}
3. >>> c = {5, 6, 7}
4. >>> a - b
5. {1}
6. >>> b - c
7. {2, 3, 4}
8. >>> c - b
9. {5, 6, 7}
10. >>> a - a # 任意一个集合与自己的差集是空集
11. set()

6、symmetric_difference()方法或“^”求对称差集

两个集合的对称差集是只属于其中一个集合，而不属于另一个集合的项组成的集合。集合的symmetric_difference()方法用于求集合间的对称差集：

1. >>> a = {1, 2, 3}
2. >>> b = {2, 3, 4}
3. >>> c = {3, 6, 7}
4. >>> a.symmetric_difference(b) # a和b的对称差集
5. {1, 4}
6. >>> b.symmetric_difference(c) # b和c的对称差集
7. {2, 4, 6, 7}
8. >>> b.symmetric_difference(a) # 对称差集运算满足交换律
9. {1, 4}

“^”操作符可以用来代替symmetric_difference()方法：

1. >>> a = {1, 2, 3}
2. >>> b = {2, 3, 4}
3. >>> c = {3, 6, 7}
4. >>> a ^ b
5. {1, 4}
6. >>> b ^ c
7. {2, 4, 6, 7}
8. >>> b ^ a
9. {1, 4}
10. >>> a ^ a # 任意一个集合和自己的对称差集是空集
11. set()