【Python基础知识】Python集合的方法

发布 : Web前端培训      来源:Web前端干货资料

2020-09-11 14:46:28

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()

THE END  

声明:本站稿件版权均属中公教育优就业所有,未经许可不得擅自转载。

领取零基础自学IT资源

涉及方向有Java、Web前端、UI设计、软件测试、python等科目,内容包含学习路线、视频、源码等

点击申请领取资料

点击查看资料详情 

收起 


 相关推荐

问题解答专区
返回顶部