Python入门之集合--集合的定义和操作

# ​集合是指无序的、不可随机访问、不可重复的元素组合，与数学中集合的概念类似，
# 也可以做交并差补等逻辑运算，分为可变集合set和不可变集合frozenset，下面分
# 别介绍两种集合的定义和常规操作。

​
# 可变集合的定义方式
#  方式1： {value, value...}
s = {1, 2, 3}
print(type(s))   # 结果为<class 'set'>
# 方式2： set(iterable)
l = [1, 2, 3]
s1 = set(l)
print(s1, type(s1))   # 结果为{1, 2, 3} <class 'set'>
d = {"name": "Sara", "age": 18}
s2 = set(d)
print(s2, type(s2))   # 结果为{'age', 'name'} <class 'set'>，
# 注意只会把字典中的关键字转换为集合

# 不可变集合的定义
fs = frozenset([1, 2, 3])
print(fs, type(fs))     # 结果为frozenset({1, 2, 3}) <class 'frozenset'>


# 注意事项                 
# 1、定义一个空集合时，不能直接用{}，否则会被当做字典，而需要用zet()或frozenset()   
# 2、集合中的元素必须是可哈希的类型，即在自己的生命周期中有一个哈希
#    值不可变，或可以理解为不可变类型   
# 3、如果集合中的元素出现重复，会被合并  


# 可变集合的常规操作                
# 1、增加元素  s,add(element)   
s = {1, 2, 3}              
s.add(4)                   
print(s)     # 结果为{1, 2, 3,
                           
# 2、删除                     
# 2.1、s.remove() 指定删除集合中特定的
s = {1, 2, 3}              
s.remove(3)                
print(s)     # 结果为{1, 2}   
# 2.2、s.discard(element) 指定
s = {1, 2, 3}              
s.discard(4)               
print(s)     # 结果为{1, 2, 3}
# 2.2、s.pop()  随机删除集合中的一个元素
s = {1, 2, 3}              
s.pop()                    
print(s)     # 结果为{2, 3}   
# 2.3、 s.clear() 清空集合中的内容，但不会删除集合
s = {1, 2, 3}              
s.clear()                  
print(s)    # 结果为set()     

# 3、遍历         
# 方式1：通过for in操作
s = {1, 2, 3}  
for v in s:    
    print(v)   
# 方式2：借助迭代器    
it = iter(s)   
for v in it:   
    print(v)   

# 4、求交集                                                                   
# 方式1、 s1.intersection(s2)                                                
s1 = {1, 2, 3, 4}                                                         
s2 = frozenset([3, 4])                                                    
res = s1.intersection(s2)                                                 
print(res, type(res))      # 结果为{3, 4} <class 'set'> ，
# 注意当可变集合与不可变集合进行运算时，结
# 方式2、用逻辑符合&                                                              
res1 = s2 & s1                                                            
print(res1, type(res1))  # 结果为 frozenset({3, 4}) <class 'frozenset'>  
# 方式3、  s1.intersection_update(s2)，
# s1只能为可变集合，返回值为None，会使s1变为交集，而s2不变 
s1 = {1, 2, 3, 4}                                                    
s2 = frozenset([3, 4, 5])                                            
res = s1.intersection_update(s2)                                     
print(s1, s2)      # 结果为{3, 4} frozenset({3, 4, 5})            

# 5、并集                                                                   
# 方式1、 s1.union(s2)                                                    
s1 = {1, 2, 3, 4}                                                      
s2 = {4, 5, 6}                                                         
res = s1.union(s2)                                                     
print(res, s1, s2)  # 结果为{1, 2, 3, 4, 5, 6} {1, 2, 3, 4} {4, 5, 6}    
# 方式2、利用|逻辑运算符                                                         
res1 = s1 | s2                                                         
print(res1, s1, s2)  # 结果为{1, 2, 3, 4, 5, 6} {1, 2, 3, 4} {4, 5, 6}    
# 方式3、 s1.update(s2) 会改变s1                                             
s1.update(s2)                                                          
print(s1, s2)  # 结果为 {1, 2, 3, 4, 5, 6} {4, 5, 6}                      
  
# 6、差集                                                    
# 方式1、 s1.difference(s2)                                  
s1 = {1, 2, 3, 4}                                         
s2 = {4, 5, 6}                                            
print(s1.difference(s2))   # 结果为 {1, 2, 3}                
# 方式2、 s1.difference_update(s2)，s1会改变                     
res = s1.difference_update(s2)                            
print(res, s1, s2)    # 结果为 None {1, 2, 3} {4, 5, 6} 
# 方式3、利用减法运算                                              
s1 = {1, 2, 3, 4}                                         
s2 = {4, 5, 6}                                            
print(s1 - s2)       # 结果为 {1, 2, 3}                      
                                                          
# 7、判定                                    
# s1.isdisjoint(s2) 判定两个集合是否不相交           
s1 = {1, 2, 3, 4}                         
s2 = {6, 7, 5}                            
print(s1.isdisjoint(s2))     # 结果为True    
# s1.issuperset(s2) 判定s1是否包含s2            
print(s1.issuperset(s2))    # 结果为 False   
# s1.issubset(s2)   判定s1是否是s2的子集          
print(s1.issubset(s2))      # 结果为 False