Python常用数据类型-------集合

        集合：无序的、不可随机访问的、不可重复的元素集合。集合和其他的数据结构不同，其他要么可变要么不可变，但是集合分为可变集合和不可变集合，不可变集合和可变集合的相关操作不太同，不可变集合的操作可变集合基本都有，但反之就不一样了，所以这里就以可变集合为基准来写。

   集合的创建

# 集合创建主要有两种方式
# 方式1：
s = {1, 2, 3, 'a'}
print(s, type(s))    # {1, 2, 3, 'a'} <class 'set'>

# 方式2:
s = set([1, 2, 3, 'a'])
print(s, type(s))    # {1, 2, 3, 'a'} <class 'set'>

'''
注意点1：不可变集合的创建只有一种方式
        s = frozenset([1, 2, 3, 'a'])    # frozenset({1, 2, 3, 'a'}) <class 'frozenset'>

注意点2：集合里面的元素必须是可hash的(简单理解就是必须为不可变的)，列表等就不能成为其元素

注意点3：空集合的创建必须采用方式2，即必须为 s = set()；若采用方式1创建，即s = {}会被当成空字典    
         处理
'''

   单一集合的操作

      增

# 不可变集合没有增操作，所以这里都是可变集合的
s = {1, 2, 3, 4}
s.add(5)
print(s)    # {1, 2, 3, 4, 5}

'''
注意：添加的元素也必须是可hash的，否则报错
s.add([5])    # TypeError: unhashable type: 'list'
print(s)
'''

     删 

# 删，不可变集合无该操作
s = {666, 888, 555, 333, 222}

# remove()指定删除集合中的一个元素对象，若该元素不存在，报错
s.remove(333)    
print(s)     # {555, 888, 666, 222}


# discard()指定删除集合中的一个元素对象，若该元素不存在，不会做任何其他事情
s.discard(444)
print(s)     # {555, 888, 666, 222}


# pop() 随机删除一个元素对象并返回该元素,当集合为空时，报错
print(s.pop())    # 888
print(s)          # {666, 555, 222}


# clear() 清空集合里面的元素，使其成为一个空集合
s.clear()
print(s)        # set()

    改 

        由定义可知，集合中的元素必须是不可变的，所以集合没有改操作。

    查

# 由于集合是无序的，所以肯定不能索引查找
# 查找可变集合与不可变集合均有
# 集合的查找主要通过for循环或迭代器来进行

# 此处以不可变集合为例，可变集合操作一样

'''
# for循环遍历
s = frozenset(['a', 'b', 'c', '1024', '666'])
for i in s:
    print(i, end=' ')    # 1024 c 666 a b     # 从打印顺序也可以看出集合是无序的
'''


'''
# 迭代器
iter1 = iter(s)
print(next(iter1))    # c
print(next(iter1))    # 666
print(next(iter1))    # a
print(next(iter1))    # b
print(next(iter1))    # 1024
'''

 集合间的操作 

        就像数学里面的集合一样，交集、并集等等。

s1 = {1, 3, 5, 7, 9}
s2 = {2, 4, 6, 8, 3, 5}
s3 = frozenset([2, 4, 6, 8, 3, 5])    # s2与s3元素完全一样，为了后面对比，往下看

# 交集
# 法1：intersection()
test_s1 = s1.intersection(s2)
print(test_s1, type(test_s1))    # {3, 5} <class 'set'>

test_s2 = s1.intersection(s3)
print(test_s2, type(test_s2))    # {3, 5} <class 'set'>

test_s3 = s3.intersection(s1)
print(test_s3, type(test_s3))    # frozenset({3, 5}) <class 'frozenset'>

# 对比test_s2和test_s3结果可知，可变与不可变集合混合运算, 返回结果类型以运算符左侧为主(适用于所有方法，下面也是这个规律，不一一演示了)

# 法2：&
print(s1 & s3)    # {3, 5}

# 法3：intersection_update() 会把结果返回给原对象，相当于改变了原对象的值
s1.intersection_update(s3)
print(s1)    # {3, 5}
# 由于会改变原对象的值，所以不可变集合(frozenset)没有该方法。
# s3.intersection_update(s1)  # 报错



# 并集（规律与上面的一样，所以这里就简单介绍一下三种方法，不一一演示了）
# 法1：union()
# 法2：|
# 法3：update(),同样，不可变集合(frozenset)没有该方法。


# 差集
# 法1：difference()
# 法2：-
# 法3：difference_update(),同样，不可变集合(frozenset)没有该方法。

        个人体会，只要涉及到集合的，就要留一个心眼，元素是否是可hash的。最后关于那个集合间的操作，除了交集写得比较完整之外，并集、差集并没有写得很完善，可以自己按照交集的那种方式验证一下，加强理解。