Python学习之路day3

一、概述

　　集合（set）是一种无序且不重复的序列。

　　无序不重复的特点决定它存在以下的应用场景：

• 去重处理
• 关系测试

     差集、并集、交集等，下文详述。

二、创建集合

　　创建集合的方法与创建字典类似，但没有键值对的概念，具体如下：

 　　s1 = {11,22,33}

　　还可以通过以下两种方法创建：

　　 s2 = set()

　　 s3 = set([11,22,33])

　　这两种方法本质上是同一种，都是通过调用系统的set()方法进行参数传递和类型转换，如果不传入参数则直接new一个空的集合；如果传入的参数有重复的元素则直接去重处理。

三、集合的常见函数用法

3.1 元素对象常见操作

• add()
  添加一个元素到指定的集合，每次只能添加一个。
  

  s1 = {"Java", "PHP", "C++"}
  print(s1)
  s1.add("Python")
  print(s1)
  
  输出：
  {'C++', 'PHP', 'Java'}
  {'C++', 'Python', 'PHP', 'Java'}
  

• remove()
  删除集合中指定的对象，一次只能删除一个，如果该对象不存在则报错。
  

  s1 = {'Java', 'PHP', 'Python', 'C++'}
  s1.remove("C++") 
  print(s1)
  s1.remove("C#") #移除不存在的对象
  
  输出：
  Traceback (most recent call last):
    File "D:/python/S13/Day3/set.py", line 8, in <module>
      s1.remove("C#")
  KeyError: 'C#'
  {'Java', 'PHP', 'Python'}  #第一次成功移除C++，C#不存在，移除时报错
  

• discard()
  与remove()类似，也是删除指定的对象，一次只能删除一个，但是如果该对象不存在时不报错。
  

  s1 = {'Java', 'PHP', 'Python', 'C++'}
  s1.discard("C++")
  s1.discard("C#")
  print(s1)
  
  输出：
  {'Python', 'PHP', 'Java'}
  

• pop()
  删除集合中任意一个对象，注意不能指定。
  

  s1 = {'Java', 'PHP', 'Python', 'C++'}
  s1.pop()
  print(s1)
  
  输出：
  运行多次会发现输出的s1不固定

• clear()
  清空集合。
  

  s1 = {'Java', 'PHP', 'Python', 'C++'}
  s1.clear()
  print(s1)
  print(len(s1))
  
  输出：
  set()
  0

 

3.2 关系测试常见操作　

　　关系测试常用于对两个集合的关系判定。

• difference()　
  语法结构：　　set1.difference(set2)或set1 - set2
  

  差集关系运算，以新的set集合形式返回set1中包含，但在set2中不存在的元素集合（不影响原set1和set2）。
  

  s1 = {'Java', 'PHP', 'Python', 'C++'}
  s2 = {'Java', 'Shell', 'Ruby'}
  print(s1.difference(s2))
  print(s1 - s2)
  print(s1)
  print(s2)
  
  输出：
  {'PHP', 'Python', 'C++'}
  {'PHP', 'Python', 'C++'}
  {'PHP', 'Python', 'C++', 'Java'}
  {'Shell', 'Java', 'Ruby'}　

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

  s1 = {'Java', 'PHP', 'Python', 'C++'}
  s2 = {'Java', 'Shell', 'Ruby'}
  print(s1.issubset(s2))
  
  输出：
  False

• issuperset()
  语法结构：　　set1.issuperset(set2)
  判断set1是否为set2的父集。
  

  s1 = {'Java', 'PHP', 'Python', 'C++'}
  s2 = {'Java', 'C++'}
  print(s1.issuperset(s2))
  
  输出：
  True

• isdisjoint()
  语法结构：　　set1.isdisjoint(set2)
  判断set1和set2是否存在交集, 如果不存在返回True， 存在则返回False.
  

  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）。
  

  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)
  

  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.
  

  s1 = {'Java', 'PHP', 'Python', 'C++'}
  s2 = {'Java', 'Shell', 'Ruby'}
  print(s1.intersection(s2))
  
  输出：
  {'Java'}

• intersection_update()
  语法结构：　　set1.intersection_update(set2)
  执行交集运算，并将结果覆盖更新原集合set1（原来被调用操作的对象）。
  

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

  s1 = {'Java', 'PHP', 'Python', 'C++'}
  s2 = {'Java', 'Shell', 'Ruby'}
  print(s1.union(s2))
  
  输出：
  {'Shell', 'PHP', 'Ruby', 'C++', 'Python', 'Java'}

• update()
  语法结构：　　set1.update(obj)
  往集合中批量添加元素，添加的对象必须是可以迭代的对象（当然如果原集合中存在与迭代对象中重复的元素会做去重处理），本质上是通过循环，把传入的迭代对象逐个添加更新到原集合中。
  

  s1 = {'Java', 'PHP', 'Python', 'C++'}
  s2 = {'Java', 'Shell', 'Ruby'}
  s1.update(s2)
  print(s1)
  
  输出：
  {'Python', 'Ruby', 'Shell', 'C++', 'Java', 'PHP'}

• in 或not in
  成员运算函数同样适用于集合，最后返回布尔值。
  

  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)
  

  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 关系测试运算符

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

 

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'}

False
False