• Python学习之路【第三篇】--集合

    语法结构：　　set1.issubset(set2)
    判断集合set1是否为set2的子集，返回布尔值。

    ?
    1
    2
    3
    4
    5
    6
    s1 = {'Java', 'PHP', 'Python', 'C++'}
    s2 = {'Java', 'Shell', 'Ruby'}
    print(s1.issubset(s2))
     
    输出：
    False
    • issuperset()
      语法结构：　　set1.issuperset(set2)
      判断set1是否为set2的父集。
      ?
      1
      2
      3
      4
      5
      6
      s1 = {'Java', 'PHP', 'Python', 'C++'}
      s2 = {'Java', 'C++'}
      print(s1.issuperset(s2))
       
      输出：
      True
    • isdisjoint()
      语法结构：　　set1.isdisjoint(set2)
      判断set1和set2是否存在交集, 如果不存在返回True， 存在则返回False.
      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      s1 = {'Java', 'PHP', 'Python', 'C++'}
      s2 = {'Java', 'C++'}
      s3 = {'GO'}
      print(s1.isdisjoint(s2))
      print(s1.isdisjoint(s3))
       
      输出：
      False
      True
    • symmetric_difference()
      语法结构：set1.symmetric_difference(set2)或set1 ^ set2
      返回set1和set2的对称式差集，相当于执行set1.difference(set2)和set2.difference(set1)，以新的set集合形式返回set1和set2中差异部分元素（不在两者中同时存在）集合（仅在set1和set2中出现过一次的元素不影响原set1和set2）。
      ?
      1
      2
      3
      4
      5
      6
      7
      8
      s1 = {'Java', 'PHP', 'Python', 'C++'}
      s2 = {'Java', 'Shell', 'Ruby'}
      print(s1.symmetric_difference(s2))
      print(s1 ^ s2)
       
      输出：
      {'PHP', 'Ruby', 'Shell', 'C++', 'Python'}
      {'PHP', 'Ruby', 'Shell', 'C++', 'Python'}
    • symmetric_difference_update()
      语法结构：set1.symmetric_difference(set2)
      返回set1和set2的对称式差集，并覆盖更新原set1集合（原来被调用操作的对象），即执行set1 = set1.symmetric_difference(set2)
      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      s1 = {'Java', 'PHP', 'Python', 'C++'}
      s2 = {'Java', 'Shell', 'Ruby'}
      print(s1.symmetric_difference(s2))
      s1.symmetric_difference_update(s2)
      print(s1)
       
      输出：
      {'PHP', 'C++', 'Shell', 'Python', 'Ruby'}
      {'Python', 'Shell', 'Ruby', 'PHP', 'C++'}
    • intersection()
      语法结构：　　set1.intersection(set2)或set1 & set2
      交集运算，以set方式返回set1和set2的交集部分（同时存在的元素），不影响原集合set1和set2.
      ?
      1
      2
      3
      4
      5
      6
      s1 = {'Java', 'PHP', 'Python', 'C++'}
      s2 = {'Java', 'Shell', 'Ruby'}
      print(s1.intersection(s2))
       
      输出：
      {'Java'}
    • intersection_update()
      语法结构：　　set1.intersection_update(set2)
      执行交集运算，并将结果覆盖更新原集合set1（原来被调用操作的对象）。
      ?
      1
      2
      3
      4
      5
      6
      7
      s1 = {'Java', 'PHP', 'Python', 'C++'}
      s2 = {'Java', 'Shell', 'Ruby'}
      s1.intersection_update(s2)
      print(s1)
       
      输出：
      {'Java'}
    • union()
      语法结构：　　set1.union(set2)或set1 | set2
      执行并集计算，合并set1和set2中的对象并做去重处理，最后以集合形式返回结果。
      综合上述关系运算函数，可确定并集计算相当于对称差集与交集的并集计算，即合并重复重现的对象和不重复出现的对象，set1.union(set2) = (set1.symmetric_difference(set2)).union(set1.intersection(set2))
      ?
      1
      2
      3
      4
      5
      6
      s1 = {'Java', 'PHP', 'Python', 'C++'}
      s2 = {'Java', 'Shell', 'Ruby'}
      print(s1.union(s2))
       
      输出：
      {'Shell', 'PHP', 'Ruby', 'C++', 'Python', 'Java'}
    • update()
      语法结构：　　set1.update(obj)
      往集合中批量添加元素，添加的对象必须是可以迭代的对象（当然如果原集合中存在与迭代对象中重复的元素会做去重处理），本质上是通过循环，把传入的迭代对象逐个添加更新到原集合中。
      ?
      1
      2
      3
      4
      5
      6
      7
      s1 = {'Java', 'PHP', 'Python', 'C++'}
      s2 = {'Java', 'Shell', 'Ruby'}
      s1.update(s2)
      print(s1)
       
      输出：
      {'Python', 'Ruby', 'Shell', 'C++', 'Java', 'PHP'}
    • in 或not in
      成员运算函数同样适用于集合，最后返回布尔值。
      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      s1 = {'Java', 'PHP', 'Python', 'C++'}
      print('Java' in s1)
      if 'Go' in s1:
          print("OK")
      else:
          print("Not OK")
       
      输出：
      True
      Not OK
    • <=
      语法结构：　　set1 <= set2
      判断set1中的每个元素是否都在set2中，即判断set1是否为set2的子集，等同于set1.issubset(set2)
      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      s1 = {'Java', 'PHP', 'Python', 'C++'}
      s2 = {'Java', 'Shell', 'Ruby'}
      s3 = s1.union(s2)
      print(s1 <= s2)
      print(s1.issubset(s2))
      print(s1 <= s3)
      print(s1.issubset(s3))
       
      输出：
      False
      False
      True
      True

     

    3.3 关系测试运算符

    　　常见的关系测试运算符如下：

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    s1 = {'Java', 'PHP', 'Python', 'C++'}
    s2 = {'Java', 'Shell', 'Ruby'}
    print(s1 - s2)
    print(s1.difference(s2))
    print("")
    print(s1 & s2)
    print(s1.intersection(s2))
    print("")
    print(s1 | s2)
    print(s1.union(s2))
    print("")
    print(s1 ^ s2)
    print(s1.symmetric_difference(s2))
    print("")
    print(s1 <= s2)
    print(s1.issubset(s2))
     
    输出：
    {'C++', 'PHP', 'Python'}
    {'C++', 'PHP', 'Python'}
     
    {'Java'}
    {'Java'}
     
    {'C++', 'Python', 'Shell', 'Ruby', 'Java', 'PHP'}
    {'C++', 'Python', 'Shell', 'Ruby', 'Java', 'PHP'}
     
    {'C++', 'Shell', 'Python', 'Ruby', 'PHP'}
    {'C++', 'Shell', 'Python', 'Ruby', 'PHP'}<br><br>False<br>False
  • 相关阅读:
    Atitti 图像处理 图像混合 图像叠加 blend 原理与实现
    Atitit Gaussian Blur 高斯模糊 的原理and实现and 用途
    Atitit 图像处理 灰度图片 灰度化的原理与实现
    Atitit (Sketch Filter)素描滤镜的实现  图像处理  attilax总结
    Atitit 实现java的linq 以及与stream api的比较
    Atitit attilax在自然语言处理领域的成果
    Atitit 图像处理 常用8大滤镜效果 Jhlabs 图像处理类库 java常用图像处理类库
    Atitit 图像处理--图像分类 模式识别 肤色检测识别原理 与attilax的实践总结
    Atitit apache 和guava的反射工具
    atitit。企业的价值观 员工第一 vs 客户第一.docx
  • 原文地址：https://www.cnblogs.com/newstart/p/9590043.html
Copyright © 2020-2023  润新知