常用数据类型操作（六）

集合

• 概念：无序的, 不可随机访问的, 不可重复元素集合
• 定义

  1. 可变集合
     (1) s = {1, 3, 5, 7, 9} 
         print(type(s), s)
  
     (2) """
         语法：set(iterable)
         参数：iterable 可以是字符串、列表、元组、字典等；
              当为字典时，只会提取 key 作为 set 的元素
         """
         s = set("abcdef")
         s = set([1, 3, 5, 7, 9])
         s = set(("王小熊", "秦秦", "超人"))
         s = set({"name": "wxx", "age": 18, "address": "杭州市"})
         print(type(s), s)
  
     (3) 集合推导式
         <1> set(表达式 for 变量 in 列表 if 条件)
             s = set(x ** 2 for x in range(1, 10) if x % 2 == 0)
             print(type(s), s)
  
         <2> {表达式 for 变量 in 列表 if 条件} 
             s = {x ** 2 for x in range(1, 10) if x % 2 == 0}
             print(type(s), s)
  
  2. 不可变集合
     (1) """
         语法：frozenset(iterable)
         参数：iterable 可以是字符串、列表、元组、字典等；
              当为字典时，只会提取 key 作为 set 的元素
         """
         s = frozenset("abcdef")
         s = frozenset([1, 3, 5, 7, 9])
         s = frozenset(("66", "88", "100"))
         s = frozenset({"name": "wxx", "age": 18, "address": "杭州市"})
         print(type(s), s)
  
     (2) frozenset(表达式 for 变量 in 列表 if 条件)
         s = frozenset(x ** 2 for x in range(1, 10) if x % 2 == 0)
         print(type(s), s)
  
  3. 注意
     (1) 创建一个空集合时，需要使用 set() 或者 frozenset()，不能使用 s = {}
     (2) 集合中的元素，必须是可哈希的值，可理解为不可变类型
     (3) 如果集合中的元素值出现重复，则会被合并为 1 个 
  

• 应用

  # 列表去重
  l = [1, 3, 5, 7, 7, 9, 9]
  s = set(l)
  result = list(s)
  print(type(result), result)
  

• 操作
  • 单一集合操作
    • 可变集合

      1 增
        """
        语法：s.add(element)
        注意：必须保证添加的元素是可哈希的值
        """
        s = {1, 3, 5, 7}
        s.add(9)
        print(type(s), s)
      
      2 删
        """
        作用：指定删除集合中的一个元素
        语法：s.remove(element)
        注意：如果集合中没有这个元素，则返回一个错误
        """
        s = {1, 3, 5, 7, 9}
        s.remove(3)
        print(s)
              
        """
        作用：指定删除集合中的一个元素
        语法：s.discard(element)
        注意：如果集合中没有这个元素，则不做任何操作
        """
        s = {1, 3, 5, 7, 9}
        s.discard(5)
        print(s)
      
        """
        作用：随机删除并返回一个集合中的元素
        语法：s.pop(element)
        注意：若集合为空，则返回一个错误
        """
        s = {1, 3, 5, 7, 9}
        result = s.pop()
        print(s)
      
        """
        作用：清空一个集合中的所有元素
        语法：s.clear()
        """
        s = {1, 3, 5, 7, 9}
        s.clear()
        print(s)
        
      3 查
        (1) 通过 for in 进行遍历
            s = {1, 3, 5, 7, 9}
            for v in s:
                print(v)
      
        (2) 通过迭代器进行访问
            s = {1, 3, 5, 7, 9}
            its = iter(s)
            for v in its:
                print(v)
      

    • 不可变集合

      1 查
        (1) 通过 for in 进行遍历
            s = frozenset([1, 3, 5, 7, 9])
            for v in s:
                print(v) 
      
        (2) 通过迭代器进行访问         
            s = frozenset([1, 3, 5, 7, 9])
            its = iter(s)
            for v in its:
                print(v)
      

  • 集合之间操作
    • 交集

      1. intersection
         """
         语法：s.intersection(iterable)
         注意：会先将 iterable 转换为 集合，即进行 set(iterable)操作，再参与运算
         """  
         s1 = {1, 2, 3, 4, 5, 6}
         s2 = {4, 5, 6}
         result = s1.intersection(s2)
         print(type(result), result)
      
      2. 逻辑与 &
         s1 = {1, 2, 3, 4, 5, 6}
         s2 = {4, 5, 6}
         result = s1 & s2
         print(type(result), result)
      
      3. intersection_update
         """
         语法：s.intersection_update(iterable)
         注意：会先将 iterable 转换为 集合，即进行 set(iterable)操作，再参与运算；
              交集计算完毕后，会再次赋值给原对象，只适用于可变集合
         """
         s1 = {"1", "2", "3", "4", "5", "6"}
         s1.intersection_update("456")
         print(type(s1), s1)
      

    • 并集

      1. union
         """
         语法：union(iterable)
         注意：会先将 iterable 转换为 集合，即进行 set(iterable)操作，再参与运算
         """
         s1 = {"1", "2", "3", "4", "5", "6"}
         result = s1.union("56789")
         print(type(result), result)
      
      2. 逻辑或 |
         s1 = {"1", "2", "3", "4", "5", "6"}
         s2 = {"5", "6", "7", "8", "9"}
         result = s1 | s2
         print(type(result), result)
      
      3. update
         """
         语法：s.update(iterable)
         注意：会先将 iterable 转换为 集合，即进行 set(iterable)操作，再参与运算；
              并集计算完毕后，会再次赋值给原对象，只适用于可变集合
         """
         s1 = {"1", "2", "3", "4", "5", "6"}
         s1.update("56789")
         print(type(s1), s1)
      

    • 差集

      1. difference
         """
         语法：difference(iterable)
         注意：会先将 iterable 转换为 集合，即进行 set(iterable)操作，再参与运算
         """
         s1 = {"1", "2", "3", "4", "5", "6"}
         result = s1. difference("56789")
         print(type(result), result)
      
      2. 逻辑差 -
         s1 = {"1", "2", "3", "4", "5", "6"}
         s2 = {"5", "6", "7", "8", "9"}
         result = s1 - s2
         print(type(result), result)
      
      3. difference_update
         """
         语法：s.difference_update(iterable)
         注意：会先将 iterable 转换为 集合，即进行 set(iterable)操作，再参与运算；
              差集计算完毕后，会再次赋值给原对象，只适用于可变集合
         """
         s1 = {"1", "2", "3", "4", "5", "6"}
         s1. difference_update("56789")
         print(type(s1), s1)
      

    • 判定

      1. isdisjoint
         """
         作用：判断两个集合是否不相交
         语法：isdisjoint(iterable)
         注意：会先将 iterable 转换为 集合，即进行 set(iterable)操作，再参与运算
         """
         s1 = {"1", "2", "3", "4", "5", "6"}
         print(s1.isdisjoint("123"))
      
      2. issuperset
         """
         作用：判断一个集合是否包含另一个集合
         语法：issuperset(iterable)
         注意：会先将 iterable 转换为 集合，即进行 set(iterable)操作，再参与运算
         """
         s1 = {"1", "2", "3", "4", "5", "6"}
         print(s1.issuperset("123"))
      
      3. issubset
         """
         作用：判断一个集合是否包含于另一个集合
         语法：issubset(iterable)
         注意：会先将 iterable 转换为 集合，即进行 set(iterable)操作，再参与运算
         """
         s1 = {"1", "2", "3"}
         print(s1.issubset("123456"))
      

    • 注意：可变集合 与 不可变集合 混合运算，返回结果类型以运算符 左侧 为主